NAC_Blockchain/nac-acc-1410/tests/integration_test.rs

use nac_acc_1410::*;
use nac_acc_1410::batch_operations::*;
use nac_acc_1410::cross_partition_transfer::*;
use nac_acc_1410::events::*;
use nac_acc_1410::optimization::*;

#[test]
fn test_complete_workflow() {
    let mut acc1410 = Acc1410::new();

    // 创建分区
    let gnacs = ExtendedGNACS {
        base_gnacs: vec![0x94, 0x01, 0x00, 0x04, 0x02, 0x01],
        extension: GNACSExtension {
            partition_type: 0x01,
            vesting_years: 0,
            voting_multiplier: 1,
            dividend_priority: 1,
        },
    };

    let partition_id = acc1410
        .create_partition("Test Partition".to_string(), gnacs, PartitionType::CommonStock)
        .unwrap();

    // 发行代币
    acc1410.issue_to_partition(&partition_id, "user1", 1000).unwrap();

    // 转账
    acc1410
        .transfer_by_partition("user1", "user2", 300, &partition_id)
        .unwrap();

    // 验证余额
    assert_eq!(
        acc1410
            .balance_of_by_partition(&partition_id, "user1")
            .unwrap(),
        700
    );
    assert_eq!(
        acc1410
            .balance_of_by_partition(&partition_id, "user2")
            .unwrap(),
        300
    );
}

#[test]
fn test_batch_operations_integration() {
    let mut manager = BatchOperationsManager::new();

    // 批量转账
    let request = BatchTransferRequest {
        from: "user1".to_string(),
        recipients: vec![
            ("user2".to_string(), 100),
            ("user3".to_string(), 200),
            ("user4".to_string(), 300),
        ],
        partition_id: [1u8; 32],
        operator: None,
    };

    let result = manager.execute_batch_transfer(&request).unwrap();
    assert_eq!(result.total_operations, 3);
    assert_eq!(result.successful_operations, 3);
    assert_eq!(result.total_amount, 600);

    // 批量铸造
    let mint_request = BatchMintRequest {
        recipients: vec![
            ("user5".to_string(), 1000),
            ("user6".to_string(), 2000),
        ],
        partition_id: [1u8; 32],
    };

    let mint_result = manager.execute_batch_mint(&mint_request).unwrap();
    assert_eq!(mint_result.total_operations, 2);
    assert_eq!(mint_result.total_amount, 3000);

    // 批量销毁
    let burn_request = BatchBurnRequest {
        accounts: vec![
            ("user7".to_string(), 500),
            ("user8".to_string(), 300),
        ],
        partition_id: [1u8; 32],
    };

    let burn_result = manager.execute_batch_burn(&burn_request).unwrap();
    assert_eq!(burn_result.total_operations, 2);
    assert_eq!(burn_result.total_amount, 800);

    // 检查统计
    let stats = manager.get_operation_statistics();
    assert_eq!(stats.total_transfers, 1);
    assert_eq!(stats.total_mints, 1);
    assert_eq!(stats.total_burns, 1);
}

#[test]
fn test_cross_partition_transfer_integration() {
    let mut manager = CrossPartitionTransferManager::new();

    let source_partition = [1u8; 32];
    let dest_partition = [2u8; 32];

    // 创建转账请求
    let request_id = manager
        .create_transfer_request(
            "user1".to_string(),
            "user2".to_string(),
            100,
            source_partition,
            dest_partition,
        )
        .unwrap();

    // 验证转账
    manager.validate_transfer(&request_id).unwrap();

    // 执行转账
    manager.execute_transfer(&request_id).unwrap();

    // 确认转账
    manager.confirm_transfer(&request_id).unwrap();

    // 检查状态
    let request = manager.get_transfer_request(&request_id).unwrap();
    assert_eq!(request.status, TransferStatus::Completed);

    // 检查统计
    let stats = manager.get_transfer_statistics();
    assert_eq!(stats.total_requests, 1);
    assert_eq!(stats.completed_transfers, 1);
}

