Testing Guide

Overview

Neo Service Layer provides a comprehensive testing framework designed to ensure reliability, security, and performance across your distributed blockchain applications.

Chaos Engineering Framework

Build resilience through controlled failure injection and recovery testing.

Available Chaos Strategies

// 1. Network Partitioning
await chaosFramework.SimulateNetworkPartitionAsync(
    partition1: new[] { "Node1", "Node2" },
    partition2: new[] { "Node3", "Node4", "Node5" },
    duration: TimeSpan.FromSeconds(30)
);

// 2. Service Instance Failures
await chaosFramework.KillServiceInstancesAsync(
    serviceName: "BlockchainService",
    instancesToKill: 2,
    allowAutoRestart: true
);

// 3. Network Latency Injection
await chaosFramework.InjectNetworkLatencyAsync(
    serviceName: "DatabaseService",
    latency: TimeSpan.FromMilliseconds(500),
    affectedPercentage: 0.3
);

// 4. CPU Stress Testing
await chaosFramework.InjectCpuStressAsync(
    serviceName: "SmartContractsService",
    cpuPercentage: 80,
    duration: TimeSpan.FromMinutes(2)
);

// 5. Memory Pressure
await chaosFramework.InjectMemoryPressureAsync(
    serviceName: "EnclaveStorageService",
    memoryMB: 1024,
    duration: TimeSpan.FromMinutes(2)
);

// 6. Disk I/O Stress
await chaosFramework.InjectDiskIoStressAsync(
    serviceName: "CacheService",
    ioPercentage: 90,
    duration: TimeSpan.FromMinutes(1)
);

// 7. Cascading Failures
await chaosFramework.SimulateCascadingFailureAsync(
    rootService: "DatabaseService",
    dependentServices: new[] { "CacheService", "ApiGateway" },
    cascadeDelay: TimeSpan.FromSeconds(5)
);

6-Phase Chaos Testing Process

1. Baseline Measurement - Establish normal performance metrics
2. Failure Injection - Apply controlled chaos strategies
3. Behavior Monitoring - Track system response and degradation
4. Resilience Testing - Validate fault tolerance mechanisms
5. Recovery Measurement - Assess recovery time and completeness
6. Validation - Verify system state and data integrity

Service Health Testing

Comprehensive health monitoring and dependency validation for all services.

8-Point Health Check System

public async Task<ServiceHealthCheckResult> CheckServiceHealthAsync(string serviceName)
{
    var result = new ServiceHealthCheckResult();
    
    // 1. Basic Connectivity Check
    result.ConnectivityCheck = await TestConnectivityAsync(serviceName);
    
    // 2. Liveness Check
    result.LivenessCheck = await TestLivenessAsync(serviceName);
    
    // 3. Readiness Check
    result.ReadinessCheck = await TestReadinessAsync(serviceName);
    
    // 4. Resource Availability Check
    result.ResourceCheck = await TestResourcesAsync(serviceName);
    
    // 5. Performance Check
    result.PerformanceCheck = await TestPerformanceAsync(serviceName);
    
    // 6. Database Connectivity Check
    result.DatabaseCheck = await TestDatabaseAsync(serviceName);
    
    // 7. External Dependencies Check
    result.DependenciesCheck = await TestDependenciesAsync(serviceName);
    
    // 8. Configuration Validation
    result.ConfigurationCheck = await ValidateConfigurationAsync(serviceName);
    
    return result;
}

Dependency Testing

// Test service dependencies
var dependencyResult = await healthFramework.TestServiceDependenciesAsync(
    serviceName: "BlockchainService",
    checkCircularDependencies: true,
    validateVersions: true
);

// Monitor service health over time
var monitoringResult = await healthFramework.MonitorServiceHealthAsync(
    serviceName: "AuthenticationService",
    duration: TimeSpan.FromMinutes(5),
    checkInterval: TimeSpan.FromSeconds(10)
);

Cross-Service Transaction Testing

Validate distributed transactions across multiple services with different patterns.

Two-Phase Commit Testing

var twoPhaseScenario = new TwoPhaseCommitScenario
{
    Name = "Multi-Service Transaction",
    Participants = new List<string> 
    { 
        "BlockchainService", 
        "EnclaveStorageService", 
        "DatabaseService" 
    },
    TestCoordinatorFailure = true,
    TestParticipantFailure = true
};

