mielin-cli 0.1.0-rc.1

//! Integration tests for mielinctl CLI
//!
//! These tests verify the complete command-line interface functionality.

use assert_cmd::Command;
use predicates::prelude::*;

/// Helper function to create a command for the mielinctl binary
fn mielinctl() -> Command {
    Command::cargo_bin("mielinctl").expect("Failed to find mielinctl binary")
}

#[test]
fn test_version_command() {
    let mut cmd = mielinctl();
    cmd.arg("version");
    cmd.assert()
        .success()
        .stdout(predicate::str::contains("MielinOS CLI"));
}

#[test]
fn test_version_json_output() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("version").arg("--output").arg("json");
    cmd.assert()
        .success()
        .stdout(predicate::str::contains("\"version\""));
}

#[test]
fn test_help_command() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("--help");
    cmd.assert()
        .success()
        .stdout(predicate::str::contains("MielinOS Control Interface"));
}

#[test]
fn test_node_list() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("node").arg("list");
    cmd.assert().success();
}

#[test]
fn test_node_list_alias_ls() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("node").arg("ls");
    cmd.assert().success();
}

#[test]
fn test_node_list_json_output() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("node").arg("list").arg("--output").arg("json");
    cmd.assert()
        .success()
        .stdout(predicate::str::contains("\"nodes\""));
}

#[test]
fn test_node_info() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("node").arg("info").arg("test-node-id");
    cmd.assert().success();
}

#[test]
fn test_node_info_alias_show() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("node").arg("show").arg("test-node-id");
    cmd.assert().success();
}

#[test]
fn test_agent_list() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("agent").arg("list");
    cmd.assert().success();
}

#[test]
fn test_agent_list_alias_ls() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("agent").arg("ls");
    cmd.assert().success();
}

#[test]
fn test_agent_list_with_filter() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("agent")
        .arg("list")
        .arg("--state")
        .arg("Running");
    cmd.assert().success();
}

#[test]
fn test_agent_inspect() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("agent").arg("inspect").arg("test-agent-id");
    cmd.assert().success();
}

#[test]
fn test_agent_inspect_alias_show() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("agent").arg("show").arg("test-agent-id");
    cmd.assert().success();
}

#[test]
fn test_agent_create_without_wasm_file() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("agent")
        .arg("create")
        .arg("nonexistent.wasm")
        .arg("--name")
        .arg("test-agent");
    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("WASM file not found"));
}

#[test]
fn test_agent_create_invalid_env_format() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();

    // Create a temporary wasm file for testing
    let temp_dir = std::env::temp_dir();
    let wasm_path = temp_dir.join("test.wasm");
    std::fs::write(&wasm_path, b"test").unwrap();

    cmd.arg("agent")
        .arg("create")
        .arg(&wasm_path)
        .arg("--name")
        .arg("test-agent")
        .arg("--env")
        .arg("INVALID_FORMAT");

    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("Invalid environment variable format"));

    // Cleanup
    std::fs::remove_file(&wasm_path).ok();
}

#[test]
fn test_agent_exec_no_command() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("agent").arg("exec").arg("test-agent-id");
    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("required"));
}

#[test]
fn test_cluster_init() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("cluster").arg("init").arg("test-cluster");
    cmd.assert().success();
}

#[test]
fn test_cluster_init_alias_setup() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("cluster").arg("setup").arg("test-cluster");
    cmd.assert().success();
}

#[test]
fn test_cluster_status() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("cluster").arg("status");
    cmd.assert().success();
}

#[test]
fn test_cluster_status_alias_st() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("cluster").arg("st");
    cmd.assert().success();
}

#[test]
fn test_cluster_health() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("cluster").arg("health");
    cmd.assert().success();
}

#[test]
fn test_cluster_health_alias_check() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("cluster").arg("check");
    cmd.assert().success();
}

#[test]
fn test_mesh_status() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("mesh").arg("status");
    cmd.assert().success();
}