#[test]
fn test_events_integration() {
    let mut event_manager = EventManager::new();

    // 添加监听器
    let listener = std::sync::Arc::new(ConsoleEventListener::new("test".to_string()));
    event_manager.add_listener(listener);

    // 触发多个事件
    event_manager.emit_event(Acc1410Event::PartitionCreated {
        partition_id: [1u8; 32],
        name: "Test Partition".to_string(),
        partition_type: 1,
    });

    event_manager.emit_event(Acc1410Event::Transfer {
        from: "user1".to_string(),
        to: "user2".to_string(),
        amount: 100,
        partition_id: [1u8; 32],
    });

    event_manager.emit_event(Acc1410Event::Mint {
        to: "user3".to_string(),
        amount: 200,
        partition_id: [1u8; 32],
    });

    // 查询事件
    let recent_events = event_manager.get_recent_events(3);
    assert_eq!(recent_events.len(), 3);

    // 查询账户事件
    let user1_events = event_manager.get_account_events("user1");
    assert_eq!(user1_events.len(), 1);

    // 查询分区事件
    let partition_events = event_manager.get_partition_events(&[1u8; 32]);
    assert_eq!(partition_events.len(), 3);

    // 统计
    let stats = event_manager.get_event_statistics();
    assert_eq!(stats.total_events, 3);
    assert_eq!(stats.partition_created, 1);
    assert_eq!(stats.transfers, 1);
    assert_eq!(stats.mints, 1);
}

#[test]
fn test_optimization_integration() {
    // 测试存储优化
    let storage_optimizer = StorageOptimizer::new(100);
    storage_optimizer.set("key1".to_string(), vec![1, 2, 3], 60);
    
    let value = storage_optimizer.get("key1");
    assert_eq!(value, Some(vec![1, 2, 3]));

    let stats = storage_optimizer.get_cache_stats();
    assert_eq!(stats.cache_hits, 1);

    // 测试计算优化
    let computation_optimizer = ComputationOptimizer::new();
    let result = computation_optimizer.compute("test", || vec![4, 5, 6]);
    assert_eq!(result, vec![4, 5, 6]);

    // 测试Gas优化
    let gas_optimizer = GasOptimizer::new(100);
    let gas = gas_optimizer.estimate_gas("transfer");
    assert_eq!(gas, 21000);

    gas_optimizer.record_gas_usage("transfer".to_string(), 21000);
    let gas_stats = gas_optimizer.get_gas_statistics();
    assert_eq!(gas_stats.total_gas_used, 21000);

    // 测试并发处理
    let concurrent_processor = ConcurrentProcessor::new(4);
    let items: Vec<u32> = (0..100).collect();
    let results = concurrent_processor.process_batch(items, |x| x * 2);
    assert_eq!(results.len(), 100);
}

#[test]
fn test_batch_validation() {
    let manager = BatchOperationsManager::new();

    // 测试有效的批量转账
    let valid_request = BatchTransferRequest {
        from: "user1".to_string(),
        recipients: vec![
            ("user2".to_string(), 100),
            ("user3".to_string(), 200),
        ],
        partition_id: [1u8; 32],
        operator: None,
    };

    let result = manager.validate_batch_transfer(&valid_request);
    assert!(result.all_valid);

    // 测试无效的批量转账（转给自己）
    let invalid_request = BatchTransferRequest {
        from: "user1".to_string(),
        recipients: vec![
            ("user1".to_string(), 100), // 转给自己
        ],
        partition_id: [1u8; 32],
        operator: None,
    };

    let result = manager.validate_batch_transfer(&invalid_request);
    assert!(!result.all_valid);
    assert!(!result.invalid_items.is_empty());
}

