linear-cli 0.3.5

use std::process::Command;

/// Helper to run CLI commands and capture output
fn run_cli(args: &[&str]) -> (i32, String, String) {
    let output = Command::new(env!("CARGO_BIN_EXE_linear-cli"))
        .args(args)
        .output()
        .expect("Failed to execute command");

    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
    let code = output.status.code().unwrap_or(-1);

    (code, stdout, stderr)
}

#[test]
fn test_help_command() {
    let (code, stdout, _stderr) = run_cli(&["--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("A powerful CLI for Linear.app"));
    assert!(stdout.contains("Commands:"));
}

#[test]
fn test_version_command() {
    let (code, stdout, _stderr) = run_cli(&["--version"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("linear") || stdout.contains("0.1"));
}

#[test]
fn test_projects_help() {
    let (code, stdout, _stderr) = run_cli(&["projects", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
    assert!(stdout.contains("create"));
}

#[test]
fn test_issues_help() {
    let (code, stdout, _stderr) = run_cli(&["issues", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
    assert!(stdout.contains("create"));
    assert!(stdout.contains("start"));
    assert!(stdout.contains("stop"));
}

#[test]
fn test_teams_help() {
    let (code, stdout, _stderr) = run_cli(&["teams", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
}

#[test]
fn test_config_help() {
    let (code, stdout, _stderr) = run_cli(&["config", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("set-key"));
    assert!(stdout.contains("show"));
    assert!(stdout.contains("workspace-add"));
    assert!(stdout.contains("workspace-list"));
}

#[test]
fn test_bulk_help() {
    let (code, stdout, _stderr) = run_cli(&["bulk", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("update-state"));
    assert!(stdout.contains("assign"));
    assert!(stdout.contains("label"));
}

#[test]
fn test_search_help() {
    let (code, stdout, _stderr) = run_cli(&["search", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("issues"));
    assert!(stdout.contains("projects"));
}

#[test]
fn test_git_help() {
    let (code, stdout, _stderr) = run_cli(&["git", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("checkout"));
    assert!(stdout.contains("branch"));
}

#[test]
fn test_sync_help() {
    let (code, stdout, _stderr) = run_cli(&["sync", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("status"));
    assert!(stdout.contains("push"));
}

#[test]
fn test_aliases_work() {
    // Test short aliases
    let (code1, stdout1, _) = run_cli(&["p", "--help"]);
    let (code2, stdout2, _) = run_cli(&["projects", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);

    let (code3, stdout3, _) = run_cli(&["i", "--help"]);
    let (code4, stdout4, _) = run_cli(&["issues", "--help"]);
    assert_eq!(code3, 0);
    assert_eq!(code4, 0);
    assert_eq!(stdout3, stdout4);
}

#[test]
fn test_output_format_option() {
    let (code, stdout, _stderr) = run_cli(&["--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--output"));
    assert!(stdout.contains("table"));
    assert!(stdout.contains("json"));
}

#[test]
fn test_invalid_command() {
    let (code, _stdout, stderr) = run_cli(&["invalid-command"]);
    assert_ne!(code, 0);
    assert!(stderr.contains("error") || stderr.contains("invalid"));
}

// --- Additional alias tests ---

#[test]
fn test_teams_alias() {
    let (code1, stdout1, _) = run_cli(&["t", "--help"]);
    let (code2, stdout2, _) = run_cli(&["teams", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_comments_alias() {
    let (code1, stdout1, _) = run_cli(&["cm", "--help"]);
    let (code2, stdout2, _) = run_cli(&["comments", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_git_alias() {
    let (code1, stdout1, _) = run_cli(&["g", "--help"]);
    let (code2, stdout2, _) = run_cli(&["git", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_search_alias() {
    let (code1, stdout1, _) = run_cli(&["s", "--help"]);
    let (code2, stdout2, _) = run_cli(&["search", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

// --- Help text completeness ---

#[test]
fn test_notifications_help() {
    let (code, stdout, _stderr) = run_cli(&["notifications", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
    assert!(stdout.contains("read"));
}

#[test]
fn test_labels_help() {
    let (code, stdout, _stderr) = run_cli(&["labels", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
}

#[test]
fn test_cycles_help() {
    let (code, stdout, _stderr) = run_cli(&["cycles", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
}

#[test]
fn test_cache_help() {
    let (code, stdout, _stderr) = run_cli(&["cache", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("status"));
    assert!(stdout.contains("clear"));
}

#[test]
fn test_export_help() {
    let (code, stdout, _stderr) = run_cli(&["export", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("csv"));
}

#[test]
fn test_uploads_help() {
    let (code, stdout, _stderr) = run_cli(&["uploads", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("fetch"));
}

// --- Subcommand help tests ---

#[test]
fn test_issues_list_help() {
    let (code, stdout, _stderr) = run_cli(&["issues", "list", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--team"));
    assert!(stdout.contains("--state"));
    assert!(stdout.contains("--assignee"));
}

#[test]
fn test_issues_create_help() {
    let (code, stdout, _stderr) = run_cli(&["issues", "create", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--team"));
    assert!(stdout.contains("--priority"));
    assert!(stdout.contains("--description"));
    assert!(stdout.contains("--dry-run"));
}

#[test]
fn test_bulk_update_state_help() {
    let (code, stdout, _stderr) = run_cli(&["bulk", "update-state", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("STATE"));
    assert!(stdout.contains("--issues"));
}

// --- Global flags ---

#[test]
fn test_quiet_flag_exists() {
    let (code, stdout, _stderr) = run_cli(&["--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--quiet") || stdout.contains("-q"));
}

#[test]
fn test_dry_run_flag_exists() {
    let (code, stdout, _stderr) = run_cli(&["--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--dry-run"));
}

#[test]
fn test_compact_flag_exists() {
    let (code, stdout, _stderr) = run_cli(&["--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--compact"));
}

#[test]
fn test_fields_flag_exists() {
    let (code, stdout, _stderr) = run_cli(&["--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--fields"));
}

// --- CLI name consistency ---

#[test]
fn test_binary_name_in_help() {
    let (code, stdout, _stderr) = run_cli(&["--help"]);
    assert_eq!(code, 0);
    // The help should show the binary name
    assert!(
        stdout.contains("linear-cli") || stdout.contains("Usage:"),
        "Help output should contain binary name or usage info"
    );
}

#[test]
fn test_version_contains_semver() {
    let (code, stdout, _stderr) = run_cli(&["--version"]);
    assert_eq!(code, 0);
    // Version should contain a semver-like pattern (digit.digit)
    assert!(
        stdout.chars().any(|c| c == '.'),
        "Version output should contain a dot-separated version number"
    );
}

// --- Help tests for commands without coverage ---

#[test]
fn test_time_help() {
    let (code, stdout, _stderr) = run_cli(&["time", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("log"));
    assert!(stdout.contains("list"));
}

#[test]
fn test_relations_help() {
    let (code, stdout, _stderr) = run_cli(&["relations", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
    assert!(stdout.contains("add"));
    assert!(stdout.contains("remove"));
}

#[test]
fn test_favorites_help() {
    let (code, stdout, _stderr) = run_cli(&["favorites", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
    assert!(stdout.contains("add"));
}

#[test]
fn test_roadmaps_help() {
    let (code, stdout, _stderr) = run_cli(&["roadmaps", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
    assert!(stdout.contains("get"));
}

#[test]
fn test_initiatives_help() {
    let (code, stdout, _stderr) = run_cli(&["initiatives", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
    assert!(stdout.contains("get"));
}

#[test]
fn test_documents_help() {
    let (code, stdout, _stderr) = run_cli(&["documents", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
    assert!(stdout.contains("get"));
    assert!(stdout.contains("create"));
}

#[test]
fn test_context_help() {
    let (code, stdout, _stderr) = run_cli(&["context", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("context") || stdout.contains("issue") || stdout.contains("branch"));
}

// --- Alias tests for commands without coverage ---

#[test]
fn test_time_alias() {
    let (code1, stdout1, _) = run_cli(&["tm", "--help"]);
    let (code2, stdout2, _) = run_cli(&["time", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_relations_alias() {
    let (code1, stdout1, _) = run_cli(&["rel", "--help"]);
    let (code2, stdout2, _) = run_cli(&["relations", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_favorites_alias() {
    let (code1, stdout1, _) = run_cli(&["fav", "--help"]);
    let (code2, stdout2, _) = run_cli(&["favorites", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_roadmaps_alias() {
    let (code1, stdout1, _) = run_cli(&["rm", "--help"]);
    let (code2, stdout2, _) = run_cli(&["roadmaps", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_initiatives_alias() {
    let (code1, stdout1, _) = run_cli(&["init", "--help"]);
    let (code2, stdout2, _) = run_cli(&["initiatives", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_documents_alias() {
    let (code1, stdout1, _) = run_cli(&["d", "--help"]);
    let (code2, stdout2, _) = run_cli(&["documents", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_context_alias() {
    let (code1, stdout1, _) = run_cli(&["ctx", "--help"]);
    let (code2, stdout2, _) = run_cli(&["context", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

// --- v0.3.4 new subcommand tests ---

#[test]
fn test_watch_help() {
    let (code, stdout, _stderr) = run_cli(&["watch", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("issue"));
    assert!(stdout.contains("project"));
    assert!(stdout.contains("team"));
}

#[test]
fn test_watch_issue_help() {
    let (code, stdout, _stderr) = run_cli(&["watch", "issue", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--interval"));
}

#[test]
fn test_watch_project_help() {
    let (code, stdout, _stderr) = run_cli(&["watch", "project", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--interval"));
}

#[test]
fn test_watch_team_help() {
    let (code, stdout, _stderr) = run_cli(&["watch", "team", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--interval"));
}

#[test]
fn test_roadmaps_create_help() {
    let (code, stdout, _stderr) = run_cli(&["roadmaps", "create", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--description"));
}

#[test]
fn test_roadmaps_update_help() {
    let (code, stdout, _stderr) = run_cli(&["roadmaps", "update", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--name"));
    assert!(stdout.contains("--dry-run"));
}

#[test]
fn test_initiatives_create_help() {
    let (code, stdout, _stderr) = run_cli(&["initiatives", "create", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--description"));
    assert!(stdout.contains("--status"));
}

#[test]
fn test_initiatives_update_help() {
    let (code, stdout, _stderr) = run_cli(&["initiatives", "update", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--name"));
    assert!(stdout.contains("--status"));
    assert!(stdout.contains("--dry-run"));
}

#[test]
fn test_documents_delete_help() {
    let (code, stdout, _stderr) = run_cli(&["documents", "delete", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--force"));
    assert!(stdout.contains("--dry-run"));
}

#[test]
fn test_roadmaps_help_includes_create() {
    let (code, stdout, _stderr) = run_cli(&["roadmaps", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("create"));
    assert!(stdout.contains("update"));
}

#[test]
fn test_initiatives_help_includes_create() {
    let (code, stdout, _stderr) = run_cli(&["initiatives", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("create"));
    assert!(stdout.contains("update"));
}

#[test]
fn test_documents_help_includes_delete() {
    let (code, stdout, _stderr) = run_cli(&["documents", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("delete"));
}

// --- v0.3.5 new subcommand tests ---

#[test]
fn test_triage_help() {
    let (code, stdout, _stderr) = run_cli(&["triage", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("list"));
    assert!(stdout.contains("claim"));
}

#[test]
fn test_triage_alias() {
    let (code1, stdout1, _) = run_cli(&["tr", "--help"]);
    let (code2, stdout2, _) = run_cli(&["triage", "--help"]);
    assert_eq!(code1, 0);
    assert_eq!(code2, 0);
    assert_eq!(stdout1, stdout2);
}

#[test]
fn test_notifications_archive_help() {
    let (code, stdout, _stderr) = run_cli(&["notifications", "archive", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("id") || stdout.contains("ID"));
}

#[test]
fn test_notifications_archive_all_help() {
    let (code, _stdout, _stderr) = run_cli(&["notifications", "archive-all", "--help"]);
    assert_eq!(code, 0);
}

#[test]
fn test_notifications_help_includes_archive() {
    let (code, stdout, _stderr) = run_cli(&["notifications", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("archive"));
}

#[test]
fn test_cycles_create_help() {
    let (code, stdout, _stderr) = run_cli(&["cycles", "create", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--team"));
    assert!(stdout.contains("--name"));
    assert!(stdout.contains("--starts-at"));
    assert!(stdout.contains("--ends-at"));
}

#[test]
fn test_cycles_update_help() {
    let (code, stdout, _stderr) = run_cli(&["cycles", "update", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("--name"));
    assert!(stdout.contains("--dry-run"));
}

#[test]
fn test_cycles_help_includes_create() {
    let (code, stdout, _stderr) = run_cli(&["cycles", "--help"]);
    assert_eq!(code, 0);
    assert!(stdout.contains("create"));
    assert!(stdout.contains("update"));
}