Ordo Testing and Benchmarking

Unit Tests

Running Tests

bash
1# Run all tests
2cargo test
3
4# Run specific crate
5cargo test --package ordo-core
6cargo test --package ordo-server
7
8# Run specific test
9cargo test test_full_workflow
10
11# Show output
12cargo test -- --nocapture
13
14# Parallel control
15cargo test -- --test-threads=4

Test Example

rust
1#[cfg(test)]
2mod tests {
3    use super::*;
4    use ordo_core::prelude::*;
5
6    #[test]
7    fn test_rule_execution() {
8        let mut ruleset = RuleSet::new("test", "start");
9        
10        ruleset.add_step(
11            Step::decision("start", "Start")
12                .branch(Condition::from_string("value > 10"), "high")
13                .default("low")
14                .build()
15        );
16        
17        ruleset.add_step(Step::terminal("high", "High", 
18            TerminalResult::new("HIGH")));
19        ruleset.add_step(Step::terminal("low", "Low", 
20            TerminalResult::new("LOW")));
21
22        let executor = RuleExecutor::new();
23        
24        // Test high value
25        let input: Value = serde_json::from_str(r#"{"value": 20}"#).unwrap();
26        let result = executor.execute(&ruleset, input).unwrap();
27        assert_eq!(result.code, "HIGH");
28        
29        // Test low value
30        let input: Value = serde_json::from_str(r#"{"value": 5}"#).unwrap();
31        let result = executor.execute(&ruleset, input).unwrap();
32        assert_eq!(result.code, "LOW");
33    }
34
35    #[test]
36    fn test_expression_eval() {
37        let evaluator = Evaluator::new();
38        let parser = ExprParser::new();
39        
40        let expr = parser.parse("age >= 18 && status == \"active\"").unwrap();
41        let ctx = Context::from_json(r#"{"age": 25, "status": "active"}"#).unwrap();
42        let result = evaluator.eval(&expr, &ctx).unwrap();
43        
44        assert_eq!(result, Value::Bool(true));
45    }
46}

Integration Tests

gRPC Tests

bash
1cargo test --package ordo-server --test grpc_test

UDS Tests

bash
1cargo test --package ordo-server --test uds_test

Benchmarks

Running Criterion Benchmarks

bash
1# All benchmarks
2cargo bench --package ordo-core
3
4# Specific benchmarks
5cargo bench --package ordo-core --bench engine_bench
6cargo bench --package ordo-core --bench jit_comparison_bench
7cargo bench --package ordo-core --bench schema_jit_bench
8cargo bench --package ordo-core --bench optimization_bench

Benchmark Files

Writing Benchmarks

rust
1use criterion::{black_box, criterion_group, criterion_main, Criterion};
2use ordo_core::prelude::*;
3
4fn bench_rule_execution(c: &mut Criterion) {
5    let mut ruleset = RuleSet::new("bench", "start");
6    // ... setup rules
7    
8    let executor = RuleExecutor::new();
9    let input: Value = serde_json::from_str(r#"{"value": 100}"#).unwrap();
10    
11    c.bench_function("rule_execution", |b| {
12        b.iter(|| {
13            executor.execute(&ruleset, black_box(input.clone()))
14        })
15    });
16}
17
18criterion_group!(benches, bench_rule_execution);
19criterion_main!(benches);

k6 Load Testing

Running Load Tests

bash
1# Basic test
2./scripts/benchmark.sh
3
4# Custom parameters
5./scripts/benchmark.sh \
6    -h localhost \
7    -p 8080 \
8    -d 60s \
9    -u 50 \
10    -r 500 \
11    --rule order_discount \
12    --analyze

Parameter Reference

Custom k6 Script

javascript
1import http from 'k6/http';
2import { check } from 'k6';
3
4export const options = {
5    scenarios: {
6        constant_load: {
7            executor: 'constant-arrival-rate',
8            rate: 100,
9            timeUnit: '1s',
10            duration: '30s',
11            preAllocatedVUs: 10,
12        },
13    },
14    thresholds: {
15        http_req_duration: ['p(95)<500', 'p(99)<1000'],
16    },
17};
18
19export default function() {
20    const url = 'http://localhost:8080/api/v1/execute/my-rule';
21    const payload = JSON.stringify({
22        input: { value: Math.random() * 1000 }
23    });
24    
25    const response = http.post(url, payload, {
26        headers: { 'Content-Type': 'application/json' },
27    });
28    
29    check(response, {
30        'status is 200': (r) => r.status === 200,
31        'response time < 100ms': (r) => r.timings.duration < 100,
32    });
33}

CI Configuration

GitHub Actions

Key workflow file: .github/workflows/ci.yml

yaml
1# Test job
2test:
3  runs-on: ${{ matrix.os }}
4  strategy:
5    matrix:
6      os: [ubuntu-latest, macos-latest, windows-latest]
7      rust: [stable, beta]
8  steps:
9    - uses: actions/checkout@v4
10    - uses: dtolnay/rust-toolchain@master
11      with:
12        toolchain: ${{ matrix.rust }}
13    - run: cargo test --all-features

Local CI Simulation

bash
1# Format check
2cargo fmt --all -- --check
3
4# Clippy check
5cargo clippy --all-targets --all-features -- -D warnings
6
7# Test
8cargo test --all-features
9
10# Build
11cargo build --release

Test Coverage

bash
1# Install tarpaulin
2cargo install cargo-tarpaulin
3
4# Generate coverage report
5cargo tarpaulin --out Html --output-dir coverage/
6
7# Or use llvm-cov
8cargo install cargo-llvm-cov
9cargo llvm-cov --html

Frontend Testing

bash
1cd ordo-editor
2
3# Run tests
4pnpm test
5
6# Run specific package tests
7pnpm --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