s7cmd 0.1.1

//! Process-level CLI tests — invocations whose validation happens entirely
//! before any AWS call. Run as part of default `cargo test`; no AWS profile
//! or network required.
//!
//! Each test asserts on exit code (clap returns 2 for arg errors) and on a
//! non-empty stderr (clap or value-parser error message).

mod common;

use common::{run, s7cmd_cmd};

// ---- Top-level ----

#[test]
fn no_subcommand_exits_2_with_usage() {
    let (code, _stdout, stderr) = run(&mut s7cmd_cmd());
    assert_eq!(code, Some(2), "no subcommand must exit 2; stderr={stderr}");
    assert!(
        stderr.to_lowercase().contains("usage"),
        "expected usage on stderr; got: {stderr}"
    );
}

#[test]
fn unrecognized_subcommand_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("not-a-real-cmd"));
    assert_eq!(code, Some(2), "unrecognized subcommand must exit 2");
    assert!(
        stderr.contains("unrecognized subcommand"),
        "expected 'unrecognized subcommand' on stderr; got: {stderr}"
    );
}

// ---- sync ----

#[test]
fn sync_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("sync"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty(), "sync with no args must produce stderr");
}

// ---- ls ----

#[test]
fn ls_invalid_target_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().args(["ls", "notavalidpath"]));
    assert_eq!(code, Some(2));
    assert!(
        stderr.contains("must be an S3 path"),
        "expected S3 path error; got: {stderr}"
    );
}

// ---- clean ----

#[test]
fn clean_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("clean"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- cp ----

#[test]
fn cp_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("cp"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

#[test]
fn cp_missing_target_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().args(["cp", "s3://b/k"]));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- mv ----

#[test]
fn mv_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("mv"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

#[test]
fn mv_missing_target_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().args(["mv", "s3://b/k"]));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- rm ----

#[test]
fn rm_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("rm"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- head-object ----

#[test]
fn head_object_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("head-object"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-object-tagging ----

#[test]
fn get_object_tagging_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-object-tagging"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-object-tagging ----

#[test]
fn put_object_tagging_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-object-tagging"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- delete-object-tagging ----

#[test]
fn delete_object_tagging_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("delete-object-tagging"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- create-bucket ----

#[test]
fn create_bucket_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("create-bucket"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- delete-bucket ----

#[test]
fn delete_bucket_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("delete-bucket"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- head-bucket ----

#[test]
fn head_bucket_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("head-bucket"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-bucket-tagging ----

#[test]
fn get_bucket_tagging_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-bucket-tagging"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-bucket-tagging ----

#[test]
fn put_bucket_tagging_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-bucket-tagging"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- delete-bucket-tagging ----

#[test]
fn delete_bucket_tagging_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("delete-bucket-tagging"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-bucket-policy ----

#[test]
fn get_bucket_policy_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-bucket-policy"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-bucket-policy ----

#[test]
fn put_bucket_policy_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-bucket-policy"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- delete-bucket-policy ----

#[test]
fn delete_bucket_policy_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("delete-bucket-policy"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-bucket-versioning ----

#[test]
fn get_bucket_versioning_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-bucket-versioning"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-bucket-versioning ----

#[test]
fn put_bucket_versioning_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-bucket-versioning"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-bucket-lifecycle-configuration ----

#[test]
fn get_bucket_lifecycle_configuration_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-bucket-lifecycle-configuration"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-bucket-lifecycle-configuration ----

#[test]
fn put_bucket_lifecycle_configuration_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-bucket-lifecycle-configuration"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- delete-bucket-lifecycle-configuration ----

#[test]
fn delete_bucket_lifecycle_configuration_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("delete-bucket-lifecycle-configuration"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-bucket-encryption ----

#[test]
fn get_bucket_encryption_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-bucket-encryption"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-bucket-encryption ----

#[test]
fn put_bucket_encryption_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-bucket-encryption"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- delete-bucket-encryption ----

#[test]
fn delete_bucket_encryption_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("delete-bucket-encryption"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-bucket-cors ----

#[test]
fn get_bucket_cors_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-bucket-cors"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-bucket-cors ----

#[test]
fn put_bucket_cors_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-bucket-cors"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- delete-bucket-cors ----

#[test]
fn delete_bucket_cors_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("delete-bucket-cors"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-public-access-block ----

#[test]
fn get_public_access_block_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-public-access-block"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-public-access-block ----

#[test]
fn put_public_access_block_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-public-access-block"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- delete-public-access-block ----

#[test]
fn delete_public_access_block_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("delete-public-access-block"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-bucket-website ----

#[test]
fn get_bucket_website_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-bucket-website"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-bucket-website ----

#[test]
fn put_bucket_website_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-bucket-website"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- delete-bucket-website ----

#[test]
fn delete_bucket_website_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("delete-bucket-website"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-bucket-logging ----

#[test]
fn get_bucket_logging_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-bucket-logging"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-bucket-logging ----

#[test]
fn put_bucket_logging_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-bucket-logging"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- get-bucket-notification-configuration ----

#[test]
fn get_bucket_notification_configuration_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("get-bucket-notification-configuration"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}

// ---- put-bucket-notification-configuration ----

#[test]
fn put_bucket_notification_configuration_no_args_exits_2() {
    let (code, _stdout, stderr) = run(s7cmd_cmd().arg("put-bucket-notification-configuration"));
    assert_eq!(code, Some(2));
    assert!(!stderr.is_empty());
}