Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/crates/ruvector-mincut-gated-transformer-wasm/tests/web.rs

@@ -0,0 +1,152 @@
+//! WebAssembly tests for mincut-gated transformer.
+//!
+//! Run with: wasm-pack test --node
+
+use ruvector_mincut_gated_transformer_wasm::{WasmGatePacket, WasmSpikePacket, WasmTransformer};
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
+
+#[wasm_bindgen_test]
+fn test_transformer_new() {
+    let transformer = WasmTransformer::new();
+    assert!(transformer.is_ok());
+}
+
+#[wasm_bindgen_test]
+fn test_transformer_baseline() {
+    let transformer = WasmTransformer::new_baseline();
+    assert!(transformer.is_ok());
+}
+
+#[wasm_bindgen_test]
+fn test_gate_packet_creation() {
+    let gate = WasmGatePacket::new();
+    assert_eq!(gate.lambda, 100);
+    assert_eq!(gate.lambda_prev, 100);
+    assert_eq!(gate.boundary_edges, 0);
+    assert_eq!(gate.partition_count, 1);
+}
+
+#[wasm_bindgen_test]
+fn test_gate_packet_modification() {
+    let mut gate = WasmGatePacket::new();
+    gate.lambda = 150;
+    gate.lambda_prev = 140;
+    gate.boundary_edges = 10;
+    gate.partition_count = 3;
+
+    assert_eq!(gate.lambda, 150);
+    assert_eq!(gate.lambda_prev, 140);
+    assert_eq!(gate.boundary_edges, 10);
+    assert_eq!(gate.partition_count, 3);
+}
+
+#[wasm_bindgen_test]
+fn test_spike_packet_creation() {
+    let spike = WasmSpikePacket::new();
+    assert_eq!(spike.fired, 1);
+    assert_eq!(spike.rate_q15, 0);
+}
+
+#[wasm_bindgen_test]
+fn test_basic_inference() {
+    let mut transformer = WasmTransformer::new().unwrap();
+
+    let gate = WasmGatePacket::new();
+    let gate_js = serde_wasm_bindgen::to_value(&gate).unwrap();
+
+    let tokens = vec![1, 2, 3, 4];
+    let result = transformer.infer(&tokens, gate_js);
+
+    assert!(result.is_ok());
+
+    let result = result.unwrap();
+    assert_eq!(result.decision(), "Allow");
+    assert_eq!(result.reason(), "None");
+    assert_eq!(result.logits().len(), transformer.buffer_size());
+}
+
+#[wasm_bindgen_test]
+fn test_inference_with_spikes() {
+    let mut transformer = WasmTransformer::new().unwrap();
+
+    let gate = WasmGatePacket::new();
+    let gate_js = serde_wasm_bindgen::to_value(&gate).unwrap();
+
+    let spike = WasmSpikePacket::new();
+    let spike_js = serde_wasm_bindgen::to_value(&spike).unwrap();
+
+    let tokens = vec![1, 2, 3, 4];
+    let result = transformer.infer_with_spikes(&tokens, gate_js, spike_js);
+
+    assert!(result.is_ok());
+}
+
+#[wasm_bindgen_test]
+fn test_reset() {
+    let mut transformer = WasmTransformer::new().unwrap();
+
+    let gate = WasmGatePacket::new();
+    let gate_js = serde_wasm_bindgen::to_value(&gate).unwrap();
+
+    // Run inference
+    let tokens = vec![1, 2, 3, 4];
+    let _result = transformer.infer(&tokens, gate_js.clone());
+
+    // Reset
+    transformer.reset();
+
+    // Run again
+    let result = transformer.infer(&tokens, gate_js);
+    assert!(result.is_ok());
+}
+
+#[wasm_bindgen_test]
+fn test_buffer_size() {
+    let transformer = WasmTransformer::new().unwrap();
+    assert_eq!(transformer.buffer_size(), 256); // Micro config logits
+
+    let transformer = WasmTransformer::new_baseline().unwrap();
+    assert_eq!(transformer.buffer_size(), 1024); // Baseline config logits
+}
+
+#[wasm_bindgen_test]
+fn test_low_lambda_intervention() {
+    let mut transformer = WasmTransformer::new().unwrap();
+
+    let mut gate = WasmGatePacket::new();
+    gate.lambda = 10; // Very low lambda
+    gate.lambda_prev = 100;
+
+    let gate_js = serde_wasm_bindgen::to_value(&gate).unwrap();
+
+    let tokens = vec![1, 2, 3, 4];
+    let result = transformer.infer(&tokens, gate_js).unwrap();
+
+    // Should trigger intervention due to low lambda
+    assert_ne!(result.decision(), "Allow");
+}
+
+#[wasm_bindgen_test]
+fn test_witness_fields() {
+    let mut transformer = WasmTransformer::new().unwrap();
+
+    let mut gate = WasmGatePacket::new();
+    gate.lambda = 100;
+    gate.lambda_prev = 95;
+    gate.boundary_edges = 5;
+    gate.partition_count = 3;
+
+    let gate_js = serde_wasm_bindgen::to_value(&gate).unwrap();
+
+    let tokens = vec![1, 2, 3, 4];
+    let result = transformer.infer(&tokens, gate_js).unwrap();
+
+    assert_eq!(result.lambda(), 100);
+    assert_eq!(result.lambda_prev(), 95);
+    assert_eq!(result.boundary_edges(), 5);
+    assert_eq!(result.partition_count(), 3);
+    assert!(result.effective_seq_len() > 0);
+    assert!(result.effective_window() > 0);
+}