bare-script 0.1.1

//! Property-based tests for bare-script.
//!
//! Run with: cargo test --test prop_test
//!
//! These tests verify the Args builder with various valid inputs.

use bare_script::Args;
use thiserror as _;
use tokio as _;

// Test with static strings that have 'static lifetime

// Flags (don't require values)
#[test]
fn test_args_flag_v() {
    let result = Args::new().flag("-v", "--verbose").validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_flag_verbose() {
    let result = Args::new().flag("-verbose", "--verbose").validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_flag_force() {
    let result = Args::new().flag("-f", "--force").validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_long_flags() {
    let result = Args::new()
        .flag("--verbose", "")
        .flag("--quiet", "")
        .flag("--version", "")
        .validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_multiple_flags() {
    let result = Args::new()
        .flag("-a", "--all")
        .flag("-l", "--long")
        .flag("-h", "--human-readable")
        .validate();
    assert!(result.is_ok());
}

// Options (require values)
#[test]
fn test_args_option_with_value() {
    let result = Args::new()
        .option("-o", "--output")
        .value("file.txt")
        .unwrap()
        .validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_option_output() {
    let result = Args::new()
        .option("-output", "--output")
        .value("out.txt")
        .unwrap()
        .validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_option_config() {
    let result = Args::new()
        .option("-c", "--config")
        .value("config.json")
        .unwrap()
        .validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_multiple_options() {
    let result = Args::new()
        .option("-o", "--output")
        .value("out1")
        .unwrap()
        .option("-e", "--error")
        .value("err1")
        .unwrap()
        .option("-c", "--config")
        .value("cfg1")
        .unwrap()
        .validate();
    assert!(result.is_ok());
}

// Optional options (don't require values)
#[test]
fn test_args_optional_option() {
    let result = Args::new().optional_option("-o", "--output").validate();
    assert!(result.is_ok());
}

// Positional arguments (required by default)
#[test]
fn test_args_positional() {
    let result = Args::new().positional().validate();
    // Positional is required but has no value, so it fails validation
    // Use optional_positional for optional
    assert!(result.is_err());
}

#[test]
fn test_args_positional_with_value() {
    let result = Args::new()
        .positional()
        .value("file.txt")
        .unwrap()
        .validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_optional_positional() {
    let result = Args::new().optional_positional().validate();
    assert!(result.is_ok());
}

// Mixed arguments
#[test]
fn test_args_mixed_1() {
    let result = Args::new()
        .flag("-v", "--verbose")
        .option("-o", "--output")
        .value("file.txt")
        .unwrap()
        .validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_mixed_2() {
    let result = Args::new()
        .flag("-f", "--force")
        .flag("-n", "--dry-run")
        .option("-c", "--config")
        .value("app.toml")
        .unwrap()
        .optional_positional()
        .validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_empty_validation() {
    let args = Args::new();
    let result = args.validate();
    assert!(result.is_ok());
}

#[test]
fn test_args_basic_usage() {
    let args = Args::new()
        .flag("-v", "--verbose")
        .optional_option("-o", "--output")
        .optional_positional()
        .validate();

    assert!(args.is_ok());
}

#[test]
fn test_args_build() {
    let args = Args::new()
        .flag("-v", "--verbose")
        .option("-o", "--output")
        .value("out.txt")
        .unwrap()
        .build();

    assert!(!args.is_empty());
}