frankensearch-embed 0.2.2

Embedder implementations for frankensearch (hash, model2vec, fastembed)
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Integration tests for model cache resolution, layout, and filesystem operations.
//!
//! These tests verify the cache directory lifecycle: resolution from environment
//! variables and XDG paths, lazy creation, and concurrent access safety.

use frankensearch_embed::{
    MODEL_CACHE_LAYOUT_VERSION, ModelCacheLayout, ensure_cache_layout, is_model_installed,
    known_models,
};

// ---------------------------------------------------------------------------
// Cache layout: directory creation and idempotency
// ---------------------------------------------------------------------------

#[test]
fn ensure_cache_layout_creates_model_subdirectories() {
    let tmp = tempfile::tempdir().unwrap();
    let layout = ModelCacheLayout::for_root(tmp.path().to_path_buf());
    ensure_cache_layout(&layout).unwrap();

    // Every known model should have a directory under the cache root.
    for model in known_models() {
        let model_dir = layout.model_path(model.dir_name);
        assert!(
            model_dir.is_some(),
            "layout should have a path for known model {}",
            model.dir_name
        );
        let path = model_dir.unwrap();
        assert!(
            path.exists(),
            "directory for {} should exist after ensure_cache_layout",
            model.dir_name
        );
    }
}

#[test]
fn ensure_cache_layout_is_idempotent() {
    let tmp = tempfile::tempdir().unwrap();
    let layout = ModelCacheLayout::for_root(tmp.path().to_path_buf());
    ensure_cache_layout(&layout).unwrap();
    // Call again — should not fail.
    ensure_cache_layout(&layout).unwrap();

    // Both calls should succeed and the layout should match the constant.
    const { assert!(MODEL_CACHE_LAYOUT_VERSION > 0) };
}

#[test]
fn ensure_cache_layout_creates_nested_parent_directories() {
    let tmp = tempfile::tempdir().unwrap();
    let deep_path = tmp.path().join("a").join("b").join("c").join("models");

    let layout = ModelCacheLayout::for_root(deep_path.clone());
    ensure_cache_layout(&layout).unwrap();
    assert!(deep_path.exists(), "deep path should be created");
}

// ---------------------------------------------------------------------------
// Installation detection: file presence checks
// ---------------------------------------------------------------------------

#[test]
fn is_model_installed_false_for_empty_directory() {
    let tmp = tempfile::tempdir().unwrap();
    let model_dir = tmp.path().join("empty_model").join("v1");
    std::fs::create_dir_all(&model_dir).unwrap();

    // An empty directory with required files should not be installed.
    assert!(
        !is_model_installed(&model_dir, &["model.bin"]),
        "empty directory should not report model as installed"
    );
}

#[test]
fn is_model_installed_true_after_populating_all_files() {
    let tmp = tempfile::tempdir().unwrap();
    let model_dir = tmp.path().join("test_model").join("v1");
    std::fs::create_dir_all(&model_dir).unwrap();

    let required_files = &["model.bin", "config.json"];
    for file_name in required_files {
        std::fs::write(model_dir.join(file_name), b"test content").unwrap();
    }

    assert!(
        is_model_installed(&model_dir, required_files),
        "model should be installed after populating all required files"
    );
}

#[test]
fn is_model_installed_false_when_missing_one_file() {
    let tmp = tempfile::tempdir().unwrap();
    let model_dir = tmp.path().join("partial_model").join("v1");
    std::fs::create_dir_all(&model_dir).unwrap();

    // Only create one of two required files.
    std::fs::write(model_dir.join("model.bin"), b"content").unwrap();

    assert!(
        !is_model_installed(&model_dir, &["model.bin", "config.json"]),
        "model with missing files should not be installed"
    );
}

// ---------------------------------------------------------------------------
// Known models: sanity checks
// ---------------------------------------------------------------------------

#[test]
fn known_models_is_non_empty() {
    assert!(
        !known_models().is_empty(),
        "known_models should contain at least one entry"
    );
}

#[test]
fn known_models_have_non_empty_dir_names() {
    for model in known_models() {
        assert!(
            !model.dir_name.is_empty(),
            "known model dir_name should not be empty"
        );
        assert!(
            !model.version.is_empty(),
            "known model version should not be empty for {}",
            model.dir_name
        );
    }
}

// ---------------------------------------------------------------------------
// Layout: model_path returns None for unknown models
// ---------------------------------------------------------------------------

#[test]
fn layout_model_path_returns_none_for_unknown_model() {
    let tmp = tempfile::tempdir().unwrap();
    let layout = ModelCacheLayout::for_root(tmp.path().to_path_buf());
    assert!(
        layout.model_path("nonexistent-model-abc123").is_none(),
        "unknown model should return None"
    );
}

// ---------------------------------------------------------------------------
// Schema version consistency
// ---------------------------------------------------------------------------

#[test]
fn layout_schema_version_is_positive() {
    const { assert!(MODEL_CACHE_LAYOUT_VERSION > 0) };
}