portable-network-archive 0.37.0

Portable-Network-Archive 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
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

use crate::utils::{EmbedExt, TestResources, archive, setup};
use clap::Parser;
use portable_network_archive::cli;
use std::collections::HashSet;
use std::fs;

/// Precondition: The source tree contains both files and directories.
/// Action: Run `pna create` to build an archive, then delete entries by
///         `pna experimental delete` with `--files-from` and `--null`.
/// Expectation: Only the entries listed in the null-separated file are removed; all other files remain.
#[test]
fn delete_with_files_from_null() {
    setup();
    TestResources::extract_in("raw/", "delete_files_from_null/in/").unwrap();
    cli::Cli::try_parse_from([
        "pna",
        "--quiet",
        "c",
        "-f",
        "delete_files_from_null/delete_files_from_null.pna",
        "--overwrite",
        "--no-keep-dir",
        "delete_files_from_null/in/",
    ])
    .unwrap()
    .execute()
    .unwrap();

    // Write patterns separated by null characters instead of newlines
    let list_path = "delete_files_from_null/delete_list";
    fs::write(
        list_path,
        ["**/raw/empty.txt", "**/raw/text.txt"].join("\0"),
    )
    .unwrap();

    cli::Cli::try_parse_from([
        "pna",
        "--quiet",
        "delete",
        "-f",
        "delete_files_from_null/delete_files_from_null.pna",
        "--files-from",
        list_path,
        "--null",
        "--unstable",
    ])
    .unwrap()
    .execute()
    .unwrap();

    let mut seen = HashSet::new();
    archive::for_each_entry(
        "delete_files_from_null/delete_files_from_null.pna",
        |entry| {
            seen.insert(entry.header().path().to_string());
        },
    )
    .unwrap();

    // empty.txt and text.txt should be deleted
    assert!(
        !seen.contains("delete_files_from_null/in/raw/empty.txt"),
        "empty.txt should have been deleted"
    );
    assert!(
        !seen.contains("delete_files_from_null/in/raw/text.txt"),
        "text.txt should have been deleted"
    );

    // Other entries should remain
    for required in [
        "delete_files_from_null/in/raw/images/icon.svg",
        "delete_files_from_null/in/raw/images/icon.bmp",
        "delete_files_from_null/in/raw/pna/empty.pna",
        "delete_files_from_null/in/raw/pna/nest.pna",
        "delete_files_from_null/in/raw/images/icon.png",
        "delete_files_from_null/in/raw/parent/child.txt",
        "delete_files_from_null/in/raw/first/second/third/pna.txt",
    ] {
        assert!(
            seen.take(required).is_some(),
            "required entry missing: {required}"
        );
    }
    assert!(seen.is_empty(), "unexpected entries found: {seen:?}");
}

/// Precondition: The source tree contains both files and directories.
/// Action: Run `pna create` to build an archive, then delete entries by
///         `pna experimental delete` with `--files-from` and `--null` where the
///         list file contains patterns separated by newlines (not nulls).
/// Expectation: The entire content is treated as a single pattern (since --null expects
///              null separators), and the command errors because no match is found.
#[test]
fn delete_with_files_from_null_rejects_newline_separator() {
    setup();
    TestResources::extract_in("raw/", "delete_null_newline/in/").unwrap();
    cli::Cli::try_parse_from([
        "pna",
        "--quiet",
        "c",
        "-f",
        "delete_null_newline/delete_null_newline.pna",
        "--overwrite",
        "--no-keep-dir",
        "delete_null_newline/in/",
    ])
    .unwrap()
    .execute()
    .unwrap();

    // Write patterns separated by newlines (NOT null characters)
    // With --null, this should be treated as a single pattern containing a newline
    let list_path = "delete_null_newline/delete_list";
    fs::write(
        list_path,
        "**/raw/empty.txt\n**/raw/text.txt", // newline-separated, not null-separated
    )
    .unwrap();

    // This should fail because the pattern "**/raw/empty.txt\n**/raw/text.txt"
    // (treated as a single pattern due to --null) won't match any entry
    let result = cli::Cli::try_parse_from([
        "pna",
        "--quiet",
        "delete",
        "-f",
        "delete_null_newline/delete_null_newline.pna",
        "--files-from",
        list_path,
        "--null",
        "--unstable",
    ])
    .unwrap()
    .execute();

    assert!(
        result.is_err(),
        "should error when newline-separated patterns are used with --null"
    );
}