writestead 0.1.3

LLM Wiki
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

use std::fs;
use std::path::Path;
use std::process::Command;

use serde_json::Value;
use tempfile::TempDir;

fn bin() -> &'static str {
    env!("CARGO_BIN_EXE_writestead")
}

fn run(args: &[&str], config_file: &Path) -> (bool, String, String) {
    let output = Command::new(bin())
        .args(args)
        .env("WRITESTEAD_CONFIG_FILE", config_file)
        .output()
        .expect("run command");

    (
        output.status.success(),
        String::from_utf8_lossy(&output.stdout).to_string(),
        String::from_utf8_lossy(&output.stderr).to_string(),
    )
}

fn init_vault(config_file: &Path, vault_path: &Path) {
    let (ok, _out, err) = run(
        &[
            "init",
            "--vault-path",
            vault_path.to_str().expect("vault path"),
            "--sync-backend",
            "none",
            "--force",
        ],
        config_file,
    );
    assert!(ok, "init failed: {err}");
}

#[test]
fn raw_add_local_file_smoke() {
    let dir = TempDir::new().expect("tempdir");
    let config_file = dir.path().join("config.json");
    let vault_path = dir.path().join("vault");
    init_vault(&config_file, &vault_path);

    let source = dir.path().join("source.txt");
    fs::write(&source, "alpha\n").expect("source file");

    let (ok, out, err) = run(
        &["raw", "add", source.to_str().expect("source path")],
        &config_file,
    );
    assert!(ok, "raw add failed: {err}");

    let payload: Value = serde_json::from_str(&out).expect("raw add json");
    assert_eq!(payload["ok"], Value::Bool(true));
    assert_eq!(payload["path"], Value::from("raw/source.txt"));
}

#[test]
fn raw_add_rejects_path_traversal() {
    let dir = TempDir::new().expect("tempdir");
    let config_file = dir.path().join("config.json");
    let vault_path = dir.path().join("vault");
    init_vault(&config_file, &vault_path);

    let (ok, _out, err) = run(&["raw", "add", "../etc/passwd"], &config_file);
    assert!(!ok, "raw add should fail");
    assert!(err.contains("path traversal"), "unexpected err: {err}");
}

#[test]
fn raw_add_rejects_overwrite_without_force() {
    let dir = TempDir::new().expect("tempdir");
    let config_file = dir.path().join("config.json");
    let vault_path = dir.path().join("vault");
    init_vault(&config_file, &vault_path);

    let source = dir.path().join("source.txt");
    fs::write(&source, "alpha\n").expect("source file");

    let (ok, _out, err) = run(
        &["raw", "add", source.to_str().expect("source path")],
        &config_file,
    );
    assert!(ok, "first raw add failed: {err}");

    let (ok, _out, err) = run(
        &["raw", "add", source.to_str().expect("source path")],
        &config_file,
    );
    assert!(!ok, "second raw add should fail");
    assert!(
        err.contains("destination already exists"),
        "unexpected err: {err}"
    );
}

#[test]
fn raw_add_size_cap_enforced() {
    let dir = TempDir::new().expect("tempdir");
    let config_file = dir.path().join("config.json");
    let vault_path = dir.path().join("vault");
    init_vault(&config_file, &vault_path);

    let (ok, _out, err) = run(
        &["config", "set", "raw.upload_max_bytes", "4"],
        &config_file,
    );
    assert!(ok, "config set failed: {err}");

    let source = dir.path().join("big.txt");
    fs::write(&source, "12345").expect("big source");

    let (ok, _out, err) = run(
        &["raw", "add", source.to_str().expect("source path")],
        &config_file,
    );
    assert!(!ok, "raw add should fail by size cap");
    assert!(err.contains("file too large"), "unexpected err: {err}");
}