Files

ruv cd5943df23 Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

2026-02-28 14:39:40 -05:00

10 KiB

Raw Blame History

RuvLLM WASM Tests

Comprehensive test suite for the RuvLLM WASM bindings, including tests for intelligent features (HNSW Router, MicroLoRA, SONA Instant).

Test Files

`web.rs`

Core WASM functionality tests:

GenerateConfig (configuration management)
ChatMessage and ChatTemplate (conversation formatting)
KV Cache (two-tier key-value cache)
Memory Arena (bump allocator)
Buffer Pool (memory reuse)
RuvLLMWasm (main interface)
Utility functions

`intelligent_wasm_test.rs`

Advanced intelligent features tests:

HNSW Router: Semantic routing with 150x faster pattern search
MicroLoRA: Ultra-lightweight LoRA adaptation (<1ms latency)
SONA Instant: Self-Optimizing Neural Architecture
Integrated Tests: Full workflow testing all components together

Running Tests

Prerequisites

Install wasm-pack:

cargo install wasm-pack

Run All Tests

Browser Tests (Headless Chrome)

# From crates/ruvllm-wasm directory
wasm-pack test --headless --chrome

# Or run specific test file
wasm-pack test --headless --chrome --test web
wasm-pack test --headless --chrome --test intelligent_wasm_test

Browser Tests (Headless Firefox)

wasm-pack test --headless --firefox

Node.js Tests

wasm-pack test --node

Run Specific Tests

# Run only HNSW Router tests
wasm-pack test --headless --chrome -- --test test_hnsw_router

# Run only MicroLoRA tests
wasm-pack test --headless --chrome -- --test test_microlora

# Run only SONA tests
wasm-pack test --headless --chrome -- --test test_sona

Watch Mode (Development)

# Automatically rerun tests on file changes
cargo watch -x 'test --target wasm32-unknown-unknown'

Test Coverage

HNSW Router Tests (11 tests)

Test	Purpose	Assertions
`test_hnsw_router_creation`	Initialization	Dimensions, empty state
`test_hnsw_router_add_pattern`	Pattern insertion	Success, count increment
`test_hnsw_router_add_pattern_dimension_mismatch`	Input validation	Error on wrong dims
`test_hnsw_router_search`	Similarity search	Top-K retrieval
`test_hnsw_router_cosine_similarity_ordering`	Result ranking	Correct similarity order
`test_hnsw_router_serialization`	State persistence	JSON format
`test_hnsw_router_deserialization`	State restoration	Correct reconstruction
`test_hnsw_router_empty_search`	Edge case	Empty results
`test_hnsw_router_max_capacity`	Capacity limits	Rejection when full
`test_performance_hnsw_search_latency`	Performance	<10ms for 100 patterns

MicroLoRA Tests (10 tests)

Test	Purpose	Assertions
`test_microlora_creation`	Initialization	Dim, rank, alpha correct
`test_microlora_apply_transformation`	Forward pass	Output shape, values
`test_microlora_verify_output_shape`	Shape validation	Correct dimensions
`test_microlora_adapt_with_feedback`	Adaptation	Success, count update
`test_microlora_adapt_changes_output`	Learning effect	Output changes
`test_microlora_stats_update`	Statistics	Adaptation count tracking
`test_microlora_reset`	State reset	Zero B matrix, reset count
`test_microlora_dimension_mismatch`	Input validation	Error handling
`test_microlora_serialization`	State export	Correct stats
`test_performance_lora_forward_pass`	Performance	<1ms latency

SONA Instant Tests (9 tests)

Test	Purpose	Assertions
`test_sona_creation`	Initialization	Dim, learning rate
`test_sona_instant_adapt`	Instant adaptation	<1ms latency
`test_sona_instant_adapt_latency`	Performance consistency	Repeated <1ms
`test_sona_record_patterns`	Pattern storage	Correct count
`test_sona_get_suggestions`	Retrieval	Top-K by quality*similarity
`test_sona_learning_accumulation`	Memory growth	Pattern count
`test_sona_memory_limit`	Capacity management	Max 100 patterns
`test_sona_dimension_validation`	Input validation	Error on mismatch
`test_performance_sona_instant_adapt_under_1ms`	Critical latency	<1ms requirement