var result = await transactionFramework.TestTwoPhaseCommitAsync(twoPhaseScenario);

SAGA Pattern Testing

var sagaScenario = new SagaScenario
{
    Name = "Cross-Chain Asset Transfer",
    Steps = new List<SagaStep>
    {
        new SagaStep
        {
            Name = "Lock Source Assets",
            Service = "BlockchainService",
            Operation = "LockAssets",
            Compensation = new CompensationDefinition
            {
                Operation = "UnlockAssets"
            }
        },
        new SagaStep
        {
            Name = "Verify Cross-Chain",
            Service = "CrossChainService",
            Operation = "VerifyTransfer",
            Compensation = new CompensationDefinition
            {
                Operation = "CancelVerification"
            }
        },
        new SagaStep
        {
            Name = "Mint Target Assets",
            Service = "SmartContractsService",
            Operation = "MintAssets",
            Compensation = new CompensationDefinition
            {
                Operation = "BurnAssets"
            }
        }
    },
    TestIdempotency = true,
    TestEventualConsistency = true
};

var result = await transactionFramework.TestSagaPatternAsync(sagaScenario);

Isolation Level Testing

var isolationScenario = new IsolationLevelScenario
{
    Name = "Serializable Isolation Test",
    IsolationLevel = IsolationLevel.Serializable,
    TestDirtyReads = true,
    TestPhantomReads = true,
    TestDeadlocks = true
};

var result = await transactionFramework.TestTransactionIsolationAsync(isolationScenario);

Test Coverage Analysis

Automated coverage tracking with intelligent recommendations for test improvements.

Coverage Analysis Usage

// Analyze test coverage
var coverageAnalysis = await coverageAnalyzer.AnalyzeCoverageAsync(
    "/path/to/coverage/report.xml"
);

// Generate gap report
var gapReport = coverageAnalyzer.GenerateCoverageGapReport(coverageAnalysis);

// Identify untested files
var untestedFiles = await coverageAnalyzer.IdentifyUntestedFilesAsync();

// Check coverage metrics
Console.WriteLine($"Line Coverage: {coverageAnalysis.OverallCoverage.LineCoverage}%");
Console.WriteLine($"Branch Coverage: {coverageAnalysis.OverallCoverage.BranchCoverage}%");
Console.WriteLine($"Method Coverage: {coverageAnalysis.OverallCoverage.MethodCoverage}%");

// Get recommendations
foreach (var recommendation in coverageAnalysis.Recommendations)
{
    Console.WriteLine($"Priority {recommendation.Priority}: {recommendation.Message}");
}

Coverage Thresholds

Comprehensive Test Scenarios

Pre-built test scenarios covering critical platform operations.

Available Test Scenarios

await TestScenarios.Scenario01_CompleteBlockchainTransactionFlow_WithFailureRecovery();

await TestScenarios.Scenario02_DistributedConsensusUnderPartition();

await TestScenarios.Scenario03_EnclaveSecurityWithAttackSimulation();

await TestScenarios.Scenario04_MultiServiceSagaWithCompensation();

await TestScenarios.Scenario05_HighLoadPerformanceWithDegradation();

await TestScenarios.Scenario06_ServiceHealthMonitoringWithAutoRecovery();

await TestScenarios.Scenario07_TransactionIsolationAndDeadlockPrevention();

await TestScenarios.Scenario08_CascadingFailureContainment();

await TestScenarios.Scenario09_TestCoverageValidation();

await TestScenarios.Scenario10_EndToEndDisasterRecovery();

Testing Best Practices

Test Organization

• Organize tests by feature and service boundaries
• Use descriptive test names that explain the scenario
• Group related tests using test fixtures
• Maintain separate test data factories for each domain

Performance Testing

• Always establish baseline metrics before testing
• Test under realistic load conditions
• Monitor resource utilization during tests
• Implement gradual load increase patterns

Chaos Testing

• Start with small, controlled failures
• Monitor system behavior during chaos injection
• Ensure proper cleanup after chaos tests
• Document failure scenarios and recovery patterns

Coverage Goals

• Aim for 80% line coverage as minimum
• Focus on critical paths and error handling
• Test edge cases and boundary conditions
• Regularly review and update test coverage

Continuous Testing

• Integrate tests into CI/CD pipeline
• Run smoke tests on every commit
• Execute full test suite on pull requests
• Schedule chaos testing in staging environments