dkp 0.3.0

dkp — Domain Knowledge Pack management CLI
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

mod common;

use tempfile::TempDir;

use common::{dkp_cmd, scaffold_pack};

#[test]
fn build_default_format_produces_archive_and_checksums() {
    let tmp = TempDir::new().unwrap();
    let pack = scaffold_pack(tmp.path(), "build-pack", "testing");
    let build_out = tmp.path().join("out");

    dkp_cmd()
        .arg("build")
        .arg(&pack)
        .arg("--out")
        .arg(&build_out)
        .assert()
        .success();

    assert!(build_out.join("checksums.json").exists());
    let checksums: serde_json::Value =
        serde_json::from_str(&std::fs::read_to_string(build_out.join("checksums.json")).unwrap())
            .unwrap();
    assert!(checksums.as_object().unwrap().contains_key("manifest.json"));

    let archives: Vec<_> = std::fs::read_dir(&build_out)
        .unwrap()
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().is_some_and(|ext| ext == "dkp"))
        .collect();
    assert_eq!(archives.len(), 1);
}

#[test]
fn build_zip_format_produces_zip_archive() {
    let tmp = TempDir::new().unwrap();
    let pack = scaffold_pack(tmp.path(), "zip-pack", "testing");
    let build_out = tmp.path().join("out");

    dkp_cmd()
        .arg("build")
        .arg(&pack)
        .arg("--format")
        .arg("zip")
        .arg("--out")
        .arg(&build_out)
        .assert()
        .success();

    let zips: Vec<_> = std::fs::read_dir(&build_out)
        .unwrap()
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().is_some_and(|ext| ext == "zip"))
        .collect();
    assert_eq!(zips.len(), 1);
}

#[test]
fn build_no_human_excludes_human_directory_from_checksums() {
    let tmp = TempDir::new().unwrap();
    let pack = scaffold_pack(tmp.path(), "nohuman-pack", "testing");
    // scaffold_pack doesn't pass --extras, so add human/ manually to have
    // something meaningful to exclude.
    std::fs::create_dir_all(pack.join("human")).unwrap();
    std::fs::write(pack.join("human/handbook.md"), "Handbook content.").unwrap();
    let build_out = tmp.path().join("out");

    dkp_cmd()
        .arg("build")
        .arg(&pack)
        .arg("--no-human")
        .arg("--out")
        .arg(&build_out)
        .assert()
        .success();

    let checksums: serde_json::Value =
        serde_json::from_str(&std::fs::read_to_string(build_out.join("checksums.json")).unwrap())
            .unwrap();
    let keys: Vec<&str> = checksums
        .as_object()
        .unwrap()
        .keys()
        .map(|s| s.as_str())
        .collect();
    assert!(!keys.iter().any(|k| k.starts_with("human/")));
}

#[test]
fn build_nonexistent_pack_fails() {
    let tmp = TempDir::new().unwrap();
    let missing = tmp.path().join("does-not-exist");

    dkp_cmd().arg("build").arg(&missing).assert().failure();
}