iridium-db 0.4.0

use super::*;

#[test]
fn parse_put_edge() {
    let args = vec![
        "ir".to_string(),
        "put-edge".to_string(),
        "10".to_string(),
        "2".to_string(),
        "payload".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::PutEdge {
            node_id: 10,
            version: 2,
            payload: b"payload".to_vec(),
        }
    );
}

#[test]
fn parse_put_full() {
    let args = vec![
        "ir".to_string(),
        "put-full".to_string(),
        "3".to_string(),
        "1".to_string(),
        "5,7,9".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::PutFull {
            node_id: 3,
            version: 1,
            adjacency: vec![5, 7, 9],
        }
    );
}

#[test]
fn parse_recover() {
    let args = vec!["ir".to_string(), "recover".to_string()];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(cmd, Command::Recover);
}

#[test]
fn parse_help_variants() {
    let long = vec!["ir".to_string(), "--help".to_string()];
    let short = vec!["ir".to_string(), "-h".to_string()];
    let word = vec!["ir".to_string(), "help".to_string()];
    let empty = vec!["ir".to_string()];
    assert_eq!(parse_args(&long).unwrap().command, Command::Help);
    assert_eq!(parse_args(&short).unwrap().command, Command::Help);
    assert_eq!(parse_args(&word).unwrap().command, Command::Help);
    assert_eq!(parse_args(&empty).unwrap().command, Command::Help);
}

#[test]
fn parse_with_data_option() {
    let args = vec![
        "ir".to_string(),
        "--data".to_string(),
        "/tmp/ir-data".to_string(),
        "query".to_string(),
        "MATCH".to_string(),
        "(n)".to_string(),
        "RETURN".to_string(),
        "n".to_string(),
    ];
    let parsed = parse_args(&args).unwrap();
    assert_eq!(parsed.data_dir, Some(PathBuf::from("/tmp/ir-data")));
    assert_eq!(parsed.wal_sync_policy, None);
    assert_eq!(parsed.wal_sync_interval_ms, None);
    assert_eq!(
        parsed.command,
        Command::Query {
            query: "MATCH (n) RETURN n".to_string()
        }
    );
}

#[test]
fn parse_with_wal_sync_global_options() {
    let args = vec![
        "ir".to_string(),
        "--wal-sync-policy".to_string(),
        "manual".to_string(),
        "--wal-sync-interval-ms".to_string(),
        "250".to_string(),
        "stats".to_string(),
    ];
    let parsed = parse_args(&args).unwrap();
    assert_eq!(parsed.wal_sync_policy, Some("manual".to_string()));
    assert_eq!(parsed.wal_sync_interval_ms, Some(250));
    assert_eq!(parsed.command, Command::Stats);
}

#[test]
fn parse_query_command() {
    let args = vec![
        "ir".to_string(),
        "parse".to_string(),
        "MATCH".to_string(),
        "(n)".to_string(),
        "RETURN".to_string(),
        "n".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::Parse {
            query: "MATCH (n) RETURN n".to_string(),
        }
    );
}

#[test]
fn parse_explain_command() {
    let args = vec![
        "ir".to_string(),
        "explain".to_string(),
        "MATCH".to_string(),
        "(n)".to_string(),
        "RETURN".to_string(),
        "n".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::Explain {
            query: "MATCH (n) RETURN n".to_string(),
        }
    );
}

#[test]
fn parse_query_exec_command() {
    let args = vec![
        "ir".to_string(),
        "query".to_string(),
        "MATCH".to_string(),
        "(n)".to_string(),
        "RETURN".to_string(),
        "n".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::Query {
            query: "MATCH (n) RETURN n".to_string(),
        }
    );
}

#[test]
fn parse_contract_report_command() {
    let args = vec![
        "ir".to_string(),
        "contract-report".to_string(),
        "acceptance".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::ContractReport {
            scenario: "acceptance".to_string(),
        }
    );
}

#[test]
fn parse_evidence_report_command() {
    let args = vec![
        "ir".to_string(),
        "evidence-report".to_string(),
        "restart-requery".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::EvidenceReport {
            surface: "restart-requery".to_string(),
        }
    );
}

