canic-cli 0.223.1

Canic command line deployment tool
use super::*;
use crate::args::Cli;
use clap::Parser as _;
use ic_topology::subnet::{
    compare::{Candidate, DistributionOutcome, SubnetComparisonReport},
    distribution::DistributionError,
    metrics::{MetricsOutcome, SubnetMetricsError},
};
use std::time::Duration;

fn fixture() -> FleetSubnetComparison {
    let candidate = |id: &str| Candidate {
        subnet_id: id.parse().unwrap(),
        distribution: DistributionOutcome::Failed {
            error: DistributionError::InitialDeadline,
        },
        metrics: MetricsOutcome::Failed {
            error: SubnetMetricsError::Read(ic_topology::ReadError::Deadline),
        },
    };
    FleetSubnetComparison {
        app: "app\u{1b}[31m".into(),
        fleet: "mainnet".into(),
        observation: SubnetComparisonReport {
            schema: 1,
            left: candidate("aaaaa-aa"),
            right: candidate("2vxsx-fae"),
            started_at_unix_seconds: 1,
            elapsed: Duration::from_secs(5),
            collection_complete: false,
            atomic_snapshot: false,
            registry_versions_agree: None,
        },
    }
}

#[test]
fn subnet_comparison_cli_scopes_explicit_candidates() {
    assert!(
        Cli::try_parse_from([
            "canic",
            "fleet",
            "compare-subnets",
            "aaaaa-aa",
            "2vxsx-fae",
            "--app",
            "app",
            "--fleet",
            "ic",
            "--json"
        ])
        .is_ok()
    );
    assert!(Cli::try_parse_from(["canic", "fleet", "compare-subnets", "aaaaa-aa"]).is_err());
    for forbidden in [
        "--state-dir",
        "--identity",
        "--no-config",
        "--watch",
        "--serve",
    ] {
        assert!(
            Cli::try_parse_from([
                "canic",
                "fleet",
                "compare-subnets",
                "aaaaa-aa",
                "2vxsx-fae",
                forbidden
            ])
            .is_err()
        );
    }
}

#[test]
fn subnet_comparison_missing_and_zero_metrics_remain_distinct() {
    use ic_topology::subnet::metrics::{SubnetMetricsEvidence, SubnetMetricsReport};
    let mut report = fixture();
    assert!(render(&report).contains("Infrastructure overlap unavailable"));
    report.observation.left.metrics = MetricsOutcome::Read {
        report: SubnetMetricsReport {
            schema: 1,
            subnet_id: report.observation.left.subnet_id,
            num_canisters: 0,
            canister_state_bytes: u64::MAX,
            consumed_cycles_total: u128::MAX,
            update_transactions_total: 0,
            evidence: SubnetMetricsEvidence {
                endpoint: "https://ic0.app",
                source_path: "left".into(),
                state_tree_path: "metrics".into(),
                observed_at_unix_seconds: 123,
                state_certificate_verified: true,
            },
        },
    };
    let text = render(&report);
    assert!(text.contains(&u64::MAX.to_string()));
    assert!(text.contains("unavailable") && text.contains("| OBSERVATION"));
    assert!(!text.contains('\u{1b}'));
    assert!(matches!(output(&report, false), Output::Partial(_)));
    let Output::Partial(inner) = output(&report, true) else {
        panic!("partial")
    };
    let Output::Json(value) = *inner else {
        panic!("JSON")
    };
    assert_eq!(
        value["observation"]["left"]["metrics"]["report"]["num_canisters"],
        0
    );
    assert_eq!(
        value["observation"]["left"]["metrics"]["report"]["consumed_cycles_total"],
        u128::MAX.to_string()
    );
    assert_eq!(value["observation"]["right"]["metrics"]["status"], "failed");
    assert!(value["observation"]["infrastructure_overlap"].is_null());
    assert_eq!(value["app"], report.app);
}

