tarzan 0.2.0

Random-access, seekable .tar.zst archives with an embedded table-of-contents index
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
134
135
136
137
138
139
140
141
142
143
144
145
146

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

use tempfile::tempdir;

fn fixture_root() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("testdata/fixtures/tiny-tree")
        .canonicalize()
        .expect("fixture path should exist")
}

fn create_tar_from_fixture(output_tar: &Path) {
    let fixture = fixture_root();
    let mut cmd = Command::new("tar");
    #[cfg(target_os = "macos")]
    cmd.env("COPYFILE_DISABLE", "1");
    let status = cmd
        .arg("-cf")
        .arg(output_tar)
        .arg("-C")
        .arg(&fixture)
        .arg(".")
        .status()
        .expect("failed to run tar command");
    assert!(status.success(), "tar command failed");
}

fn tarzan_bin() -> PathBuf {
    PathBuf::from(std::env::var("CARGO_BIN_EXE_tarzan").expect("missing tarzan test binary"))
}

fn wrap_fixture(temp: &tempfile::TempDir) -> PathBuf {
    let tar_path = temp.path().join("input.tar");
    let archive_path = temp.path().join("archive.tar.zst");
    create_tar_from_fixture(&tar_path);
    let status = Command::new(tarzan_bin())
        .arg("wrap")
        .arg(&tar_path)
        .arg("-f")
        .arg(&archive_path)
        .status()
        .expect("failed to run tarzan wrap");
    assert!(status.success(), "tarzan wrap failed");
    archive_path
}

#[test]
fn cat_extracts_readme_txt() {
    let temp = tempdir().expect("tempdir");
    let archive = wrap_fixture(&temp);

    let output = Command::new(tarzan_bin())
        .args(["cat", "-f"])
        .arg(&archive)
        .arg("./README.txt")
        .output()
        .expect("failed to run tarzan cat");

    assert!(
        output.status.success(),
        "tarzan cat failed; stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );

    let expected = fs::read(fixture_root().join("README.txt")).expect("read fixture");
    assert_eq!(
        output.stdout, expected,
        "cat output should match fixture file bytes"
    );
}

#[test]
fn cat_extracts_src_main_rs() {
    let temp = tempdir().expect("tempdir");
    let archive = wrap_fixture(&temp);

    let output = Command::new(tarzan_bin())
        .args(["cat", "-f"])
        .arg(&archive)
        .arg("./src/main.rs")
        .output()
        .expect("failed to run tarzan cat");

    assert!(
        output.status.success(),
        "tarzan cat failed; stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );

    let expected = fs::read(fixture_root().join("src/main.rs")).expect("read fixture");
    assert_eq!(output.stdout, expected);
}

#[test]
fn cat_missing_path_exits_nonzero() {
    let temp = tempdir().expect("tempdir");
    let archive = wrap_fixture(&temp);

    let status = Command::new(tarzan_bin())
        .args(["cat", "-f"])
        .arg(&archive)
        .arg("no/such/file.txt")
        .status()
        .expect("failed to run tarzan cat");

    assert!(!status.success(), "tarzan cat on missing path should fail");
}

#[test]
fn verify_exits_zero_on_fresh_archive() {
    let temp = tempdir().expect("tempdir");
    let archive = wrap_fixture(&temp);

    let output = Command::new(tarzan_bin())
        .args(["verify", "-f"])
        .arg(&archive)
        .output()
        .expect("failed to run tarzan verify");

    assert!(
        output.status.success(),
        "tarzan verify failed; stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );
}

#[test]
fn verify_single_file_exits_zero() {
    let temp = tempdir().expect("tempdir");
    let archive = wrap_fixture(&temp);

    let output = Command::new(tarzan_bin())
        .args(["verify", "-f"])
        .arg(&archive)
        .arg("./README.txt")
        .output()
        .expect("failed to run tarzan verify");

    assert!(
        output.status.success(),
        "tarzan verify single file failed; stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );
}