Integrated Tests (4 tests)

Test	Purpose	Assertions
`test_integrated_system_creation`	Component setup	All initialized
`test_integrated_flow_route_apply_adapt`	Full workflow	Route → Apply → Adapt
`test_integrated_save_load_state`	State persistence	Serialization works
`test_integrated_components_work_together`	End-to-end	Complete task flow

Edge Case Tests (5 tests)

Test	Purpose	Assertions
`test_edge_case_zero_vectors`	Zero input handling	No crashes, correct results
`test_edge_case_very_small_values`	Numerical stability	Finite outputs
`test_edge_case_high_dimensional`	High dims (1024)	All components work
`test_edge_case_single_pattern`	Minimal data	Correct retrieval

Performance Targets

All tests include performance assertions:

Component	Target	Test
HNSW Search (100 patterns)	<10ms	✅ Verified
MicroLoRA Forward Pass	<1ms	✅ Verified
SONA Instant Adapt	<1ms	✅ Critical
Integrated Workflow	<50ms	✅ Verified

Test Organization

tests/
├── README.md                      # This file
├── web.rs                         # Core WASM functionality tests
└── intelligent_wasm_test.rs       # Intelligent features tests
    ├── Mock Implementations       # Standalone test implementations
    ├── HNSW Router Tests         # 11 tests
    ├── MicroLoRA Tests           # 10 tests
    ├── SONA Instant Tests        # 9 tests
    ├── Integrated Tests          # 4 tests
    ├── Performance Tests         # 3 tests
    └── Edge Case Tests           # 5 tests

Mock Implementations

The tests use mock implementations to validate behavior without requiring full integration:

`MockHnswRouter`

Purpose: Test HNSW semantic routing
Features: Pattern addition, cosine similarity search, serialization
Dimensions: Configurable (64-1024)
Capacity: 1000 patterns

`MockMicroLoRA`

Purpose: Test LoRA adaptation
Features: Forward pass (A*B product), adaptation (B matrix update), reset
Rank: 1-2 (micro variants)
Latency: <1ms for rank-2, 256-dim

`MockSONA`

Purpose: Test instant adaptation
Features: Instant adapt (<1ms), pattern memory, suggestion retrieval
Memory: Limited to 100 patterns (LRU eviction)
Learning: Quality-weighted similarity scoring

Test Patterns

Typical Test Structure

#[wasm_bindgen_test]
fn test_feature_name() {
    // 1. Setup
    let component = MockComponent::new(config);

    // 2. Execute
    let result = component.operation(input);

    // 3. Assert
    assert!(result.is_ok());
    assert_eq!(result.unwrap().property, expected);
}

Performance Test Structure

#[wasm_bindgen_test]
fn test_performance_feature() {
    use std::time::Instant;

    let component = MockComponent::new(config);
    let input = create_test_input();

    let start = Instant::now();
    let _result = component.operation(&input);
    let latency = start.elapsed();

    assert!(latency.as_micros() < TARGET_US);
}

Continuous Integration

GitHub Actions Example

name: WASM Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          target: wasm32-unknown-unknown
      - name: Install wasm-pack
        run: cargo install wasm-pack
      - name: Run tests
        run: |
          cd crates/ruvllm-wasm
          wasm-pack test --headless --chrome

Debugging Failed Tests

Enable Console Logging

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(js_namespace = console)]
    fn log(s: &str);
}

#[wasm_bindgen_test]
fn test_with_logging() {
    log("Starting test...");
    // test code
    log(&format!("Result: {:?}", result));
}

Run with Detailed Output

wasm-pack test --headless --chrome -- --nocapture

Browser DevTools (Manual Testing)

# Start local server with tests
wasm-pack test --chrome
# Browser window opens with DevTools available

Common Issues

Issue: `panic! hook not set`

Solution: Tests automatically call console_error_panic_hook::set_once() in lib.rs init()

Issue: `dimension mismatch errors`

Solution: Ensure all components use consistent dimensions (e.g., 384 for embeddings)

Issue: `performance test failures`

Solution:

Run on optimized build: wasm-pack test --release
Check for debug logging overhead
Verify target hardware meets requirements

Issue: `WASM instantiation failed`