283 lines
9.0 KiB
Rust
283 lines
9.0 KiB
Rust
//! CBPP集成测试
|
||
//!
|
||
//! 测试各模块之间的集成和完整的共识流程
|
||
|
||
use nac_cbpp::*;
|
||
use nac_cbpp::fork::ForkChain;
|
||
|
||
#[test]
|
||
fn test_full_consensus_flow() {
|
||
// 1. 创建验证者集合
|
||
let mut validator_set = ValidatorSet::new();
|
||
validator_set.add_validator(Validator::new("validator1".to_string(), 1000));
|
||
validator_set.add_validator(Validator::new("validator2".to_string(), 1000));
|
||
validator_set.add_validator(Validator::new("validator3".to_string(), 1000));
|
||
|
||
// 2. 创建共识引擎
|
||
let mut engine = ConsensusEngine::new();
|
||
engine.set_validator_set(validator_set);
|
||
|
||
// 3. 开始新高度
|
||
engine.start_new_height(1);
|
||
assert_eq!(engine.state(), ConsensusState::NewHeight);
|
||
|
||
// 4. 进入提议阶段
|
||
engine.enter_propose();
|
||
assert_eq!(engine.state(), ConsensusState::Propose);
|
||
|
||
// 5. 创建并验证区块
|
||
let block = Block::new(1, "genesis".to_string(), "validator1".to_string());
|
||
assert!(engine.handle_proposal(block));
|
||
assert_eq!(engine.state(), ConsensusState::Prevote);
|
||
}
|
||
|
||
#[test]
|
||
fn test_block_validation_integration() {
|
||
// 创建区块验证器
|
||
let validator = BlockValidator::new();
|
||
|
||
// 创建区块（使用长地址满足KYC要求）
|
||
let mut block = Block::new(0, "0".repeat(96), "0x1234567890123456789012345678901234567890".to_string());
|
||
block.header.state_root = "0".repeat(64);
|
||
block.header.timestamp = chrono::Utc::now();
|
||
|
||
// 计算Merkle根（空交易列表）
|
||
block.header.merkle_root = "0".repeat(64);
|
||
|
||
// 验证区块
|
||
match validator.validate_block(&block, None) {
|
||
Ok(_) => {},
|
||
Err(e) => panic!("Validation failed: {:?}", e),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn test_signature_integration() {
|
||
// 创建密钥管理器
|
||
let mut key_manager = KeyManager::new();
|
||
|
||
// 生成密钥对
|
||
let (private_key, public_key) = key_manager.generate_key_pair("validator1".to_string()).expect("mainnet: handle error");
|
||
|
||
// 签名消息
|
||
let message = b"Test block";
|
||
let signature = private_key.sign(message);
|
||
|
||
// 验证签名
|
||
assert!(public_key.verify(message, &signature).is_ok());
|
||
|
||
// 创建聚合签名
|
||
let mut aggregate = AggregateSignature::new();
|
||
assert!(aggregate.add_signature(&signature, &public_key).is_ok());
|
||
assert_eq!(aggregate.signer_count(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_timeout_integration() {
|
||
// 创建超时管理器
|
||
let mut timeout_manager = TimeoutManager::with_default_config();
|
||
|
||
// 启动超时
|
||
timeout_manager.start_timeout(
|
||
"proposal_1_0".to_string(),
|
||
TimeoutType::Proposal,
|
||
1,
|
||
0,
|
||
);
|
||
|
||
assert_eq!(timeout_manager.active_timer_count(), 1);
|
||
|
||
// 取消超时
|
||
assert!(timeout_manager.cancel_timeout("proposal_1_0"));
|
||
assert_eq!(timeout_manager.active_timer_count(), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_fork_detection_integration() {
|
||
// 创建分叉检测器
|
||
let mut detector = ForkDetector::new(1);
|
||
|
||
// 添加相同高度的不同区块
|
||
let block1 = Block::new(1, "genesis".to_string(), "validator1".to_string());
|
||
let block2 = Block::new(1, "genesis".to_string(), "validator2".to_string());
|
||
|
||
// 第一个区块不应触发分叉
|
||
assert!(detector.add_block(block1).expect("mainnet: handle error").is_none());
|
||
|
||
// 第二个区块应触发分叉
|
||
let fork = detector.add_block(block2).expect("mainnet: handle error");
|
||
assert!(fork.is_some());
|
||
|
||
// 检查分叉信息
|
||
let fork_info = fork.expect("mainnet: handle error");
|
||
assert_eq!(fork_info.fork_height, 1);
|
||
assert_eq!(fork_info.chains.len(), 2);
|
||
}
|
||
|
||
#[test]
|
||
fn test_fork_choice_integration() {
|
||
// 创建分叉选择器
|
||
let selector = ForkChoiceSelector::new(ForkChoiceRule::LongestChain);
|
||
|
||
// 创建分叉信息
|
||
let mut fork_info = ForkInfo::new("test_fork".to_string(), 1);
|
||
|
||
// 创建两条链
|
||
let mut chain1 = ForkChain::new("chain1".to_string());
|
||
chain1.add_block(Block::new(1, "genesis".to_string(), "v1".to_string()));
|
||
|
||
let mut chain2 = ForkChain::new("chain2".to_string());
|
||
chain2.add_block(Block::new(1, "genesis".to_string(), "v2".to_string()));
|
||
chain2.add_block(Block::new(2, "block1".to_string(), "v2".to_string()));
|
||
|
||
fork_info.add_chain(chain1);
|
||
fork_info.add_chain(chain2);
|
||
|
||
// 选择最佳链
|
||
let best_chain = selector.select_best_chain(&fork_info).expect("mainnet: handle error");
|
||
assert_eq!(best_chain.id, "chain2");
|
||
assert_eq!(best_chain.length(), 2);
|
||
}
|
||
|
||
#[test]
|
||
fn test_complete_consensus_with_validation() {
|
||
// 创建完整的共识环境
|
||
let mut validator_set = ValidatorSet::new();
|
||
validator_set.add_validator(Validator::new("v1".to_string(), 1000));
|
||
validator_set.add_validator(Validator::new("v2".to_string(), 1000));
|
||
validator_set.add_validator(Validator::new("v3".to_string(), 1000));
|
||
|
||
let mut engine = ConsensusEngine::new();
|
||
engine.set_validator_set(validator_set);
|
||
|
||
let block_validator = BlockValidator::new();
|
||
let mut key_manager = KeyManager::new();
|
||
|
||
// 生成验证者密钥
|
||
for i in 1..=3 {
|
||
key_manager.generate_key_pair(format!("v{}", i)).expect("mainnet: handle error");
|
||
}
|
||
|
||
// 开始共识
|
||
engine.start_new_height(1);
|
||
engine.enter_propose();
|
||
|
||
// 创建并验证区块（使用长地址满足KYC要求）
|
||
let mut block = Block::new(0, "0".repeat(96), "0x1234567890123456789012345678901234567890".to_string());
|
||
block.header.state_root = "0".repeat(64);
|
||
block.header.timestamp = chrono::Utc::now();
|
||
block.header.merkle_root = "0".repeat(64);
|
||
|
||
// 验证区块
|
||
assert!(block_validator.validate_block(&block, None).is_ok());
|
||
|
||
// 处理提议
|
||
assert!(engine.handle_proposal(block));
|
||
}
|
||
|
||
#[test]
|
||
fn test_timeout_with_recovery() {
|
||
use std::thread;
|
||
use std::time::Duration;
|
||
|
||
// 创建超时管理器（短超时用于测试）
|
||
let mut config = TimeoutConfig::default_config();
|
||
config.proposal_timeout = 1; // 1秒
|
||
let mut timeout_manager = TimeoutManager::new(config).expect("mainnet: handle error");
|
||
|
||
// 启动超时
|
||
timeout_manager.start_timeout(
|
||
"test_timeout".to_string(),
|
||
TimeoutType::Proposal,
|
||
1,
|
||
0,
|
||
);
|
||
|
||
// 等待超时
|
||
thread::sleep(Duration::from_secs(2));
|
||
|
||
// 检查超时事件
|
||
let events = timeout_manager.check_timeouts();
|
||
assert_eq!(events.len(), 1);
|
||
assert_eq!(events[0].timeout_type, TimeoutType::Proposal);
|
||
}
|
||
|
||
#[test]
|
||
fn test_compliance_checking() {
|
||
let mut validator = BlockValidator::new();
|
||
|
||
// 添加黑名单地址
|
||
validator.compliance_checker_mut().add_to_blacklist("0x_malicious".to_string());
|
||
|
||
// 创建区块
|
||
let block = Block::new(1, "genesis".to_string(), "0x_malicious".to_string());
|
||
|
||
// 应该失败（提议者在黑名单中）
|
||
assert!(validator.validate_block(&block, None).is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn test_aggregate_signature_verification() {
|
||
let mut key_manager = KeyManager::new();
|
||
|
||
// 生成多个密钥对
|
||
let (pk1, pub1) = key_manager.generate_key_pair("v1".to_string()).expect("mainnet: handle error");
|
||
let (pk2, pub2) = key_manager.generate_key_pair("v2".to_string()).expect("mainnet: handle error");
|
||
let (pk3, pub3) = key_manager.generate_key_pair("v3".to_string()).expect("mainnet: handle error");
|
||
|
||
// 签名相同消息
|
||
let message = b"Block proposal";
|
||
let sig1 = pk1.sign(message);
|
||
let sig2 = pk2.sign(message);
|
||
let sig3 = pk3.sign(message);
|
||
|
||
// 创建聚合签名
|
||
let mut aggregate = AggregateSignature::new();
|
||
assert!(aggregate.add_signature(&sig1, &pub1).is_ok());
|
||
assert!(aggregate.add_signature(&sig2, &pub2).is_ok());
|
||
assert!(aggregate.add_signature(&sig3, &pub3).is_ok());
|
||
|
||
assert_eq!(aggregate.signer_count(), 3);
|
||
assert!(aggregate.verify(message).is_ok());
|
||
}
|
||
|
||
#[test]
|
||
fn test_fork_prevention() {
|
||
let mut prevention = ForkPrevention::new(3, 1000);
|
||
|
||
// 添加恶意验证者到黑名单
|
||
prevention.add_to_blacklist("malicious_validator".to_string());
|
||
|
||
// 创建由恶意验证者提议的区块
|
||
let block = Block::new(1, "genesis".to_string(), "malicious_validator".to_string());
|
||
|
||
// 应该被阻止
|
||
assert!(prevention.check_block(&block).is_err());
|
||
|
||
// 正常验证者应该通过
|
||
let good_block = Block::new(1, "genesis".to_string(), "good_validator".to_string());
|
||
assert!(prevention.check_block(&good_block).is_ok());
|
||
}
|
||
|
||
#[test]
|
||
fn test_multi_round_consensus() {
|
||
let mut validator_set = ValidatorSet::new();
|
||
validator_set.add_validator(Validator::new("v1".to_string(), 1000));
|
||
validator_set.add_validator(Validator::new("v2".to_string(), 1000));
|
||
|
||
let mut engine = ConsensusEngine::new();
|
||
engine.set_validator_set(validator_set);
|
||
|
||
// 第一轮
|
||
engine.start_new_height(1);
|
||
engine.enter_propose();
|
||
let block1 = Block::new(1, "genesis".to_string(), "v1".to_string());
|
||
assert!(engine.handle_proposal(block1));
|
||
|
||
// 第二轮
|
||
engine.start_new_height(2);
|
||
engine.enter_propose();
|
||
let block2 = Block::new(2, "block1".to_string(), "v2".to_string());
|
||
assert!(engine.handle_proposal(block2));
|
||
}
|