Ordo Testing

Ordo Testing and Benchmarking

Unit Tests

Running Tests

# 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

#[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

cargo test --package ordo-server --test grpc_test

UDS Tests

cargo test --package ordo-server --test uds_test

Benchmarks

Running Criterion Benchmarks

# 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

Writing Benchmarks

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

# 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

Custom k6 Script

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

# 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

# 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

# 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

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 — claim your Tome and manage your conversions.