embeddenator-testkit 0.21.0

Comprehensive testing utilities and performance benchmarking for embeddenator VSA operations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Observability integration tests
//!
//! Tests metrics and tracing work correctly across component boundaries.

#![cfg(feature = "integration")]

use embeddenator_retrieval::{BruteForceIndex, IndexConfig, RetrievalIndex};
use embeddenator_testkit::{random_sparse_vec, TestMetrics};
use embeddenator_vsa::{ReversibleVSAConfig, SparseVec};
use std::time::Instant;
use tempfile::tempdir;

/// Test: TestMetrics utility works
#[test]
fn test_test_metrics_utility() {
    let mut metrics = TestMetrics::new("test_operation");

    metrics.start_timing();

    // Do some work
    let mut sum = 0u64;
    for i in 0..1000 {
        sum = sum.wrapping_add(i);
    }
    let _ = sum; // use the value

    metrics.stop_timing();

    // Should have recorded non-zero duration
    let stats = metrics.timing_stats();
    assert!(stats.total_ns > 0);
}

/// Test: TestMetrics multiple samples
#[test]
fn test_test_metrics_multiple_samples() {
    let mut metrics = TestMetrics::new("multi_sample");

    for _ in 0..10 {
        metrics.start_timing();
        let mut sum = 0u64;
        for i in 0..100 {
            sum = sum.wrapping_add(i);
        }
        let _ = sum;
        metrics.stop_timing();
    }

    let stats = metrics.timing_stats();
    assert_eq!(stats.count, 10);
    assert!(stats.mean_ns > 0.0);
}

/// Test: VSA operations work with metrics
#[test]
fn test_vsa_operations_tracked() {
    let mut rng = rand::rng();

    for _ in 0..10 {
        let vec1 = random_sparse_vec(&mut rng, 10000, 200);
        let vec2 = random_sparse_vec(&mut rng, 10000, 200);
        let _ = vec1.cosine(&vec2);
        let _ = vec1.bind(&vec2);
        let _ = vec1.bundle(&vec2);
    }

    // Just verify operations complete without panicking
}

/// Test: Timing operations don't interfere with functionality
#[test]
fn test_timing_no_interference() {
    let dir = tempdir().unwrap();
    let config = ReversibleVSAConfig::default();

    let start = Instant::now();

    // Create and save vector
    let vec = SparseVec::encode_data(b"test data", &config, None);
    let path = dir.path().join("test.bin");
    embeddenator_io::write_bincode_file(&path, &vec).unwrap();

    // Load and verify
    let loaded: SparseVec = embeddenator_io::read_bincode_file(&path).unwrap();

    let elapsed = start.elapsed();

    // Functionality should work correctly
    assert_eq!(vec.pos, loaded.pos);
    assert_eq!(vec.neg, loaded.neg);

    // Timing should be recorded
    assert!(elapsed.as_nanos() > 0);
}

/// Test: Index operations complete correctly
#[test]
fn test_index_operations() {
    let config = ReversibleVSAConfig::default();

    let mut index = BruteForceIndex::new(IndexConfig::default());
    for i in 0..10 {
        let data = format!("doc-{}", i);
        let vec = SparseVec::encode_data(data.as_bytes(), &config, None);
        index.add(i, &vec);
    }
    index.finalize();

    // Perform queries
    let query = SparseVec::encode_data(b"doc-5", &config, None);
    let results = index.query_top_k(&query, 3);

    // Should return results
    assert!(!results.is_empty());
}