rustfs-cli 0.1.30

A Rust S3 CLI client for S3-compatible object storage
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

//! Process-level contracts for bucket replication check and resync commands.

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

use serde_json::Value;
use tempfile::TempDir;

fn run_rc(args: &[&str]) -> (Output, TempDir) {
    let config_dir = tempfile::tempdir().expect("create isolated config dir");
    let output = Command::new(env!("CARGO_BIN_EXE_rc"))
        .args(args)
        .env("RC_CONFIG_DIR", config_dir.path())
        .output()
        .expect("execute rc");
    (output, config_dir)
}

fn assert_v3_usage_error(output: &Output, operation: &str) {
    assert_v3_error(output, operation, 2, "usage_error");
}

fn assert_v3_error(output: &Output, operation: &str, code: i32, error_type: &str) {
    assert_eq!(output.status.code(), Some(code));
    assert!(output.stdout.is_empty(), "JSON errors belong on stderr");
    let value: Value = serde_json::from_slice(&output.stderr).expect("v3 error JSON");
    assert_eq!(value["schema_version"], 3);
    assert_eq!(value["type"], "replication_operations");
    assert_eq!(value["status"], "error");
    assert_eq!(value["error"]["type"], error_type);
    assert!(
        value["error"]["message"]
            .as_str()
            .is_some_and(|message| message.contains(operation))
    );
}

#[test]
fn replication_check_requires_confirmation_before_alias_setup() {
    let (output, _config_dir) = run_rc(&[
        "--json",
        "bucket",
        "replication",
        "check",
        "missing-alias/source-bucket",
    ]);

    assert_v3_usage_error(&output, "check");
    assert!(String::from_utf8_lossy(&output.stderr).contains("--yes"));
}

#[test]
fn replication_check_missing_alias_is_not_found_before_network() {
    let (output, _config_dir) = run_rc(&[
        "--json",
        "bucket",
        "replication",
        "check",
        "missing-alias/source-bucket",
        "--yes",
    ]);

    assert_v3_error(&output, "check", 5, "not_found");
}

#[test]
fn replication_resync_start_requires_confirmation_before_alias_setup() {
    let (output, _config_dir) = run_rc(&[
        "--json",
        "bucket",
        "replication",
        "resync",
        "start",
        "missing-alias/source-bucket",
    ]);

    assert_v3_usage_error(&output, "resync_start");
    assert!(String::from_utf8_lossy(&output.stderr).contains("--yes"));
}

#[test]
fn replication_resync_start_missing_alias_is_not_found_before_network() {
    let (output, _config_dir) = run_rc(&[
        "--json",
        "bucket",
        "replication",
        "resync",
        "start",
        "missing-alias/source-bucket",
        "--yes",
    ]);

    assert_v3_error(&output, "resync_start", 5, "not_found");
}

#[test]
fn replication_resync_status_validates_target_before_alias_setup() {
    let (output, _config_dir) = run_rc(&[
        "--json",
        "bucket",
        "replication",
        "resync",
        "status",
        "missing-alias/source-bucket",
        "--target-arn",
        "not-an-arn",
    ]);

    assert_v3_usage_error(&output, "resync_status");
    assert!(String::from_utf8_lossy(&output.stderr).contains("--target-arn"));
}

#[test]
fn replication_resync_status_missing_alias_is_not_found_before_network() {
    let (output, _config_dir) = run_rc(&[
        "--json",
        "bucket",
        "replication",
        "resync",
        "status",
        "missing-alias/source-bucket",
    ]);

    assert_v3_error(&output, "resync_status", 5, "not_found");
}