#[test]
fn test_mesh_status_alias_st() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("mesh").arg("st");
    cmd.assert().success();
}

#[test]
fn test_mesh_peers() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("mesh").arg("peers");
    cmd.assert().success();
}

#[test]
fn test_mesh_peers_alias_ls() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("mesh").arg("ls");
    cmd.assert().success();
}

#[test]
fn test_migrate_status() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("migrate").arg("status");
    cmd.assert().success();
}

#[test]
fn test_migrate_status_alias_st() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("migrate").arg("st");
    cmd.assert().success();
}

#[test]
fn test_migrate_history() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("migrate").arg("history");
    cmd.assert().success();
}

#[test]
fn test_migrate_history_with_limit() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("migrate").arg("history").arg("-n").arg("5");
    cmd.assert().success();
}

#[test]
fn test_registry_list() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("registry").arg("list");
    cmd.assert().success();
}

#[test]
fn test_registry_list_alias_ls() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("registry").arg("ls");
    cmd.assert().success();
}

#[test]
fn test_registry_query() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("registry").arg("query").arg("test-pattern");
    cmd.assert().success();
}

#[test]
fn test_registry_query_alias_search() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("registry").arg("search").arg("test-pattern");
    cmd.assert().success();
}

#[test]
fn test_registry_stats() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("registry").arg("stats");
    cmd.assert().success();
}

#[test]
fn test_gossip_status() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("gossip").arg("status");
    cmd.assert().success();
}

#[test]
fn test_gossip_members() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("gossip").arg("members");
    cmd.assert().success();
}

#[test]
fn test_gossip_members_alive_filter() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("gossip").arg("members").arg("--alive");
    cmd.assert().success();
}

#[test]
fn test_gossip_sync() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("gossip").arg("sync");
    cmd.assert().success();
}

#[test]
fn test_wasm_validate_nonexistent() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("wasm").arg("validate").arg("nonexistent.wasm");
    cmd.assert().failure();
}

#[test]
fn test_wasm_validate_alias_check() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();

    // Create a temporary wasm file for testing
    let temp_dir = std::env::temp_dir();
    let wasm_path = temp_dir.join("test_validate.wasm");
    std::fs::write(&wasm_path, b"test").unwrap();

    cmd.arg("wasm").arg("check").arg(&wasm_path);
    cmd.assert().success();

    // Cleanup
    std::fs::remove_file(&wasm_path).ok();
}

#[test]
fn test_debug_attach() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("debug").arg("attach").arg("test-agent-id");
    cmd.assert().success();
}

#[test]
fn test_debug_attach_with_port() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("debug")
        .arg("attach")
        .arg("test-agent-id")
        .arg("--port")
        .arg("9999");
    cmd.assert().success();
}

#[test]
fn test_debug_trace() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("debug").arg("trace").arg("test-agent-id");
    cmd.assert().success();
}

#[test]
fn test_debug_dump() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("debug").arg("dump").arg("test-agent-id");
    cmd.assert().success();
}

#[test]
fn test_debug_profile() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("debug").arg("profile").arg("test-agent-id");
    cmd.assert().success();
}

#[test]
fn test_quiet_mode() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("--quiet").arg("node").arg("list");
    cmd.assert().success();
}

#[test]
fn test_output_format_yaml() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("--output").arg("yaml").arg("node").arg("list");
    cmd.assert()
        .success()
        .stdout(predicate::str::contains("nodes:"));
}

#[test]
fn test_completion_bash() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("completion").arg("bash");
    cmd.assert()
        .success()
        .stdout(predicate::str::contains("complete"));
}

#[test]
fn test_completion_zsh() {
    let mut cmd = Command::cargo_bin("mielinctl").unwrap();
    cmd.arg("completion").arg("zsh");
    cmd.assert()
        .success()
        .stdout(predicate::str::contains("compdef"));
}