#[test]
fn test_event_filtering() {
    let mut event_manager = EventManager::new();

    // 添加多个事件
    event_manager.emit_event(Acc1410Event::Transfer {
        from: "user1".to_string(),
        to: "user2".to_string(),
        amount: 100,
        partition_id: [1u8; 32],
    });

    event_manager.emit_event(Acc1410Event::Transfer {
        from: "user3".to_string(),
        to: "user4".to_string(),
        amount: 200,
        partition_id: [2u8; 32],
    });

    event_manager.emit_event(Acc1410Event::Mint {
        to: "user5".to_string(),
        amount: 300,
        partition_id: [1u8; 32],
    });

    // 按分区过滤
    let filter = EventFilter {
        event_types: None,
        accounts: None,
        partitions: Some(vec![[1u8; 32]]),
        time_range: None,
    };

    let filtered_events = event_manager.query_events(&filter);
    assert_eq!(filtered_events.len(), 2);

    // 按账户过滤
    let filter = EventFilter {
        event_types: None,
        accounts: Some(vec!["user1".to_string()]),
        partitions: None,
        time_range: None,
    };

    let filtered_events = event_manager.query_events(&filter);
    assert_eq!(filtered_events.len(), 1);
}

#[test]
fn test_gas_optimization_suggestions() {
    let gas_optimizer = GasOptimizer::new(100);

    // 记录一些操作
    gas_optimizer.record_gas_usage("transfer".to_string(), 21000);
    gas_optimizer.record_gas_usage("transfer".to_string(), 21000);
    gas_optimizer.record_gas_usage("transfer".to_string(), 21000);

    // 获取优化建议
    let suggestions = gas_optimizer.get_optimization_suggestions();
    assert!(!suggestions.is_empty());
}

#[test]
fn test_cross_partition_transfer_cancellation() {
    let mut manager = CrossPartitionTransferManager::new();

    let source_partition = [1u8; 32];
    let dest_partition = [2u8; 32];

    // 创建转账请求
    let request_id = manager
        .create_transfer_request(
            "user1".to_string(),
            "user2".to_string(),
            100,
            source_partition,
            dest_partition,
        )
        .unwrap();

    // 取消转账
    manager.cancel_transfer(&request_id).unwrap();

    // 检查状态
    let request = manager.get_transfer_request(&request_id).unwrap();
    assert_eq!(request.status, TransferStatus::Cancelled);
}

#[test]
fn test_batch_operations_history() {
    let mut manager = BatchOperationsManager::new();

    // 执行多个批量操作
    for i in 0..5 {
        let request = BatchTransferRequest {
            from: "user1".to_string(),
            recipients: vec![("user2".to_string(), 100)],
            partition_id: [1u8; 32],
            operator: None,
        };
        manager.execute_batch_transfer(&request).unwrap();
    }

    // 检查历史
    let history = manager.get_operation_history();
    assert_eq!(history.len(), 5);

    // 检查统计
    let stats = manager.get_operation_statistics();
    assert_eq!(stats.total_transfers, 5);
    assert_eq!(stats.total_transfer_amount, 500);
}

#[test]
fn test_event_max_log_size() {
    let mut event_manager = EventManager::new();
    event_manager.set_max_log_size(5);

    // 添加10个事件
    for i in 0..10 {
        event_manager.emit_event(Acc1410Event::Transfer {
            from: format!("user{}", i),
            to: format!("user{}", i + 1),
            amount: 100,
            partition_id: [1u8; 32],
        });
    }

    // 日志应该只保留最后5个事件
    let recent_events = event_manager.get_recent_events(10);
    assert_eq!(recent_events.len(), 5);
}

#[test]
fn test_storage_optimizer_expiry() {
    let optimizer = StorageOptimizer::new(100);

    // 设置一个立即过期的缓存
    optimizer.set("key1".to_string(), vec![1, 2, 3], 0);

    // 等待1秒
    std::thread::sleep(std::time::Duration::from_secs(1));

    // 应该无法获取（已过期）
    let value = optimizer.get("key1");
    assert_eq!(value, None);
}