use super::*;
use crate::model::ModelConfig;
use std::path::Path;
fn write_shard(path: &Path, seed: f32) {
let mut header = serde_json::Map::new();
let mut data = Vec::new();
for (name, shape, n) in [
("embed_tokens.weight", vec![6, 32], 192usize),
("norm.weight", vec![32], 32usize),
] {
let start = data.len();
for i in 0..n {
let value = if name == "norm.weight" {
1.0 + seed * 0.01
} else {
((i % 17) as f32 - 8.0) * 0.03 + seed * 0.02
};
data.extend_from_slice(&value.to_le_bytes());
}
header.insert(
name.into(),
serde_json::json!({"dtype":"F32","shape":shape,"data_offsets":[start,data.len()]}),
);
}
let mut json = serde_json::to_vec(&header).unwrap();
while !json.len().is_multiple_of(8) {
json.push(b' ');
}
let mut file = (json.len() as u64).to_le_bytes().to_vec();
file.extend_from_slice(&json);
file.extend_from_slice(&data);
std::fs::write(path, file).unwrap();
}
fn checkpoint(dir: &Path, swapped: bool) {
std::fs::write(dir.join("config.json"), br#"{"vocab_size":6,"hidden_size":32,"num_hidden_layers":0,"num_attention_heads":1,"num_key_value_heads":1,"head_dim":32,"intermediate_size":32,"max_position_embeddings":8}"#).unwrap();
std::fs::write(
dir.join("vocab.txt"),
"[PAD]\n[UNK]\n[CLS]\n[SEP]\n[MASK]\na\n",
)
.unwrap();
std::fs::write(dir.join("inference_config.json"), br#"{"eos_token_id":3}"#).unwrap();
write_shard(&dir.join("a.safetensors"), 1.0);
write_shard(&dir.join("b.safetensors"), 2.0);
let (a, b) = if swapped {
("b.safetensors", "a.safetensors")
} else {
("a.safetensors", "b.safetensors")
};
let index = serde_json::json!({"weight_map":{"embed_tokens.weight":a,"norm.weight":b}});
std::fs::write(
dir.join("model.safetensors.index.json"),
serde_json::to_vec(&index).unwrap(),
)
.unwrap();
}
fn service(dir: &Path, mode: IdentityMode) -> NativeEmbeddingService {
let config = ModelConfig::try_new(EmbeddingModel::Qwen3Embedding0_6B, Some(32)).unwrap();
let mut service = NativeEmbeddingService::with_model_config(config)
.unwrap()
.with_identity_mode(mode)
.unwrap();
service.model_directory = Some(dir.to_path_buf());
service
}
async fn result(service: &NativeEmbeddingService) -> IdentifiedEmbeddings {
service
.embed_identified(
&["a".into()],
EmbeddingModel::Qwen3Embedding0_6B,
EmbeddingRole::Generic,
)
.await
.unwrap()
}
#[tokio::test]
async fn qwen_index_mapping_and_copy_bind_identified_vectors() {
#[cfg(target_os = "macos")]
let _guard = lattice_metal_runtime::measurement::gpu_test_lock();
let original = tempfile::tempdir().unwrap();
let copy = tempfile::tempdir().unwrap();
let swapped = tempfile::tempdir().unwrap();
checkpoint(original.path(), false);
checkpoint(copy.path(), false);
checkpoint(swapped.path(), true);
for name in ["a.safetensors", "b.safetensors"] {
assert_eq!(
std::fs::read(original.path().join(name)).unwrap(),
std::fs::read(swapped.path().join(name)).unwrap()
);
}
let first = result(&service(original.path(), IdentityMode::Full)).await;
let same = result(&service(copy.path(), IdentityMode::Full)).await;
let changed = result(&service(swapped.path(), IdentityMode::Full)).await;
assert!(matches!(&first.identity, EmbeddingSpaceIdentity::Known(_)));
assert!(first.identity.known_match(&same.identity));
assert_eq!(first.embeddings, same.embeddings);
assert!(!first.identity.known_match(&changed.identity));
assert_eq!(first.embeddings[0].len(), 32);
assert!(first.embeddings[0].iter().all(|value| value.is_finite()));
assert_eq!(first.backends.len(), 1);
assert!(first.backends[0].is_some());
let header = result(&service(original.path(), IdentityMode::Header)).await;
assert!(matches!(
header.identity,
EmbeddingSpaceIdentity::Unavailable
));
}
#[tokio::test]
async fn qwen_missing_shard_never_returns_identified_vector() {
#[cfg(target_os = "macos")]
let _guard = lattice_metal_runtime::measurement::gpu_test_lock();
let dir = tempfile::tempdir().unwrap();
checkpoint(dir.path(), false);
std::fs::remove_file(dir.path().join("a.safetensors")).unwrap();
let outcome = service(dir.path(), IdentityMode::Full)
.embed_identified(
&["a".into()],
EmbeddingModel::Qwen3Embedding0_6B,
EmbeddingRole::Generic,
)
.await;
assert!(outcome.is_err());
}
#[tokio::test]
async fn qwen_single_file_takes_precedence_and_full_digest_detects_weight_changes() {
#[cfg(target_os = "macos")]
let _guard = lattice_metal_runtime::measurement::gpu_test_lock();
let a = tempfile::tempdir().unwrap();
let b = tempfile::tempdir().unwrap();
let c = tempfile::tempdir().unwrap();
for dir in [&a, &b, &c] {
checkpoint(dir.path(), false);
}
write_shard(&a.path().join("model.safetensors"), 1.0);
write_shard(&b.path().join("model.safetensors"), 1.0);
write_shard(&c.path().join("model.safetensors"), 2.0);
write_shard(&b.path().join("b.safetensors"), 7.0);
let first = result(&service(a.path(), IdentityMode::Full)).await;
let unused_changed = result(&service(b.path(), IdentityMode::Full)).await;
let weights_changed = result(&service(c.path(), IdentityMode::Full)).await;
assert!(first.identity.known_match(&unused_changed.identity));
assert!(!first.identity.known_match(&weights_changed.identity));
}
#[tokio::test]
async fn qwen_header_identified_uses_cache_while_full_remains_uncached() {
#[cfg(target_os = "macos")]
let _guard = lattice_metal_runtime::measurement::gpu_test_lock();
let dir = tempfile::tempdir().unwrap();
checkpoint(dir.path(), false);
for mode in [IdentityMode::Header, IdentityMode::Full] {
let service = service(dir.path(), mode);
let LoadedModel::Qwen { model, .. } = service.ensure_model().await.unwrap() else {
panic!("fixture must load Qwen");
};
model.cache_clear();
let first = result(&service).await;
let expected_size = usize::from(mode == IdentityMode::Header);
assert_eq!(model.cache_size(), expected_size);
let second = result(&service).await;
assert_eq!(model.cache_size(), expected_size);
assert_eq!(first.embeddings, second.embeddings);
if mode == IdentityMode::Header {
assert!(matches!(
first.identity,
EmbeddingSpaceIdentity::Unavailable
));
assert_eq!(first.backends, vec![None]);
} else {
assert!(matches!(first.identity, EmbeddingSpaceIdentity::Known(_)));
assert!(first.backends[0].is_some());
}
}
}
#[test]
fn loaded_qwen_configs_select_distinct_stable_cache_paths() {
let first = tempfile::tempdir().unwrap();
let second = tempfile::tempdir().unwrap();
checkpoint(first.path(), false);
checkpoint(second.path(), false);
let config_path = second.path().join("config.json");
let mut config: serde_json::Value =
serde_json::from_slice(&std::fs::read(&config_path).unwrap()).unwrap();
config["revision_witness"] = serde_json::json!(2);
std::fs::write(&config_path, serde_json::to_vec(&config).unwrap()).unwrap();
let a = lattice_model_qwen3_embedding::QwenModel::from_directory(first.path()).unwrap();
let a_again = lattice_model_qwen3_embedding::QwenModel::from_directory(first.path()).unwrap();
let b = lattice_model_qwen3_embedding::QwenModel::from_directory(second.path()).unwrap();
let key = |model: &lattice_model_qwen3_embedding::QwenModel| {
super::super::embedding_cache_path(
"qwen3-embedding-0.6b",
model.dimensions(),
&model.effective_inference_config().base_model_rev,
)
};
assert_eq!(key(&a), key(&a_again));
assert_ne!(key(&a), key(&b));
}
#[test]
fn legacy_cache_restore_validates_real_model_revision_before_migration() {
let first = tempfile::tempdir().unwrap();
let second = tempfile::tempdir().unwrap();
let caches = tempfile::tempdir().unwrap();
checkpoint(first.path(), false);
checkpoint(second.path(), false);
for dir in [first.path(), second.path()] {
std::fs::write(
dir.join("inference_config.json"),
br#"{"eos_token_id":3,"tokenizer_rev":"fixture-tokenizer"}"#,
)
.unwrap();
}
let config_path = second.path().join("config.json");
let mut config: serde_json::Value =
serde_json::from_slice(&std::fs::read(&config_path).unwrap()).unwrap();
config["revision_witness"] = serde_json::json!(2);
std::fs::write(&config_path, serde_json::to_vec(&config).unwrap()).unwrap();
let first_model =
lattice_model_qwen3_embedding::QwenModel::from_directory(first.path()).unwrap();
let second_model =
lattice_model_qwen3_embedding::QwenModel::from_directory(second.path()).unwrap();
let legacy = caches.path().join("legacy.bin");
let current = caches.path().join("current.bin");
let wrong = caches.path().join("wrong.bin");
first_model.cache_save(&legacy).unwrap();
let (count, source) = super::super::restore_embedding_cache(¤t, Some(&legacy), |path| {
first_model.cache_load(path)
})
.unwrap();
assert_eq!(count, 0);
assert_eq!(source, legacy);
first_model.cache_save(¤t).unwrap();
let (_, source) = super::super::restore_embedding_cache(¤t, Some(&legacy), |path| {
first_model.cache_load(path)
})
.unwrap();
assert_eq!(source, current);
let (source, error) = super::super::restore_embedding_cache(&wrong, Some(&legacy), |path| {
second_model.cache_load(path)
})
.unwrap_err();
assert_eq!(source, legacy);
assert!(error.to_string().contains("base_model_rev mismatch"));
assert!(!wrong.exists());
}
#[test]
fn qwen_service_save_and_reload_share_the_loaded_config_path() {
#[cfg(target_os = "macos")]
let _gpu_guard = lattice_metal_runtime::measurement::gpu_test_lock();
struct CacheDirectoryGuard(Option<std::path::PathBuf>);
impl Drop for CacheDirectoryGuard {
fn drop(&mut self) {
super::super::TEST_CACHE_DIRECTORY
.with(|directory| *directory.borrow_mut() = self.0.take());
}
}
let checkpoint_dir = tempfile::tempdir().unwrap();
let cache_dir = tempfile::tempdir().unwrap();
checkpoint(checkpoint_dir.path(), false);
std::fs::write(
checkpoint_dir.path().join("inference_config.json"),
br#"{"eos_token_id":3,"tokenizer_rev":"fixture-tokenizer"}"#,
)
.unwrap();
let previous = super::super::TEST_CACHE_DIRECTORY
.with(|directory| directory.replace(Some(cache_dir.path().to_path_buf())));
let cache_guard = CacheDirectoryGuard(previous);
assert!(cache_guard.0.is_none());
let service = service(checkpoint_dir.path(), IdentityMode::Header);
let config = service.model_config;
let loaded =
super::super::load_qwen_model(config, IdentityMode::Header, Some(checkpoint_dir.path()))
.unwrap();
let LoadedModel::Qwen { model, .. } = &loaded else {
panic!("fixture must load Qwen");
};
assert_eq!(model.cache_size(), 0);
let expected = model.encode("a").unwrap();
assert_eq!(model.cache_size(), 1);
let original_model = std::sync::Arc::clone(model);
assert!(service.model.set(Ok(loaded)).is_ok());
assert_eq!(service.save_cache().unwrap(), 1);
let files: Vec<_> = std::fs::read_dir(cache_dir.path()).unwrap().collect();
assert_eq!(files.len(), 1);
assert!(
files[0]
.as_ref()
.unwrap()
.file_name()
.to_string_lossy()
.starts_with("embed_qwen3-embedding-0.6b_32d_")
);
let restored =
super::super::load_qwen_model(config, IdentityMode::Header, Some(checkpoint_dir.path()))
.unwrap();
let LoadedModel::Qwen { model, .. } = restored else {
panic!("fixture must load Qwen");
};
assert!(!std::sync::Arc::ptr_eq(&original_model, &model));
assert_eq!(
model.cache_size(),
1,
"reload must discover the cache saved by the service"
);
assert_eq!(model.encode("a").unwrap(), expected);
}