#[test]
fn parse_service_report_command() {
    let args = vec![
        "ir".to_string(),
        "service-report".to_string(),
        "--listen".to_string(),
        "0.0.0.0:7443".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::ServiceReport {
            listen: Some("0.0.0.0:7443".to_string()),
        }
    );
}

#[test]
fn parse_service_validate_command() {
    let args = vec![
        "ir".to_string(),
        "service-validate".to_string(),
        "--listen".to_string(),
        "0.0.0.0:7443".to_string(),
        "--telemetry-endpoint".to_string(),
        "stdout".to_string(),
        "--tls".to_string(),
        "operator-optional".to_string(),
        "--admin-token".to_string(),
        "secret".to_string(),
        "--max-requests".to_string(),
        "5".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::ServiceValidate {
            listen: Some("0.0.0.0:7443".to_string()),
            telemetry_endpoint: Some("stdout".to_string()),
            tls: "operator-optional".to_string(),
            admin_token: Some("secret".to_string()),
            max_requests: 5,
        }
    );
}

#[test]
fn parse_service_serve_command() {
    let args = vec![
        "ir".to_string(),
        "service-serve".to_string(),
        "--listen".to_string(),
        "127.0.0.1:7001".to_string(),
        "--tls".to_string(),
        "disabled".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::ServiceServe {
            listen: Some("127.0.0.1:7001".to_string()),
            telemetry_endpoint: None,
            tls: "disabled".to_string(),
            admin_token: None,
            max_requests: 0,
        }
    );
}

#[test]
fn parse_ingest_edge_command() {
    let args = vec![
        "ir".to_string(),
        "ingest-edge".to_string(),
        "11".to_string(),
        "3".to_string(),
        "payload".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::IngestEdge {
            node_id: 11,
            version: 3,
            payload: b"payload".to_vec(),
        }
    );
}

#[test]
fn parse_health_command() {
    let args = vec!["ir".to_string(), "health".to_string()];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(cmd, Command::Health);
}

#[test]
fn parse_metrics_command() {
    let args = vec!["ir".to_string(), "metrics".to_string()];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(cmd, Command::Metrics);
}

#[test]
fn parse_metrics_prom_command() {
    let args = vec!["ir".to_string(), "metrics-prom".to_string()];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(cmd, Command::MetricsProm);
}

#[test]
fn parse_status_command() {
    let args = vec!["ir".to_string(), "status".to_string()];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(cmd, Command::Status);
}

#[test]
fn parse_trigger_compaction_with_level() {
    let args = vec![
        "ir".to_string(),
        "trigger-compaction".to_string(),
        "--level".to_string(),
        "2".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(cmd, Command::TriggerCompaction { level: Some(2) });
}

#[test]
fn parse_recluster_force() {
    let args = vec![
        "ir".to_string(),
        "recluster".to_string(),
        "--force".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(cmd, Command::Recluster { force: true });
}

#[test]
fn parse_ingest_file_command() {
    let args = vec![
        "ir".to_string(),
        "ingest".to_string(),
        "--file".to_string(),
        "events.jsonl".to_string(),
        "--batch-size".to_string(),
        "256".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::IngestFile {
            path: PathBuf::from("events.jsonl"),
            batch_size: 256,
        }
    );
}

#[test]
fn parse_bench_with_options() {
    let args = vec![
        "ir".to_string(),
        "bench".to_string(),
        "1000".to_string(),
        "--seed".to_string(),
        "99".to_string(),
        "--json".to_string(),
        "artifacts/out.json".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::Bench {
            iterations: 1000,
            seed: 99,
            json_out: Some(PathBuf::from("artifacts/out.json")),
        }
    );
}

#[test]
fn parse_ingest_batch_edge_loop_command() {
    let args = vec![
        "ir".to_string(),
        "ingest-batch-edge-loop".to_string(),
        "100".to_string(),
        "50".to_string(),
        "3".to_string(),
        "2".to_string(),
        "pref".to_string(),
    ];
    let cmd = parse_args(&args).unwrap().command;
    assert_eq!(
        cmd,
        Command::IngestBatchEdgeLoop {
            start_node_id: 100,
            count: 50,
            rounds: 3,
            version: 2,
            payload_prefix: "pref".to_string(),
        }
    );
}