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
138
139
140
141
142
143

//! Process-level e2e tests for bucket-request-payment subcommands.

#![cfg(e2e_test)]

mod common;

use common::{REGION, TestHelper, generate_bucket_name, run, s7cmd_cmd};

const PROFILE: &str = "s7cmd-e2e-test";

/// Round-trip: get default → put Requester → get → put BucketOwner → get.
#[tokio::test]
async fn request_payment_round_trip() {
    let helper = TestHelper::new().await;
    let bucket = generate_bucket_name();
    helper.create_bucket(&bucket, REGION).await;

    let bucket_arg = format!("s3://{bucket}");

    // 1. Get default — should be BucketOwner
    let (code, stdout, stderr) = run(s7cmd_cmd().args([
        "get-bucket-request-payment",
        "--target-profile",
        PROFILE,
        "--target-region",
        REGION,
        &bucket_arg,
    ]));
    assert_eq!(
        code,
        Some(0),
        "get-bucket-request-payment should succeed; stderr: {stderr}"
    );
    let json: serde_json::Value =
        serde_json::from_str(&stdout).expect("get-bucket-request-payment stdout must be JSON");
    assert_eq!(
        json.get("Payer").and_then(|v| v.as_str()),
        Some("BucketOwner"),
        "expected default Payer=BucketOwner; got: {json}"
    );

    // 2. Put Requester
    let (code, stdout, stderr) = run(s7cmd_cmd().args([
        "put-bucket-request-payment",
        "--target-profile",
        PROFILE,
        "--target-region",
        REGION,
        &bucket_arg,
        "--requester",
    ]));
    assert_eq!(
        code,
        Some(0),
        "put --requester should succeed; stderr: {stderr}"
    );
    assert_eq!(
        stdout.trim(),
        "",
        "put-bucket-request-payment must produce no stdout"
    );

    // 3. Get — expect Requester
    let (code, stdout, _stderr) = run(s7cmd_cmd().args([
        "get-bucket-request-payment",
        "--target-profile",
        PROFILE,
        "--target-region",
        REGION,
        &bucket_arg,
    ]));
    assert_eq!(code, Some(0));
    let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
    assert_eq!(
        json.get("Payer").and_then(|v| v.as_str()),
        Some("Requester")
    );

    // 4. Put BucketOwner (back to default)
    let (code, _stdout, _stderr) = run(s7cmd_cmd().args([
        "put-bucket-request-payment",
        "--target-profile",
        PROFILE,
        "--target-region",
        REGION,
        &bucket_arg,
        "--bucket-owner",
    ]));
    assert_eq!(code, Some(0));

    // 5. Get — expect BucketOwner
    let (code, stdout, _stderr) = run(s7cmd_cmd().args([
        "get-bucket-request-payment",
        "--target-profile",
        PROFILE,
        "--target-region",
        REGION,
        &bucket_arg,
    ]));
    assert_eq!(code, Some(0));
    let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
    assert_eq!(
        json.get("Payer").and_then(|v| v.as_str()),
        Some("BucketOwner")
    );

    helper.delete_bucket_with_cascade(&bucket).await;
}

/// put-bucket-request-payment on a non-existent bucket should fail with exit 1.
#[tokio::test]
async fn put_request_payment_on_missing_bucket_exits_1() {
    let bucket = generate_bucket_name();
    let bucket_arg = format!("s3://{bucket}");
    let (code, _stdout, _stderr) = run(s7cmd_cmd().args([
        "put-bucket-request-payment",
        "--target-profile",
        PROFILE,
        "--target-region",
        REGION,
        &bucket_arg,
        "--requester",
    ]));

    assert_eq!(code, Some(1));
}

/// get-bucket-request-payment on a non-existent bucket should exit 4 (NoSuchBucket).
#[tokio::test]
async fn get_request_payment_on_missing_bucket_exits_4() {
    let bucket = generate_bucket_name();
    let bucket_arg = format!("s3://{bucket}");
    let (code, _stdout, _stderr) = run(s7cmd_cmd().args([
        "get-bucket-request-payment",
        "--target-profile",
        PROFILE,
        "--target-region",
        REGION,
        &bucket_arg,
    ]));

    assert_eq!(code, Some(4), "missing bucket must exit 4 (NoSuchBucket)");
}