#[tokio::test]
async fn subnet_comparison_duplicate_is_refused_without_journal_access() {
    let parent = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("../../target/subnet-comparison-tests");
    std::fs::create_dir_all(&parent).unwrap();
    let root = crate::tests::directory(&parent, "duplicate").unwrap();
    let path = root.join("canic.toml");
    let raw = crate::tests::UNBOUND_FLEET;
    std::fs::write(&path, raw).unwrap();
    let cli = Cli::try_parse_from([
        "canic",
        "fleet",
        "compare-subnets",
        "aaaaa-aa",
        "aaaaa-aa",
        "--config",
        path.to_str().unwrap(),
    ])
    .unwrap();
    assert!(crate::run(&cli).await.is_err());
    assert_eq!(std::fs::read_to_string(&path).unwrap(), raw);
    assert_eq!(std::fs::read_dir(&root).unwrap().count(), 1);
}

#[test]
fn subnet_comparison_overlap_keeps_unknown_coverage_and_independent_versions() {
    use ic_topology::subnet::{
        configuration::{SubnetConfigurationEvidence, SubnetConfigurationReport},
        distribution::{DistributionSummary, GroupCount, SubnetDistributionReport},
    };
    let distribution = |side: &Candidate, version| SubnetDistributionReport {
        schema: 1,
        endpoint: "https://ic0.app",
        source_canister: "rwlgt-iiaaa-aaaaa-aaaaa-cai",
        version_method: "get_latest_version",
        requested_registry_version: version,
        version_observed_at_unix_seconds: 100,
        started_at_unix_seconds: 99,
        elapsed: Duration::from_secs(1),
        query_signature_verified: true,
        result_certified: false,
        overall_deadline_reached: false,
        complete: false,
        configuration: SubnetConfigurationReport {
            schema: 1,
            subnet_id: side.subnet_id,
            registered_node_ids: vec![
                "ryjl3-tyaaa-aaaaa-aaaba-cai".parse().unwrap(),
                "rwlgt-iiaaa-aaaaa-aaaaa-cai".parse().unwrap(),
            ],
            replica_version_id: "version\n\u{1b}[31m".into(),
            registered_subnet_type: 1,
            is_halted: false,
            halt_at_cup_height: false,
            evidence: SubnetConfigurationEvidence {
                endpoint: "https://ic0.app",
                source_canister: "rwlgt-iiaaa-aaaaa-aaaaa-cai",
                source_method: "get_value",
                source_key: format!("subnet_record_{}", side.subnet_id),
                observed_at_unix_seconds: 100,
                record_version: version,
                record_timestamp_nanoseconds: 0,
                query_signature_verified: true,
                result_certified: false,
                membership_complete: true,
            },
        },
        nodes: vec![],
        operators: vec![],
        data_centers: vec![],
        relationships: vec![],
        summary: DistributionSummary {
            selected_nodes: 2,
            provider_resolved: 1,
            provider_unknown: 1,
            data_center_references_resolved: 0,
            location_resolved: 0,
            location_unknown: 2,
            providers: vec![GroupCount {
                value: "ryjl3-tyaaa-aaaaa-aaaba-cai".parse().unwrap(),
                nodes: 1,
            }],
            data_centers: vec![],
            regions: vec![],
            region_unknown: 2,
            owners: vec![],
            owner_unknown: 2,
        },
    };
    let mut report = fixture();
    report.observation.left.distribution = DistributionOutcome::Read {
        report: Box::new(distribution(&report.observation.left, 10)),
    };
    report.observation.right.distribution = DistributionOutcome::Read {
        report: Box::new(distribution(&report.observation.right, 11)),
    };
    report.observation.registry_versions_agree = Some(false);
    let text = render(&report);
    assert!(
        text.contains("Observed infrastructure overlap")
            && text.contains("Providers")
            && text.contains("Data centers")
    );
    assert!(text.contains("1 known / 1 unknown") && text.contains("0 known / 2 unknown"));
    assert!(!text.contains('\u{1b}'));
    let Output::Partial(inner) = output(&report, true) else {
        panic!("partial")
    };
    let Output::Json(value) = *inner else {
        panic!("JSON")
    };
    let overlap = &value["observation"]["infrastructure_overlap"];
    assert_eq!(overlap["providers"]["shared"].as_array().unwrap().len(), 1);
    assert_eq!(overlap["providers"]["coverage_complete"], false);
    assert_eq!(overlap["data_centers"]["left_unknown_nodes"], 2);
    assert_eq!(value["observation"]["registry_versions_agree"], false);
}