cmprss 0.4.0

A compression multi-tool for the command line.
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

use assert_cmd::prelude::*;
use assert_fs::prelude::*;
use predicates::prelude::*;
use std::process::Command;

mod common;
use common::*;

mod list {
    use super::*;

    /// `cmprss --list archive.tar` prints every entry's path, one per line.
    #[test]
    fn tar_archive() -> Result<(), Box<dyn std::error::Error>> {
        let working_dir = create_working_dir()?;
        let a = working_dir.child("alpha.txt");
        a.write_str("alpha")?;
        let b = working_dir.child("beta.txt");
        b.write_str("beta")?;

        let mut pack = Command::cargo_bin("cmprss")?;
        pack.current_dir(&working_dir)
            .args(["tar", "alpha.txt", "beta.txt", "out.tar"]);
        pack.assert().success();

        let mut list = Command::cargo_bin("cmprss")?;
        list.current_dir(&working_dir).args(["--list", "out.tar"]);
        list.assert()
            .success()
            .stdout(predicate::str::contains("alpha.txt"))
            .stdout(predicate::str::contains("beta.txt"));
        Ok(())
    }

    /// `cmprss --list archive.zip` enumerates file names via ZipArchive.
    #[test]
    fn zip_archive() -> Result<(), Box<dyn std::error::Error>> {
        let working_dir = create_working_dir()?;
        let a = working_dir.child("first.txt");
        a.write_str("first")?;
        let b = working_dir.child("second.txt");
        b.write_str("second")?;

        let mut pack = Command::cargo_bin("cmprss")?;
        pack.current_dir(&working_dir)
            .args(["zip", "first.txt", "second.txt", "out.zip"]);
        pack.assert().success();

        let mut list = Command::cargo_bin("cmprss")?;
        list.current_dir(&working_dir).args(["--list", "out.zip"]);
        list.assert()
            .success()
            .stdout(predicate::str::contains("first.txt"))
            .stdout(predicate::str::contains("second.txt"));
        Ok(())
    }

    /// Pipelines whose innermost layer is a container format list through
    /// the in-memory pipe plumbing shared with extract.
    #[test]
    fn tar_gz_archive() -> Result<(), Box<dyn std::error::Error>> {
        let working_dir = create_working_dir()?;
        let a = working_dir.child("inside.txt");
        a.write_str("inside")?;

        let mut pack = Command::cargo_bin("cmprss")?;
        pack.current_dir(&working_dir)
            .args(["tar", "inside.txt", "out.tar"]);
        pack.assert().success();

        let mut gz = Command::cargo_bin("cmprss")?;
        gz.current_dir(&working_dir)
            .args(["gzip", "out.tar", "out.tar.gz"]);
        gz.assert().success();

        let mut list = Command::cargo_bin("cmprss")?;
        list.current_dir(&working_dir)
            .args(["--list", "out.tar.gz"]);
        list.assert()
            .success()
            .stdout(predicate::str::contains("inside.txt"));
        Ok(())
    }

    /// Stream codecs (gzip, xz, …) don't carry multiple entries — listing
    /// must fail loudly rather than silently doing nothing.
    #[test]
    fn gzip_stream_rejects_list() -> Result<(), Box<dyn std::error::Error>> {
        let working_dir = create_working_dir()?;
        let a = working_dir.child("doc.txt");
        a.write_str("doc")?;

        let mut pack = Command::cargo_bin("cmprss")?;
        pack.current_dir(&working_dir)
            .args(["gzip", "doc.txt", "doc.txt.gz"]);
        pack.assert().success();

        let mut list = Command::cargo_bin("cmprss")?;
        list.current_dir(&working_dir)
            .args(["--list", "doc.txt.gz"]);
        list.assert()
            .failure()
            .stderr(predicate::str::contains("cannot be listed"));
        Ok(())
    }
}