syncular-testkit 0.1.0

Rust-first test fixtures, in-memory app server, and assertions for Syncular apps.
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

use std::fs;
use std::path::{Path, PathBuf};

use uuid::Uuid;

/// Temporary SQLite database path that removes the database and sidecar files
/// when dropped.
#[derive(Debug)]
pub struct TempDbPath {
    path: PathBuf,
}

impl TempDbPath {
    pub fn new(prefix: impl AsRef<str>) -> Self {
        let sanitized = sanitize_prefix(prefix.as_ref());
        let path = std::env::temp_dir().join(format!(
            "{sanitized}-{}-{}.sqlite",
            std::process::id(),
            Uuid::new_v4()
        ));
        Self { path }
    }

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

    pub fn to_string_lossy(&self) -> String {
        self.path.to_string_lossy().into_owned()
    }

    pub fn remove_now(&self) {
        remove_sqlite_path(&self.path);
    }
}

impl AsRef<Path> for TempDbPath {
    fn as_ref(&self) -> &Path {
        self.path()
    }
}

impl Drop for TempDbPath {
    fn drop(&mut self) {
        remove_sqlite_path(&self.path);
    }
}

pub fn temp_db_path(prefix: impl AsRef<str>) -> TempDbPath {
    TempDbPath::new(prefix)
}

pub fn unique_temp_db_path(prefix: impl AsRef<str>) -> String {
    TempDbPath::new(prefix).to_string_lossy()
}

pub fn unique_temp_file_path(prefix: impl AsRef<str>) -> String {
    let sanitized = sanitize_prefix(prefix.as_ref());
    std::env::temp_dir()
        .join(format!(
            "{sanitized}-{}-{}",
            std::process::id(),
            Uuid::new_v4()
        ))
        .to_string_lossy()
        .into_owned()
}

fn remove_sqlite_path(path: &Path) {
    let _ = fs::remove_file(path);
    for suffix in ["-wal", "-shm", "-journal"] {
        let sidecar = PathBuf::from(format!("{}{}", path.to_string_lossy(), suffix));
        let _ = fs::remove_file(sidecar);
    }
}

fn sanitize_prefix(prefix: &str) -> String {
    prefix
        .chars()
        .map(|ch| {
            if ch.is_ascii_alphanumeric() || ch == '-' || ch == '_' {
                ch
            } else {
                '-'
            }
        })
        .collect()
}