# Ordo Testing > Ordo testing and benchmarking guide. Includes unit tests, integration tests, Criterion benchmarks, k6 load tests, CI configuration. Use for writing tests, performance analysis, continuous integration. Use when this capability is needed. - Skill: `tomevault-io/ordo-testing` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds@latest add tomevault-io/ordo-testing` - Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/ordo-testing/raw - Safety review: pending (external: skill-scanner PASS, skillspector PASS) - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Integrations & APIs - Author: tomevault-io (https://skillmd.com/u/tomevault-io) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/tomevault-io/ordo-testing --- # Ordo Testing and Benchmarking ## Unit Tests ### Running Tests ```bash # Run all tests cargo test # Run specific crate cargo test --package ordo-core cargo test --package ordo-server # Run specific test cargo test test_full_workflow # Show output cargo test -- --nocapture # Parallel control cargo test -- --test-threads=4 ``` ### Test Example ```rust #[cfg(test)] mod tests { use super::*; use ordo_core::prelude::*; #[test] fn test_rule_execution() { let mut ruleset = RuleSet::new("test", "start"); ruleset.add_step( Step::decision("start", "Start") .branch(Condition::from_string("value > 10"), "high") .default("low") .build() ); ruleset.add_step(Step::terminal("high", "High", TerminalResult::new("HIGH"))); ruleset.add_step(Step::terminal("low", "Low", TerminalResult::new("LOW"))); let executor = RuleExecutor::new(); // Test high value let input: Value = serde_json::from_str(r#"{"value": 20}"#).unwrap(); let result = executor.execute(&ruleset, input).unwrap(); assert_eq!(result.code, "HIGH"); // Test low value let input: Value = serde_json::from_str(r#"{"value": 5}"#).unwrap(); let result = executor.execute(&ruleset, input).unwrap(); assert_eq!(result.code, "LOW"); } #[test] fn test_expression_eval() { let evaluator = Evaluator::new(); let parser = ExprParser::new(); let expr = parser.parse("age >= 18 && status == \"active\"").unwrap(); let ctx = Context::from_json(r#"{"age": 25, "status": "active"}"#).unwrap(); let result = evaluator.eval(&expr, &ctx).unwrap(); assert_eq!(result, Value::Bool(true)); } } ``` ## Integration Tests ### gRPC Tests ```bash cargo test --package ordo-server --test grpc_test ``` ### UDS Tests ```bash cargo test --package ordo-server --test uds_test ``` ## Benchmarks ### Running Criterion Benchmarks ```bash # All benchmarks cargo bench --package ordo-core # Specific benchmarks cargo bench --package ordo-core --bench engine_bench cargo bench --package ordo-core --bench jit_comparison_bench cargo bench --package ordo-core --bench schema_jit_bench cargo bench --package ordo-core --bench optimization_bench ``` ### Benchmark Files | File | Description | |------|-------------| | `engine_bench.rs` | Overall engine performance | | `jit_comparison_bench.rs` | JIT vs interpreter comparison | | `jit_realistic_bench.rs` | Realistic JIT scenarios | | `jit_stress_bench.rs` | JIT stress testing | | `schema_jit_bench.rs` | Schema JIT performance | | `optimization_bench.rs` | Optimization effectiveness | ### Writing Benchmarks ```rust use criterion::{black_box, criterion_group, criterion_main, Criterion}; use ordo_core::prelude::*; fn bench_rule_execution(c: &mut Criterion) { let mut ruleset = RuleSet::new("bench", "start"); // ... setup rules let executor = RuleExecutor::new(); let input: Value = serde_json::from_str(r#"{"value": 100}"#).unwrap(); c.bench_function("rule_execution", |b| { b.iter(|| { executor.execute(&ruleset, black_box(input.clone())) }) }); } criterion_group!(benches, bench_rule_execution); criterion_main!(benches); ``` ## k6 Load Testing ### Running Load Tests ```bash # Basic test ./scripts/benchmark.sh # Custom parameters ./scripts/benchmark.sh \ -h localhost \ -p 8080 \ -d 60s \ -u 50 \ -r 500 \ --rule order_discount \ --analyze ``` ### Parameter Reference | Parameter | Description | Default | |-----------|-------------|---------| | `-h, --host` | Server address | localhost | | `-p, --port` | Port | 8080 | | `-d, --duration` | Test duration | 30s | | `-u, --vus` | Virtual users | 10 | | `-r, --rps` | Target RPS | 100 | | `--rule` | Rule name to test | order_discount | | `--analyze` | Show CPU analysis | false | ### Custom k6 Script ```javascript import http from 'k6/http'; import { check } from 'k6'; export const options = { scenarios: { constant_load: { executor: 'constant-arrival-rate', rate: 100, timeUnit: '1s', duration: '30s', preAllocatedVUs: 10, }, }, thresholds: { http_req_duration: ['p(95)<500', 'p(99)<1000'], }, }; export default function() { const url = 'http://localhost:8080/api/v1/execute/my-rule'; const payload = JSON.stringify({ input: { value: Math.random() * 1000 } }); const response = http.post(url, payload, { headers: { 'Content-Type': 'application/json' }, }); check(response, { 'status is 200': (r) => r.status === 200, 'response time < 100ms': (r) => r.timings.duration < 100, }); } ``` ## CI Configuration ### GitHub Actions Key workflow file: `.github/workflows/ci.yml` ```yaml # Test job test: runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest] rust: [stable, beta] steps: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@master with: toolchain: ${{ matrix.rust }} - run: cargo test --all-features ``` ### Local CI Simulation ```bash # Format check cargo fmt --all -- --check # Clippy check cargo clippy --all-targets --all-features -- -D warnings # Test cargo test --all-features # Build cargo build --release ``` ## Test Coverage ```bash # Install tarpaulin cargo install cargo-tarpaulin # Generate coverage report cargo tarpaulin --out Html --output-dir coverage/ # Or use llvm-cov cargo install cargo-llvm-cov cargo llvm-cov --html ``` ## Frontend Testing ```bash cd ordo-editor # Run tests pnpm test # Run specific package tests pnpm --filter @ordo-engine/editor-core test ``` ## Key Files - `crates/ordo-core/benches/` - Rust benchmarks - `crates/ordo-server/tests/` - Server integration tests - `scripts/benchmark.sh` - k6 load test script - `.github/workflows/ci.yml` - CI configuration - `ordo-editor/packages/core/src/engine/__tests__/` - Frontend tests --- > Converted and distributed by [TomeVault](https://tomevault.io/claim/pama-lee) — claim your Tome and manage your conversions.