6093eac7bf
Wave 64-65 cleanup: Proto regeneration and build system updates from Tonic 0.12→0.14 upgrade Files updated: - Cargo.lock: Dependency resolution for Tonic 0.14.2 - All build.rs: Updated for tonic-prost-build - Proto files: Regenerated with tonic-prost 0.14 - Examples/tests: Updated for new gRPC API 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
555 lines
20 KiB
Rust
555 lines
20 KiB
Rust
//! Compliance automation and report generation tests
|
|
//! Validates automated compliance monitoring and regulatory submission processes
|
|
#![allow(unused_crate_dependencies)]
|
|
|
|
// TODO: Re-enable when compliance module is working
|
|
// use core::compliance::compliance_reporting::*;
|
|
// use chrono::{DateTime, Utc, Duration};
|
|
// use std::collections::HashMap;
|
|
// use tokio;
|
|
|
|
// TODO: Re-enable this entire test file when compliance module is implemented
|
|
/*
|
|
#[tokio::test]
|
|
async fn test_automated_mifid_ii_reporting() {
|
|
// Test automated MiFID II transaction reporting generation
|
|
let config = ComplianceReportingConfig {
|
|
database_url: "postgresql://test:test@localhost/compliance_test".to_string(),
|
|
retention_policies: create_test_retention_policies(),
|
|
encryption_config: create_test_encryption_config(),
|
|
report_templates: create_mifid_report_templates(),
|
|
..Default::default()
|
|
};
|
|
|
|
let reporter = ComplianceReporter::new(config).await.unwrap();
|
|
|
|
// Generate test trading events
|
|
let trading_events = create_test_trading_events(100);
|
|
|
|
for event in &trading_events {
|
|
reporter.log_event(event).await.unwrap();
|
|
}
|
|
|
|
// Generate MiFID II RTS 22 report
|
|
let report_request = ReportRequest {
|
|
report_type: ReportType::MiFIDII_RTS22,
|
|
start_date: Utc::now() - Duration::days(1),
|
|
end_date: Utc::now(),
|
|
format: ReportFormat::XML,
|
|
filters: HashMap::new(),
|
|
};
|
|
|
|
let report = reporter.generate_report(&report_request).await.unwrap();
|
|
|
|
// Verify MiFID II report structure
|
|
assert!(report.content.contains("<?xml version=\"1.0\""));
|
|
assert!(report.content.contains("RTS22"));
|
|
assert!(report.content.contains("transaction"));
|
|
assert!(report.metadata.total_records == trading_events.len());
|
|
assert!(report.metadata.compliance_verified);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_sox_internal_controls_automation() {
|
|
// Test automated SOX internal controls monitoring
|
|
let config = ComplianceReportingConfig {
|
|
database_url: "postgresql://test:test@localhost/compliance_test".to_string(),
|
|
retention_policies: create_test_retention_policies(),
|
|
encryption_config: create_test_encryption_config(),
|
|
report_templates: create_sox_report_templates(),
|
|
..Default::default()
|
|
};
|
|
|
|
let reporter = ComplianceReporter::new(config).await.unwrap();
|
|
|
|
// Simulate SOX control events
|
|
let control_events = vec![
|
|
create_sox_control_event("ACCESS_CONTROL", "USER_LOGIN", true),
|
|
create_sox_control_event("SEGREGATION_DUTIES", "TRADE_APPROVAL", true),
|
|
create_sox_control_event("CHANGE_MANAGEMENT", "SYSTEM_UPDATE", false), // Control failure
|
|
create_sox_control_event("DATA_INTEGRITY", "BACKUP_VERIFICATION", true),
|
|
];
|
|
|
|
for event in &control_events {
|
|
reporter.log_event(event).await.unwrap();
|
|
}
|
|
|
|
// Generate SOX Section 404 report
|
|
let report_request = ReportRequest {
|
|
report_type: ReportType::SOX_Section404,
|
|
start_date: Utc::now() - Duration::days(90), // Quarterly report
|
|
end_date: Utc::now(),
|
|
format: ReportFormat::PDF,
|
|
filters: HashMap::new(),
|
|
};
|
|
|
|
let report = reporter.generate_report(&report_request).await.unwrap();
|
|
|
|
// Verify SOX report contains control testing results
|
|
assert!(report.content.len() > 1000); // PDF should have substantial content
|
|
assert!(report.metadata.total_records == control_events.len());
|
|
assert!(!report.metadata.compliance_verified); // Should be false due to control failure
|
|
|
|
// Check for control effectiveness summary
|
|
let control_summary = reporter.get_control_effectiveness_summary(
|
|
Utc::now() - Duration::days(90),
|
|
Utc::now()
|
|
).await.unwrap();
|
|
|
|
assert!(control_summary.total_controls_tested == 4);
|
|
assert!(control_summary.failed_controls == 1);
|
|
assert!(control_summary.effectiveness_percentage < 100.0);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_iso27001_security_monitoring() {
|
|
// Test automated ISO 27001 security incident monitoring
|
|
let config = ComplianceReportingConfig {
|
|
database_url: "postgresql://test:test@localhost/compliance_test".to_string(),
|
|
retention_policies: create_test_retention_policies(),
|
|
encryption_config: create_test_encryption_config(),
|
|
report_templates: create_iso27001_report_templates(),
|
|
..Default::default()
|
|
};
|
|
|
|
let reporter = ComplianceReporter::new(config).await.unwrap();
|
|
|
|
// Simulate security events
|
|
let security_events = vec![
|
|
create_security_event("FAILED_LOGIN_ATTEMPT", "INFO", "Multiple failed login attempts detected"),
|
|
create_security_event("UNAUTHORIZED_ACCESS", "HIGH", "Unauthorized access attempt to trading system"),
|
|
create_security_event("DATA_BREACH_ATTEMPT", "CRITICAL", "Potential data exfiltration detected"),
|
|
create_security_event("SYSTEM_UPDATE", "LOW", "Security patch applied successfully"),
|
|
];
|
|
|
|
for event in &security_events {
|
|
reporter.log_event(event).await.unwrap();
|
|
}
|
|
|
|
// Generate ISO 27001 security report
|
|
let report_request = ReportRequest {
|
|
report_type: ReportType::ISO27001_SecurityIncidents,
|
|
start_date: Utc::now() - Duration::days(30),
|
|
end_date: Utc::now(),
|
|
format: ReportFormat::JSON,
|
|
filters: HashMap::new(),
|
|
};
|
|
|
|
let report = reporter.generate_report(&report_request).await.unwrap();
|
|
|
|
// Parse JSON report
|
|
let report_data: serde_json::Value = serde_json::from_str(&report.content).unwrap();
|
|
|
|
// Verify security incident categorization
|
|
assert!(report_data["security_incidents"].is_array());
|
|
assert!(report_data["risk_assessment"].is_object());
|
|
assert!(report_data["incident_summary"]["total_incidents"].as_u64().unwrap() == 4);
|
|
assert!(report_data["incident_summary"]["critical_incidents"].as_u64().unwrap() == 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_automated_audit_trail_verification() {
|
|
// Test automated audit trail integrity verification
|
|
let config = ComplianceReportingConfig {
|
|
database_url: "postgresql://test:test@localhost/compliance_test".to_string(),
|
|
retention_policies: create_test_retention_policies(),
|
|
encryption_config: create_test_encryption_config(),
|
|
hash_verification_enabled: true,
|
|
digital_signature_enabled: true,
|
|
..Default::default()
|
|
};
|
|
|
|
let reporter = ComplianceReporter::new(config).await.unwrap();
|
|
|
|
// Create events with audit trail
|
|
let audit_events = create_test_audit_events(50);
|
|
|
|
for event in &audit_events {
|
|
reporter.log_event(event).await.unwrap();
|
|
}
|
|
|
|
// Verify audit trail integrity
|
|
let verification_result = reporter.verify_audit_trail(
|
|
Utc::now() - Duration::hours(1),
|
|
Utc::now()
|
|
).await.unwrap();
|
|
|
|
// Check verification results
|
|
assert!(verification_result.total_records_checked == audit_events.len());
|
|
assert!(verification_result.hash_verification_passed);
|
|
assert!(verification_result.digital_signature_valid);
|
|
assert!(verification_result.integrity_score >= 0.99); // Should be near perfect
|
|
|
|
// Test tamper detection
|
|
let tamper_test_result = reporter.detect_tampering(
|
|
Utc::now() - Duration::hours(1),
|
|
Utc::now()
|
|
).await.unwrap();
|
|
|
|
assert!(!tamper_test_result.tampering_detected);
|
|
assert!(tamper_test_result.chain_integrity_maintained);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_data_retention_automation() {
|
|
// Test automated data retention policy enforcement
|
|
let retention_policies = HashMap::from([
|
|
("TRADING_EVENTS".to_string(), Duration::days(2555)), // 7 years
|
|
("AUDIT_LOGS".to_string(), Duration::days(3650)), // 10 years
|
|
("TEMP_DATA".to_string(), Duration::days(30)), // 30 days
|
|
]);
|
|
|
|
let config = ComplianceReportingConfig {
|
|
database_url: "postgresql://test:test@localhost/compliance_test".to_string(),
|
|
retention_policies,
|
|
encryption_config: create_test_encryption_config(),
|
|
auto_archive_enabled: true,
|
|
..Default::default()
|
|
};
|
|
|
|
let reporter = ComplianceReporter::new(config).await.unwrap();
|
|
|
|
// Create old events that should be archived
|
|
let old_events = vec![
|
|
create_old_event("TRADING_EVENT", Utc::now() - Duration::days(3000)), // Should be kept (< 7 years)
|
|
create_old_event("TEMP_DATA", Utc::now() - Duration::days(60)), // Should be archived (> 30 days)
|
|
create_old_event("AUDIT_LOG", Utc::now() - Duration::days(4000)), // Should be archived (> 10 years)
|
|
];
|
|
|
|
for event in &old_events {
|
|
reporter.log_event(event).await.unwrap();
|
|
}
|
|
|
|
// Run retention policy enforcement
|
|
let retention_result = reporter.enforce_retention_policies().await.unwrap();
|
|
|
|
// Verify retention actions
|
|
assert!(retention_result.records_processed == old_events.len());
|
|
assert!(retention_result.records_archived >= 1); // At least temp data should be archived
|
|
assert!(retention_result.records_retained >= 1); // Trading events should be retained
|
|
|
|
// Verify archived data is compressed and encrypted
|
|
let archive_status = reporter.get_archive_status().await.unwrap();
|
|
assert!(archive_status.total_archived_records > 0);
|
|
assert!(archive_status.compression_ratio > 0.5); // Should achieve some compression
|
|
assert!(archive_status.encryption_verified);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_regulatory_submission_automation() {
|
|
// Test automated regulatory submission preparation
|
|
let config = ComplianceReportingConfig {
|
|
database_url: "postgresql://test:test@localhost/compliance_test".to_string(),
|
|
retention_policies: create_test_retention_policies(),
|
|
encryption_config: create_test_encryption_config(),
|
|
submission_endpoints: create_test_submission_endpoints(),
|
|
..Default::default()
|
|
};
|
|
|
|
let reporter = ComplianceReporter::new(config).await.unwrap();
|
|
|
|
// Generate comprehensive trading data
|
|
let trading_events = create_test_trading_events(1000);
|
|
|
|
for event in &trading_events {
|
|
reporter.log_event(event).await.unwrap();
|
|
}
|
|
|
|
// Prepare MiFID II submission
|
|
let submission_request = SubmissionRequest {
|
|
regulation: "MiFID_II".to_string(),
|
|
submission_type: "RTS22_DAILY".to_string(),
|
|
reporting_date: Utc::now().date_naive(),
|
|
format: SubmissionFormat::XML,
|
|
encrypt_submission: true,
|
|
digital_sign: true,
|
|
};
|
|
|
|
let submission = reporter.prepare_submission(&submission_request).await.unwrap();
|
|
|
|
// Verify submission package
|
|
assert!(submission.file_size > 1000); // Should have substantial content
|
|
assert!(submission.checksum.len() == 64); // SHA-256 hash
|
|
assert!(submission.digital_signature.is_some());
|
|
assert!(submission.encryption_verified);
|
|
|
|
// Test submission validation
|
|
let validation_result = reporter.validate_submission(&submission).await.unwrap();
|
|
assert!(validation_result.schema_valid);
|
|
assert!(validation_result.data_integrity_verified);
|
|
assert!(validation_result.signature_valid);
|
|
|
|
// Verify submission meets regulatory requirements
|
|
assert!(validation_result.regulatory_compliant);
|
|
assert!(validation_result.submission_ready);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_real_time_compliance_monitoring() {
|
|
// Test real-time compliance monitoring and alerting
|
|
let config = ComplianceReportingConfig {
|
|
database_url: "postgresql://test:test@localhost/compliance_test".to_string(),
|
|
retention_policies: create_test_retention_policies(),
|
|
encryption_config: create_test_encryption_config(),
|
|
real_time_monitoring_enabled: true,
|
|
alert_thresholds: create_test_alert_thresholds(),
|
|
..Default::default()
|
|
};
|
|
|
|
let mut reporter = ComplianceReporter::new(config).await.unwrap();
|
|
|
|
// Set up alert subscribers
|
|
let mut violation_receiver = reporter.subscribe_to_violations();
|
|
let mut warning_receiver = reporter.subscribe_to_warnings();
|
|
|
|
// Generate events that should trigger alerts
|
|
let violation_event = create_compliance_violation_event();
|
|
let warning_event = create_compliance_warning_event();
|
|
|
|
reporter.log_event(&violation_event).await.unwrap();
|
|
reporter.log_event(&warning_event).await.unwrap();
|
|
|
|
// Check for real-time alerts
|
|
tokio::time::timeout(Duration::from_millis(1000), async {
|
|
let violation_alert = violation_receiver.recv().await.unwrap();
|
|
assert!(violation_alert.severity == "HIGH");
|
|
assert!(violation_alert.requires_immediate_action);
|
|
|
|
let warning_alert = warning_receiver.recv().await.unwrap();
|
|
assert!(warning_alert.severity == "MEDIUM");
|
|
assert!(!warning_alert.requires_immediate_action);
|
|
}).await.unwrap();
|
|
|
|
// Verify monitoring dashboard metrics
|
|
let metrics = reporter.get_real_time_metrics().await.unwrap();
|
|
assert!(metrics.violations_last_hour >= 1);
|
|
assert!(metrics.warnings_last_hour >= 1);
|
|
assert!(metrics.compliance_score < 100.0); // Should be reduced due to violation
|
|
}
|
|
|
|
// Helper functions for test data creation
|
|
|
|
fn create_test_retention_policies() -> HashMap<String, Duration> {
|
|
HashMap::from([
|
|
("TRADING_EVENTS".to_string(), Duration::days(2555)),
|
|
("AUDIT_LOGS".to_string(), Duration::days(3650)),
|
|
("COMPLIANCE_REPORTS".to_string(), Duration::days(2555)),
|
|
])
|
|
}
|
|
|
|
fn create_test_encryption_config() -> EncryptionConfig {
|
|
EncryptionConfig {
|
|
algorithm: "AES-256".to_string(),
|
|
key_rotation_days: 90,
|
|
hsm_enabled: false,
|
|
key_derivation: "Argon2".to_string(),
|
|
}
|
|
}
|
|
|
|
fn create_mifid_report_templates() -> HashMap<String, String> {
|
|
HashMap::from([
|
|
("RTS22".to_string(), "mifid_rts22_template.xml".to_string()),
|
|
("BEST_EXECUTION".to_string(), "best_execution_template.pdf".to_string()),
|
|
])
|
|
}
|
|
|
|
fn create_sox_report_templates() -> HashMap<String, String> {
|
|
HashMap::from([
|
|
("SECTION_404".to_string(), "sox_404_template.pdf".to_string()),
|
|
("INTERNAL_CONTROLS".to_string(), "internal_controls_template.xlsx".to_string()),
|
|
])
|
|
}
|
|
|
|
fn create_iso27001_report_templates() -> HashMap<String, String> {
|
|
HashMap::from([
|
|
("SECURITY_INCIDENTS".to_string(), "security_incidents_template.json".to_string()),
|
|
("RISK_ASSESSMENT".to_string(), "risk_assessment_template.pdf".to_string()),
|
|
])
|
|
}
|
|
|
|
fn create_test_submission_endpoints() -> HashMap<String, String> {
|
|
HashMap::from([
|
|
("MiFID_II".to_string(), "https://test.esma.europa.eu/submission".to_string()),
|
|
("SOX".to_string(), "https://test.sec.gov/submission".to_string()),
|
|
])
|
|
}
|
|
|
|
fn create_test_alert_thresholds() -> HashMap<String, f64> {
|
|
HashMap::from([
|
|
("VIOLATION_RATE_PER_HOUR".to_string(), 5.0),
|
|
("WARNING_RATE_PER_HOUR".to_string(), 20.0),
|
|
("COMPLIANCE_SCORE_THRESHOLD".to_string(), 85.0),
|
|
])
|
|
}
|
|
|
|
fn create_test_trading_events(count: usize) -> Vec<ComplianceEvent> {
|
|
(0..count).map(|i| ComplianceEvent {
|
|
id: format!("TRADE_{:06}", i),
|
|
event_type: "TRADE_EXECUTION".to_string(),
|
|
timestamp: Utc::now() - Duration::minutes(i as i64),
|
|
data: HashMap::from([
|
|
("instrument".to_string(), "AAPL".to_string()),
|
|
("quantity".to_string(), (100 * (i + 1)).to_string()),
|
|
("price".to_string(), (150.0 + i as f64 * 0.1).to_string()),
|
|
]),
|
|
compliance_status: "COMPLIANT".to_string(),
|
|
risk_score: Some(i as f64 / count as f64 * 10.0),
|
|
}).collect()
|
|
}
|
|
|
|
fn create_sox_control_event(control_type: &str, control_name: &str, passed: bool) -> ComplianceEvent {
|
|
ComplianceEvent {
|
|
id: format!("SOX_{}_{}", control_type, uuid::Uuid::new_v4()),
|
|
event_type: "SOX_CONTROL_TEST".to_string(),
|
|
timestamp: Utc::now(),
|
|
data: HashMap::from([
|
|
("control_type".to_string(), control_type.to_string()),
|
|
("control_name".to_string(), control_name.to_string()),
|
|
("test_result".to_string(), if passed { "PASS" } else { "FAIL" }.to_string()),
|
|
]),
|
|
compliance_status: if passed { "COMPLIANT" } else { "VIOLATION" }.to_string(),
|
|
risk_score: Some(if passed { 1.0 } else { 8.0 }),
|
|
}
|
|
}
|
|
|
|
fn create_security_event(event_type: &str, severity: &str, description: &str) -> ComplianceEvent {
|
|
ComplianceEvent {
|
|
id: format!("SEC_{}_{}", event_type, uuid::Uuid::new_v4()),
|
|
event_type: "SECURITY_EVENT".to_string(),
|
|
timestamp: Utc::now(),
|
|
data: HashMap::from([
|
|
("security_event_type".to_string(), event_type.to_string()),
|
|
("severity".to_string(), severity.to_string()),
|
|
("description".to_string(), description.to_string()),
|
|
]),
|
|
compliance_status: match severity {
|
|
"CRITICAL" | "HIGH" => "VIOLATION",
|
|
"MEDIUM" => "WARNING",
|
|
_ => "COMPLIANT",
|
|
}.to_string(),
|
|
risk_score: Some(match severity {
|
|
"CRITICAL" => 10.0,
|
|
"HIGH" => 8.0,
|
|
"MEDIUM" => 5.0,
|
|
"LOW" => 2.0,
|
|
_ => 1.0,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn create_test_audit_events(count: usize) -> Vec<ComplianceEvent> {
|
|
(0..count).map(|i| ComplianceEvent {
|
|
id: format!("AUDIT_{:06}", i),
|
|
event_type: "AUDIT_LOG".to_string(),
|
|
timestamp: Utc::now() - Duration::minutes(i as i64),
|
|
data: HashMap::from([
|
|
("action".to_string(), "TRADE_VALIDATION".to_string()),
|
|
("user".to_string(), format!("trader_{}", i % 10)),
|
|
("result".to_string(), "SUCCESS".to_string()),
|
|
]),
|
|
compliance_status: "COMPLIANT".to_string(),
|
|
risk_score: Some(1.0),
|
|
}).collect()
|
|
}
|
|
|
|
fn create_old_event(event_type: &str, timestamp: DateTime<Utc>) -> ComplianceEvent {
|
|
ComplianceEvent {
|
|
id: format!("OLD_{}_{}", event_type, uuid::Uuid::new_v4()),
|
|
event_type: event_type.to_string(),
|
|
timestamp,
|
|
data: HashMap::from([
|
|
("legacy_data".to_string(), "test_data".to_string()),
|
|
]),
|
|
compliance_status: "COMPLIANT".to_string(),
|
|
risk_score: Some(1.0),
|
|
}
|
|
}
|
|
|
|
fn create_compliance_violation_event() -> ComplianceEvent {
|
|
ComplianceEvent {
|
|
id: format!("VIOLATION_{}", uuid::Uuid::new_v4()),
|
|
event_type: "COMPLIANCE_VIOLATION".to_string(),
|
|
timestamp: Utc::now(),
|
|
data: HashMap::from([
|
|
("violation_type".to_string(), "POSITION_LIMIT_BREACH".to_string()),
|
|
("severity".to_string(), "HIGH".to_string()),
|
|
]),
|
|
compliance_status: "VIOLATION".to_string(),
|
|
risk_score: Some(9.0),
|
|
}
|
|
}
|
|
|
|
fn create_compliance_warning_event() -> ComplianceEvent {
|
|
ComplianceEvent {
|
|
id: format!("WARNING_{}", uuid::Uuid::new_v4()),
|
|
event_type: "COMPLIANCE_WARNING".to_string(),
|
|
timestamp: Utc::now(),
|
|
data: HashMap::from([
|
|
("warning_type".to_string(), "APPROACHING_LIMIT".to_string()),
|
|
("severity".to_string(), "MEDIUM".to_string()),
|
|
]),
|
|
compliance_status: "WARNING".to_string(),
|
|
risk_score: Some(5.0),
|
|
}
|
|
}
|
|
|
|
// Additional data structures for testing
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct EncryptionConfig {
|
|
algorithm: String,
|
|
key_rotation_days: u32,
|
|
hsm_enabled: bool,
|
|
key_derivation: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct ComplianceEvent {
|
|
id: String,
|
|
event_type: String,
|
|
timestamp: DateTime<Utc>,
|
|
data: HashMap<String, String>,
|
|
compliance_status: String,
|
|
risk_score: Option<f64>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct ReportRequest {
|
|
report_type: ReportType,
|
|
start_date: DateTime<Utc>,
|
|
end_date: DateTime<Utc>,
|
|
format: ReportFormat,
|
|
filters: HashMap<String, String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum ReportType {
|
|
MiFIDII_RTS22,
|
|
SOX_Section404,
|
|
ISO27001_SecurityIncidents,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum ReportFormat {
|
|
XML,
|
|
PDF,
|
|
JSON,
|
|
CSV,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct SubmissionRequest {
|
|
regulation: String,
|
|
submission_type: String,
|
|
reporting_date: NaiveDate,
|
|
format: SubmissionFormat,
|
|
encrypt_submission: bool,
|
|
digital_sign: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum SubmissionFormat {
|
|
XML,
|
|
JSON,
|
|
}*/
|