oxiarc-cli 0.2.8

Command-line interface for OxiArc archive operations
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

//! Integration test for `oxiarc create --compress-threshold`.
//!
//! Two files are dropped into a unique temp directory: a tiny one below the
//! threshold and a large, highly-compressible one above it. After the archive
//! is created, `ZipReader` is used to inspect the per-entry compression
//! method and verify the small file is Stored while the large file uses
//! Deflate.

use std::io::Cursor;
use std::path::PathBuf;
use std::process::Command;

use oxiarc_archive::zip::ZipReader;
use oxiarc_core::entry::CompressionMethod;

fn cli_bin() -> PathBuf {
    PathBuf::from(env!("CARGO_BIN_EXE_oxiarc"))
}

fn workdir() -> PathBuf {
    let dir = std::env::temp_dir().join(format!("oxiarc_create_threshold_{}", std::process::id()));
    // Best-effort cleanup before the test, so a prior crash can't wedge us.
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).expect("create workdir");
    dir
}

#[test]
fn test_compress_threshold_stores_small_and_deflates_large() {
    let wd = workdir();
    let small = wd.join("tiny.txt");
    let big = wd.join("big.txt");

    std::fs::write(&small, vec![b'A'; 100]).expect("write small");
    // 10_000 bytes of repeating content — highly compressible, will deflate.
    std::fs::write(&big, vec![b'Z'; 10_000]).expect("write big");

    let archive = wd.join("out.zip");
    let status = Command::new(cli_bin())
        .args(["create", "--compress-threshold", "1024", "--color=never"])
        .arg(&archive)
        .arg(&small)
        .arg(&big)
        .status()
        .expect("run oxiarc create");
    assert!(status.success(), "create failed");

    let bytes = std::fs::read(&archive).expect("read archive");
    let reader = ZipReader::new(Cursor::new(&bytes)).expect("ZipReader::new");

    let entries = reader.entries();
    // At least 2 entries (may be 2 exactly if no directories were added).
    assert!(entries.len() >= 2, "expected at least 2 entries");

    let tiny = entries
        .iter()
        .find(|e| e.name.ends_with("tiny.txt"))
        .expect("tiny.txt entry");
    let bigf = entries
        .iter()
        .find(|e| e.name.ends_with("big.txt"))
        .expect("big.txt entry");

    assert_eq!(
        tiny.method,
        CompressionMethod::Stored,
        "tiny.txt should be Stored, got {:?}",
        tiny.method
    );
    assert_eq!(
        bigf.method,
        CompressionMethod::Deflate,
        "big.txt should be Deflate, got {:?}",
        bigf.method
    );

    let _ = std::fs::remove_dir_all(&wd);
}