130 lines
5.2 KiB
Rust
130 lines
5.2 KiB
Rust
use alpha_id::embed::{EmbeddingStore, embed_batch, estimate};
|
|
use alpha_id::ionos::IonosClient;
|
|
|
|
#[test]
|
|
fn cache_key_is_stable_sha256() {
|
|
let k1 = EmbeddingStore::key("BAAI/bge-m3", "diabetes");
|
|
let k2 = EmbeddingStore::key("BAAI/bge-m3", "diabetes");
|
|
assert_eq!(k1, k2);
|
|
assert_ne!(k1, EmbeddingStore::key("BAAI/bge-m3", "hypertonie"));
|
|
assert_eq!(k1.len(), 64); // hex sha256
|
|
}
|
|
|
|
#[test]
|
|
fn store_persists_and_reloads_vectors_resumably() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let store = EmbeddingStore::open(dir.path().to_str().unwrap(), "BAAI/bge-m3").unwrap();
|
|
assert!(store.get("diabetes").is_none());
|
|
store.put("diabetes", &[0.1, 0.2, 0.3]).unwrap();
|
|
let reopened = EmbeddingStore::open(dir.path().to_str().unwrap(), "BAAI/bge-m3").unwrap();
|
|
assert_eq!(reopened.get("diabetes").unwrap(), vec![0.1, 0.2, 0.3]);
|
|
assert!(reopened.has("diabetes")); // resume: skip already-embedded
|
|
}
|
|
|
|
#[test]
|
|
fn estimate_reports_pending_count_and_chars() {
|
|
let est = estimate(&["abc".to_string(), "de".to_string()]);
|
|
assert_eq!(est.items, 2);
|
|
assert_eq!(est.chars, 5);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Regression tests for embed_batch hardening (Fix 1 & Fix 2)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Spin up a tiny_http mock server that serves one fixed JSON response, then
|
|
/// return an IonosClient pointed at it together with a temp token file.
|
|
fn make_mock_client(
|
|
response_body: &str,
|
|
token_dir: &tempfile::TempDir,
|
|
) -> (IonosClient, std::net::SocketAddr, std::thread::JoinHandle<()>) {
|
|
use tiny_http::{Server, Response};
|
|
|
|
let server = Server::http("127.0.0.1:0").unwrap();
|
|
let addr = server.server_addr().to_ip().unwrap();
|
|
|
|
// Write a dummy token file
|
|
let token_path = token_dir.path().join("token.txt");
|
|
std::fs::write(&token_path, "dummy-token").unwrap();
|
|
|
|
let body = response_body.to_string();
|
|
let handle = std::thread::spawn(move || {
|
|
if let Ok(req) = server.recv() {
|
|
let response = Response::from_string(body)
|
|
.with_header(
|
|
"Content-Type: application/json".parse::<tiny_http::Header>().unwrap(),
|
|
);
|
|
let _ = req.respond(response);
|
|
}
|
|
});
|
|
|
|
let base_url = format!("http://{}", addr);
|
|
let client = IonosClient::new(&base_url, token_path.to_str().unwrap()).unwrap();
|
|
(client, addr, handle)
|
|
}
|
|
|
|
#[test]
|
|
fn embed_batch_happy_path_index_pairing() {
|
|
let token_dir = tempfile::tempdir().unwrap();
|
|
let embed_dir = tempfile::tempdir().unwrap();
|
|
|
|
let body = r#"{"data":[{"index":0,"embedding":[0.1,0.2]},{"index":1,"embedding":[0.3,0.4]}]}"#;
|
|
let (client, _addr, handle) = make_mock_client(body, &token_dir);
|
|
|
|
let store = EmbeddingStore::open(embed_dir.path().to_str().unwrap(), "test-model").unwrap();
|
|
let texts = vec!["a".to_string(), "b".to_string()];
|
|
|
|
let result = embed_batch(&client, &store, "test-model", &texts);
|
|
handle.join().unwrap();
|
|
|
|
assert_eq!(result.unwrap(), 2, "should return count of stored vectors");
|
|
|
|
let va = store.get("a").expect("vector for 'a' must be cached");
|
|
let vb = store.get("b").expect("vector for 'b' must be cached");
|
|
assert_eq!(va, vec![0.1_f32, 0.2_f32], "vector for 'a' mismatch");
|
|
assert_eq!(vb, vec![0.3_f32, 0.4_f32], "vector for 'b' mismatch");
|
|
}
|
|
|
|
#[test]
|
|
fn embed_batch_length_mismatch_is_err_no_partial_write() {
|
|
let token_dir = tempfile::tempdir().unwrap();
|
|
let embed_dir = tempfile::tempdir().unwrap();
|
|
|
|
// API returns only 1 item for 2 texts
|
|
let body = r#"{"data":[{"index":0,"embedding":[0.1,0.2]}]}"#;
|
|
let (client, _addr, handle) = make_mock_client(body, &token_dir);
|
|
|
|
let store = EmbeddingStore::open(embed_dir.path().to_str().unwrap(), "test-model").unwrap();
|
|
let texts = vec!["a".to_string(), "b".to_string()];
|
|
|
|
let result = embed_batch(&client, &store, "test-model", &texts);
|
|
handle.join().unwrap();
|
|
|
|
assert!(result.is_err(), "length mismatch must be an Err, not Ok");
|
|
assert!(store.get("b").is_none(), "partial write for 'b' must not occur");
|
|
}
|
|
|
|
#[test]
|
|
fn embed_batch_reordered_index_maps_to_correct_text() {
|
|
let token_dir = tempfile::tempdir().unwrap();
|
|
let embed_dir = tempfile::tempdir().unwrap();
|
|
|
|
// API returns items in reverse index order (index 1 first, index 0 second)
|
|
let body = r#"{"data":[{"index":1,"embedding":[0.3,0.4]},{"index":0,"embedding":[0.1,0.2]}]}"#;
|
|
let (client, _addr, handle) = make_mock_client(body, &token_dir);
|
|
|
|
let store = EmbeddingStore::open(embed_dir.path().to_str().unwrap(), "test-model").unwrap();
|
|
let texts = vec!["a".to_string(), "b".to_string()];
|
|
|
|
let result = embed_batch(&client, &store, "test-model", &texts);
|
|
handle.join().unwrap();
|
|
|
|
assert_eq!(result.unwrap(), 2, "should return count of stored vectors");
|
|
|
|
let va = store.get("a").expect("vector for 'a' must be cached");
|
|
let vb = store.get("b").expect("vector for 'b' must be cached");
|
|
// index 0 → texts[0] = "a" → [0.1, 0.2]; index 1 → texts[1] = "b" → [0.3, 0.4]
|
|
assert_eq!(va, vec![0.1_f32, 0.2_f32], "reordered index: vector for 'a' mismatch");
|
|
assert_eq!(vb, vec![0.3_f32, 0.4_f32], "reordered index: vector for 'b' mismatch");
|
|
}
|