s7cmd 1.5.0

Reliable, flexible, and fast command-line tool for Amazon S3
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

//! Process-level CLI tests for the `restore-object` subcommand.
//! These run without AWS credentials or network access (mock-endpoint
//! tests talk only to a loopback HTTP server).

mod common;
use common::{MockResponse, MockS3Server, mock_target_args, s7cmd_cmd_clean_env};

use std::process::{Command, Stdio};

fn s7cmd() -> Command {
    Command::new(env!("CARGO_BIN_EXE_s7cmd"))
}

fn run(cmd: &mut Command) -> (bool, String, String, Option<i32>) {
    let output = cmd
        .stdin(Stdio::null())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .output()
        .expect("failed to spawn s7cmd binary");
    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
    (
        output.status.success(),
        stdout,
        stderr,
        output.status.code(),
    )
}

#[test]
fn help_succeeds_and_lists_option_groups() {
    let (ok, stdout, _stderr, _code) = run(s7cmd().args(["restore-object", "--help"]));
    assert!(ok, "restore-object --help must succeed");
    assert!(stdout.contains("AWS Configuration"));
    assert!(stdout.contains("Retry Options"));
    assert!(stdout.contains("Timeout Options"));
    assert!(
        stdout.contains("--days") && stdout.contains("--tier"),
        "expected --days and --tier in help; got: {stdout}"
    );
}

#[test]
fn missing_target_exits_non_zero() {
    let (ok, _stdout, stderr, code) = run(s7cmd().arg("restore-object"));
    assert!(!ok);
    assert_eq!(
        code,
        Some(2),
        "clap missing-arg should exit 2; stderr: {stderr}"
    );
    assert!(
        stderr.to_lowercase().contains("required") || stderr.to_lowercase().contains("usage"),
        "expected 'required' or 'usage' in stderr; got: {stderr}"
    );
}

#[test]
fn bucket_only_path_exits_1() {
    let (ok, _stdout, stderr, code) = run(s7cmd().args(["restore-object", "s3://example"]));
    assert!(!ok);
    assert_eq!(code, Some(1), "bucket-only path should exit 1 (validation)");
    assert!(
        !stderr.is_empty(),
        "should have an error message on stderr; got empty"
    );
}

#[test]
fn invalid_tier_exits_2() {
    let (ok, _stdout, stderr, code) =
        run(s7cmd().args(["restore-object", "s3://example/key", "--tier", "TurboMax"]));
    assert!(!ok);
    assert_eq!(
        code,
        Some(2),
        "invalid tier should exit 2 (clap validation); stderr: {stderr}"
    );
    assert!(
        stderr.to_lowercase().contains("invalid tier")
            || stderr.to_lowercase().contains("invalid value"),
        "expected invalid-tier message; got: {stderr}"
    );
}

#[test]
fn standard_tier_with_days_parses_ok() {
    let (ok, _stdout, stderr, code) = run(s7cmd().args([
        "restore-object",
        "s3://example/key",
        "--days",
        "7",
        "--tier",
        "Standard",
    ]));
    assert!(
        code != Some(2),
        "valid tier+days combo must parse without clap error; code={code:?}; stderr={stderr}"
    );
    let _ = ok;
}

#[test]
fn target_access_key_without_secret_exits_non_zero() {
    let (ok, _stdout, stderr, code) = run(s7cmd().args([
        "restore-object",
        "s3://example/key",
        "--target-access-key",
        "AKIA",
    ]));
    assert!(!ok);
    assert_eq!(
        code,
        Some(2),
        "clap missing-arg should exit 2; stderr: {stderr}"
    );
    assert!(
        stderr.to_lowercase().contains("required")
            || stderr.to_lowercase().contains("--target-secret-access-key")
    );
}

#[test]
fn mock_endpoint_restore_initiated_exits_0() {
    let server = MockS3Server::start(vec![MockResponse::new(202, "")]);
    let mut cmd = s7cmd_cmd_clean_env();
    cmd.args(["restore-object", "-v", "--days", "1"])
        .args(mock_target_args(&server.endpoint_url()))
        .arg("s3://mock-bucket/deep-archive-object");
    let (code, _stdout, stderr) = common::run(&mut cmd);
    assert_eq!(code, Some(0), "expected success; stderr: {stderr}");
    assert!(
        stderr.contains("Restore initiated."),
        "expected the success info line (-v); got: {stderr}"
    );
}