Squashed 'vendor/ruvector/' content from commit b64c2172

git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900

crates/ruvector-sparse-inference-wasm/tests/web.rs

@@ -0,0 +1,154 @@
+#![cfg(target_arch = "wasm32")]
+
+use ruvector_sparse_inference_wasm::*;
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
+
+/// Create a minimal mock GGUF model for testing
+fn create_mock_model() -> Vec<u8> {
+    // Minimal GGUF header + metadata
+    // Magic: "GGUF" (0x46554747)
+    // Version: 3
+    // Minimal tensors and metadata
+    let mut bytes = Vec::new();
+
+    // Magic number (GGUF in little-endian)
+    bytes.extend_from_slice(&[0x47, 0x47, 0x55, 0x46]); // "GGUF"
+
+    // Version (u32)
+    bytes.extend_from_slice(&3u32.to_le_bytes());
+
+    // Tensor count (u64) - 0 tensors for minimal test
+    bytes.extend_from_slice(&0u64.to_le_bytes());
+
+    // Metadata count (u64) - minimal metadata
+    bytes.extend_from_slice(&4u64.to_le_bytes());
+
+    // Add minimal required metadata fields
+    // This is a simplified version - real GGUF has complex structure
+
+    bytes
+}
+
+fn create_test_engine() -> SparseInferenceEngine {
+    let model_bytes = create_mock_model();
+    let config = r#"{
+        "sparsity": {
+            "enabled": true,
+            "threshold": 0.1
+        },
+        "temperature": 1.0,
+        "top_k": 50
+    }"#;
+
+    SparseInferenceEngine::new(&model_bytes, config).expect("Failed to create test engine")
+}
+
+#[wasm_bindgen_test]
+fn test_version() {
+    let ver = version();
+    assert!(!ver.is_empty());
+    assert!(ver.contains('.'));
+}
+
+#[wasm_bindgen_test]
+fn test_init() {
+    // Just ensure init doesn't panic
+    init();
+}
+
+#[wasm_bindgen_test]
+fn test_engine_creation_with_invalid_config() {
+    let model_bytes = create_mock_model();
+    let bad_config = "not json";
+
+    let result = SparseInferenceEngine::new(&model_bytes, bad_config);
+    assert!(result.is_err());
+}
+
+#[wasm_bindgen_test]
+fn test_engine_metadata() {
+    let engine = create_test_engine();
+    let metadata = engine.metadata();
+
+    // Should return valid JSON string
+    assert!(!metadata.is_empty());
+}
+
+#[wasm_bindgen_test]
+fn test_sparsity_stats() {
+    let engine = create_test_engine();
+    let stats = engine.sparsity_stats();
+
+    // Should return valid JSON string
+    assert!(!stats.is_empty());
+}
+
+#[wasm_bindgen_test]
+fn test_sparsity_adjustment() {
+    let mut engine = create_test_engine();
+
+    // Should not panic
+    engine.set_sparsity(0.5);
+
+    let stats = engine.sparsity_stats();
+    assert!(!stats.is_empty());
+}
+
+#[wasm_bindgen_test]
+fn test_embedding_model_creation() {
+    let model_bytes = create_mock_model();
+
+    let result = EmbeddingModel::new(&model_bytes);
+    // May fail with mock model, but shouldn't panic
+    let _ = result;
+}
+
+#[wasm_bindgen_test]
+fn test_llm_model_creation() {
+    let model_bytes = create_mock_model();
+    let config = r#"{
+        "sparsity": {"enabled": true, "threshold": 0.1},
+        "temperature": 0.7,
+        "top_k": 40
+    }"#;
+
+    let result = LLMModel::new(&model_bytes, config);
+    // May fail with mock model, but shouldn't panic
+    let _ = result;
+}
+
+#[wasm_bindgen_test]
+fn test_calibrate_with_empty_samples() {
+    let mut engine = create_test_engine();
+    let samples: Vec<f32> = vec![];
+
+    let result = engine.calibrate(&samples, 512);
+    // Should handle gracefully
+    let _ = result;
+}
+
+#[wasm_bindgen_test]
+fn test_measure_inference_time() {
+    let engine = create_test_engine();
+    let input = vec![0.1f32; 512];
+
+    // Should not panic even if inference fails
+    let time = measure_inference_time(&engine, &input, 1);
+    assert!(time >= 0.0);
+}
+
+// Integration tests with actual model would go here
+// These require a real GGUF model file which we don't have in tests
+
+#[wasm_bindgen_test]
+async fn test_load_streaming_with_bad_url() {
+    let config = r#"{"sparsity": {"enabled": true}}"#;
+    let result =
+        SparseInferenceEngine::load_streaming("https://invalid.example.com/model.gguf", config)
+            .await;
+
+    // Should fail gracefully
+    assert!(result.is_err());
+}