Skip to main content

Testing Framework

Overview​

The Mina Rust node testing infrastructure provides comprehensive testing capabilities for blockchain functionality. The framework is designed around scenario-based testing with deterministic replay capabilities, multi-node orchestration, and cross-implementation compatibility testing.

Testing Architecture​

Core Design Principles​

  1. Scenario-Based Testing: Tests are structured as scenarios - sequences of steps that can be recorded, saved, and replayed deterministically
  2. State Machine Architecture: Follows the Redux-style pattern used throughout the Mina Rust node
  3. Multi-Implementation Support: Tests both Rust (the Mina Rust node) and OCaml (original Mina) nodes
  4. Deterministic Replay: All tests can be replayed exactly using recorded scenarios

Component Overview​

The testing framework consists of several specialized testing areas:

Development Workflow​

Adding New Tests​

  1. Determine test type: Choose the appropriate testing category
  2. Follow existing patterns: Use existing tests as templates
  3. Document purpose: Clear documentation of what is being tested
  4. Integration: Ensure tests run in CI/CD pipeline

Debugging Test Failures​

  1. Check logs: Review detailed test output and node logs
  2. Use network debugger: For scenario and P2P test issues
  3. Reproduce locally: Run failing tests in local environment
  4. State analysis: Examine node state when tests fail

Performance Considerations​

  1. Resource management: Monitor memory and CPU usage during tests
  2. Timeout handling: Set appropriate timeouts for test conditions
  3. Parallel execution: Use cargo-nextest for faster test execution
  4. Cleanup: Ensure proper resource cleanup after tests

Advanced Features​

Deterministic Testing​

The framework provides deterministic test execution through:

  • Time control: Precise control over time progression in tests
  • State recording: Capture exact state transitions
  • Replay capability: Reproduce exact test scenarios
  • Invariant checking: Continuous validation of system properties

Multi-Node Orchestration​

Support for complex multi-node scenarios:

  • Cluster management: Coordinate multiple node instances
  • Synchronization: Ensure proper ordering of operations
  • Network simulation: Control network conditions and failures
  • Cross-implementation: Mix Rust and OCaml nodes in same tests

Network Debugging​

Integration with network debugger provides:

  • Connection inspection: Real-time network monitoring
  • Message tracing: Follow messages through the network
  • Performance analysis: Bandwidth and latency measurements
  • Failure diagnosis: Debug network-related issues

Best Practices​

Test Design​

  1. Start simple: Begin with unit tests, build up to integration tests
  2. Test incrementally: Build complex scenarios from simpler components
  3. Use appropriate tools: Choose right test type for the functionality
  4. Handle edge cases: Include failure scenarios and boundary conditions

Maintenance​

  1. Regular updates: Keep tests updated with code changes
  2. Performance monitoring: Track test execution times
  3. Flaky test management: Identify and fix non-deterministic failures
  4. Documentation: Maintain current test documentation

CI/CD Integration​

Tests are integrated into the continuous integration pipeline:

  • Automated execution: Tests run on every pull request
  • Multiple platforms: Testing across different operating systems
  • Container isolation: Each test runs in clean environment
  • Artifact collection: Test results and logs archived for analysis