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

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

mod common;
use common::*;

mod force {
    use super::*;

    /// Without --force, cmprss must refuse to overwrite an existing -o target.
    ///
    /// ``` bash
    /// echo 'sentinel' > output.gz
    /// cmprss gzip -o output.gz input.txt   # fails, output.gz untouched
    /// ```
    #[test]
    fn refuses_overwrite_without_force() -> Result<(), Box<dyn std::error::Error>> {
        let working_dir = create_working_dir()?;
        let input = working_dir.child("input.txt");
        input.write_str("the real payload")?;

        let output = working_dir.child("output.gz");
        output.write_str("sentinel — must not be clobbered")?;

        let mut cmd = Command::cargo_bin("cmprss")?;
        cmd.current_dir(&working_dir)
            .args(["gzip", "-o", "output.gz", "input.txt"]);
        cmd.assert()
            .failure()
            .stderr(predicate::str::contains("already exists"));

        // The existing file must be byte-for-byte unchanged.
        output.assert("sentinel — must not be clobbered");
        Ok(())
    }

    /// With --force, cmprss overwrites an existing -o target.
    #[test]
    fn overwrites_with_force_explicit_output() -> Result<(), Box<dyn std::error::Error>> {
        let working_dir = create_working_dir()?;
        let input = working_dir.child("input.txt");
        input.write_str("the real payload")?;

        let output = working_dir.child("output.gz");
        output.write_str("sentinel — should be clobbered")?;

        let mut cmd = Command::cargo_bin("cmprss")?;
        cmd.current_dir(&working_dir)
            .args(["gzip", "--force", "-o", "output.gz", "input.txt"]);
        cmd.assert().success();

        // The file now contains real gzip output — confirm by round-tripping.
        let mut extract = Command::cargo_bin("cmprss")?;
        extract
            .current_dir(&working_dir)
            .args(["gzip", "--extract", "output.gz", "output.txt"]);
        extract.assert().success();
        working_dir.child("output.txt").assert("the real payload");
        Ok(())
    }

    /// With --force, a trailing existing file in the positional io_list is
    /// taken as the output and overwritten. Without --force, that trailing
    /// file gets mistakenly pulled into the input list.
    #[test]
    fn overwrites_with_force_positional_output() -> Result<(), Box<dyn std::error::Error>> {
        let working_dir = create_working_dir()?;
        let input = working_dir.child("input.txt");
        input.write_str("the real payload")?;

        let output = working_dir.child("input.txt.gz");
        output.write_str("stale archive")?;

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

        // Round-trip the new archive to confirm it contains the fresh payload.
        let mut extract = Command::cargo_bin("cmprss")?;
        extract.current_dir(&working_dir).args([
            "gzip",
            "--extract",
            "input.txt.gz",
            "roundtrip.txt",
        ]);
        extract.assert().success();
        working_dir
            .child("roundtrip.txt")
            .assert("the real payload");
        Ok(())
    }
}