arama-cache 0.36.2

Embedding and thumbnail cache facade over localcache for arama
Documentation 
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

// Shared test fixtures for the arama-cache integration test suite.

use std::io::Write;
use std::path::{Path, PathBuf};

use arama_cache::{
    CacheConfig, DbLocation, ImageCacheConfig, ImageCacheWriter, UpsertImageRequest,
    VideoCacheConfig, VideoCacheWriter,
};

// ---------------------------------------------------------------------------
// TempFile — self-cleaning temporary file
// ---------------------------------------------------------------------------

pub(super) struct TempFile {
    pub(super) path: PathBuf,
}

impl TempFile {
    pub(super) fn new(content: &[u8]) -> Self {
        let mut f = tempfile::NamedTempFile::new().unwrap();
        f.write_all(content).unwrap();
        let (_, path) = f.keep().unwrap();
        TempFile { path }
    }

    /// Create a temp file whose name ends with `suffix` (e.g. `".jpg"`).
    /// Required when the crate under test infers file format from the
    /// extension (as `image::open` does for JPEG content).
    pub(super) fn with_suffix(content: &[u8], suffix: &str) -> Self {
        let mut f = tempfile::Builder::new().suffix(suffix).tempfile().unwrap();
        f.write_all(content).unwrap();
        let (_, path) = f.keep().unwrap();
        TempFile { path }
    }

    pub(super) fn path(&self) -> &Path {
        &self.path
    }

    pub(super) fn overwrite(&self, content: &[u8]) {
        std::fs::write(&self.path, content).unwrap();
    }
}

impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}

// ---------------------------------------------------------------------------
// Writer / DB factories
// ---------------------------------------------------------------------------

pub(super) fn tmp_db() -> tempfile::NamedTempFile {
    tempfile::NamedTempFile::new().unwrap()
}

pub(super) fn image_writer_with_db(db: &tempfile::NamedTempFile) -> ImageCacheWriter {
    ImageCacheWriter::as_session(ImageCacheConfig {
        cache_config: CacheConfig {
            db_location: DbLocation::Custom(db.path().to_path_buf()),
            read_conns: 2,
            thumbnail_dir: None,
        },
    })
    .unwrap()
}

pub(super) fn upsert_image(writer: &ImageCacheWriter, path: &Path) {
    writer
        .upsert(UpsertImageRequest {
            path: path.to_path_buf(),
            clip_vector: None,
        })
        .unwrap();
}

pub(super) fn video_writer() -> (VideoCacheWriter, tempfile::NamedTempFile) {
    let db = tmp_db();
    let w = VideoCacheWriter::as_session(VideoCacheConfig {
        cache_config: CacheConfig {
            db_location: DbLocation::Custom(db.path().to_path_buf()),
            read_conns: 2,
            thumbnail_dir: None,
        },
        ffmpeg_path: None,
    })
    .unwrap();
    (w, db)
}

/// Create `count` files with the given byte contents inside `dir`.
pub(super) fn files_in_dir(dir: &Path, contents: &[&[u8]]) -> Vec<PathBuf> {
    contents
        .iter()
        .enumerate()
        .map(|(i, c)| {
            let p = dir.join(format!("file_{i}.bin"));
            std::fs::write(&p, c).unwrap();
            p
        })
        .collect()
}

// ---------------------------------------------------------------------------
// Minimal valid JPEG (1×1 px) for thumbnail tests
// ---------------------------------------------------------------------------

pub(super) const MINIMAL_JPEG: &[u8] = &[
    0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01,
    0x00, 0x01, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x08, 0x06, 0x06, 0x07, 0x06, 0x05, 0x08,
    0x07, 0x07, 0x07, 0x09, 0x09, 0x08, 0x0a, 0x0c, 0x14, 0x0d, 0x0c, 0x0b, 0x0b, 0x0c, 0x19, 0x12,
    0x13, 0x0f, 0x14, 0x1d, 0x1a, 0x1f, 0x1e, 0x1d, 0x1a, 0x1c, 0x1c, 0x20, 0x24, 0x2e, 0x27, 0x20,
    0x22, 0x2c, 0x23, 0x1c, 0x1c, 0x28, 0x37, 0x29, 0x2c, 0x30, 0x31, 0x34, 0x34, 0x34, 0x1f, 0x27,
    0x39, 0x3d, 0x38, 0x32, 0x3c, 0x2e, 0x33, 0x34, 0x32, 0xff, 0xc0, 0x00, 0x0b, 0x08, 0x00, 0x01,
    0x00, 0x01, 0x01, 0x01, 0x11, 0x00, 0xff, 0xc4, 0x00, 0x1f, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01,
    0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
    0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x10, 0x00, 0x02, 0x01, 0x03,
    0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d, 0x01, 0x02, 0x03, 0x00,
    0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32,
    0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72,
    0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35,
    0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55,
    0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75,
    0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94,
    0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2,
    0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
    0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
    0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xda,
    0x00, 0x08, 0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xfb, 0x6d, 0xff, 0xd9,
];