canic-cli 0.223.1

Canic command line deployment tool
use super::*;
use std::process::Command;

#[test]
fn slot_summaries_expose_network_and_identity_conflicts_without_erasing_evidence() {
    use canic_host::{
        CanisterConfig, DeploymentName, FleetConfig, FleetOperation, Network, SelectedFleet,
    };
    use std::collections::BTreeMap;

    let network = Network::Local {
        url: "http://localhost:8000".into(),
        root_key: "00".repeat(133),
        root_subnet: None,
        routing_canister: "aaaaa-aa".into(),
    };
    let mut snapshot = Fleet {
        configuration: Some(SelectedFleet {
            app: "app".into(),
            fleet: "demo".into(),
            config: FleetConfig {
                shard_pool: None,
                auth: Vec::new(),
                network: network.clone(),
                journal: None,
                canisters: BTreeMap::from([("worker".into(), CanisterConfig::default())]),
            },
        }),
        started_at_ns: 0,
        finished_at_ns: 0,
        scope: "test",
        canisters: vec![],
        operations: vec![FleetOperation {
            store_root: None,
            slot: None,
            upgrade: None,
            management: None,
            deployment: Some(DeploymentName {
                app: "app".into(),
                fleet: "demo".into(),
                canister: "worker".into(),
            }),
            operation: "original-operation".into(),
            network_id: network.binding_id().unwrap(),
            network: "local / http://localhost:8000".into(),
            canister: Some("original-principal".into()),
            approved_module: "original-module".into(),
            approved_controller: "original-controller".into(),
            effects: BTreeMap::new(),
            receipt_retained: false,
            approval_expired: true,
        }],
        issues: vec![],
        managers: vec![],
        metrics: vec![],
        stores: vec![],
        wallet: None,
    };
    assert_eq!(
        slot_status(&snapshot, "worker"),
        "original-principal (retained deployment identity)"
    );
    // Same endpoint, app, fleet and principal: only the trust anchor changed.
    let Network::Local { root_key, .. } =
        &mut snapshot.configuration.as_mut().unwrap().config.network
    else {
        unreachable!()
    };
    *root_key = "01".repeat(133);
    for configured_id in [None, Some("original-principal".into())] {
        snapshot
            .configuration
            .as_mut()
            .unwrap()
            .config
            .canisters
            .get_mut("worker")
            .unwrap()
            .id = configured_id;
        let before = serde_json::to_value(&snapshot).unwrap();
        assert!(slot_status(&snapshot, "worker").starts_with("Network conflict"));
        for output in [
            render(&snapshot, ""),
            terminal(&snapshot, &[], false, false),
        ] {
            assert!(output.contains("Network conflict"));
            assert!(output.contains("original-principal"));
            assert!(output.contains("original-operation"));
        }
        assert_eq!(serde_json::to_value(&snapshot).unwrap(), before);
    }
    snapshot.configuration.as_mut().unwrap().config.network = network;
    assert_eq!(
        slot_status(&snapshot, "worker"),
        "original-principal (configured identity; metadata below)"
    );
    snapshot
        .configuration
        .as_mut()
        .unwrap()
        .config
        .canisters
        .get_mut("worker")
        .unwrap()
        .id = Some("replacement-principal".into());
    for output in [
        render(&snapshot, ""),
        terminal(&snapshot, &[], false, false),
    ] {
        assert!(output.contains("Identity conflict"));
        assert!(output.contains("original-principal"));
    }
    snapshot.operations[0].canister = None;
    assert!(slot_status(&snapshot, "worker").starts_with("Identity conflict"));
}

#[test]
fn report_escapes_untrusted_text_and_labels_partial_inventory() {
    let mut snapshot = Fleet {
        configuration: None,
        started_at_ns: 0,
        finished_at_ns: 0,
        scope: "local deployment journal only",
        canisters: vec![],
        operations: vec![],
        issues: vec!["<script>alert('unsafe')</script> & \"quoted\"".into()],
        managers: vec![],
        metrics: vec![],
        stores: vec![],
        wallet: None,
    };
    snapshot.managers.push(canic_host::FleetManager {
        slot: None,
        upgrade: None,
        network_id: "local".into(),
        manager: "manager<script>".into(),
        reported: Some(Default::default()),
        observation_error: Some("<bad provider>".into()),
    });
    let status = snapshot.managers[0].reported.as_mut().unwrap();
    status.phase = canic_host::ManagementPhase::CreateIssued;
    status.attempts = [1, 0, 0];
    snapshot.wallet = Some(canic_host::Wallet {
        principal: "owner<script>".into(),
        icp_address: "address<unsafe>".into(),
        network: "ic / mainnet",
        certified: false,
        icp: canic_host::WalletBalance {
            ledger: "icp",
            amount: Some("510925125".into()),
            display: Some("5.10925125 ICP".into()),
            observed_at_ns: 0,
            observation_error: None,
        },
        cycles: canic_host::WalletBalance {
            ledger: "cycles",
            amount: None,
            display: None,
            observed_at_ns: 0,
            observation_error: Some("<failed ledger>".into()),
        },
    });
    let html = render(&snapshot, "");
    assert!(!html.contains("<script>alert"));
    assert!(html.contains("&lt;script&gt;alert(&#39;unsafe&#39;)"));
    assert!(html.contains("Partial inventory"));
    assert!(html.contains("0 canisters"));
    assert!(html.contains("Regenerate the report to refresh"));
    assert!(html.contains("manager&lt;script&gt;"));
    assert!(html.contains("&lt;bad provider&gt;"));
    assert!(html.contains("No reported principal"));
    assert!(html.contains("No second creation is authorized"));
    assert!(html.contains("Manager report (uncertified)"));
    assert!(html.contains("Uncertified balance queries"));
    assert!(html.contains("owner&lt;script&gt;"));
    assert!(html.contains("address&lt;unsafe&gt;"));
    assert!(html.contains("5.10925125 ICP"));
    assert!(html.contains("<strong>Unknown</strong>"));
    assert!(html.contains("&lt;failed ledger&gt;"));
    assert!(!html.contains("0.000000000000 T cycles"));
}

#[test]
fn declared_routes_require_unambiguous_known_network_and_escape_text() {
    let mut snapshot = Fleet {
        configuration: None,
        started_at_ns: 0,
        finished_at_ns: 0,
        scope: "local deployment journal only",
        canisters: vec![],
        operations: vec![],
        issues: vec![],
        managers: vec![],
        metrics: vec![],
        stores: vec![],
        wallet: None,
    };
    let link = "entry<script>:worker".to_owned();
    assert!(declared_routes(&snapshot, std::slice::from_ref(&link)).is_err());
    for canister in ["entry<script>", "worker"] {
        snapshot.canisters.push(canic_host::FleetCanister {
            network_id: "network-a".into(),
            network: "local".into(),
            canister: canister.into(),
            observed_at_ns: 0,
            module_hash: None,
            controllers: None,
            observation_error: Some("unavailable".into()),
        });
    }
    let html = declared_routes(&snapshot, std::slice::from_ref(&link)).unwrap();
    assert!(html.contains("Declared ยท not verified"));
    assert!(html.contains("Source canister"));
    assert!(html.contains("Destination canister"));
    assert!(!html.contains("Profile"));
    assert!(!html.contains("owns private data"));
    assert!(html.contains("entry&lt;script&gt;"));
    assert!(!html.contains("entry<script>"));
    snapshot.canisters[1].network_id = "network-b".into();
    assert!(declared_routes(&snapshot, std::slice::from_ref(&link)).is_err());
    snapshot.canisters[1].network_id = "network-a".into();
    for canister in ["entry<script>", "worker"] {
        snapshot.canisters.push(canic_host::FleetCanister {
            network_id: "network-b".into(),
            network: "local".into(),
            canister: canister.into(),
            observed_at_ns: 0,
            module_hash: None,
            controllers: None,
            observation_error: None,
        });
    }
    assert!(declared_routes(&snapshot, &[link]).is_err());
}

#[test]
fn metrics_views_preserve_exact_text_unknowns_and_reset_windows() {
    let mut snapshot = Fleet {
        configuration: None,
        started_at_ns: 0,
        finished_at_ns: 100,
        scope: "fixture",
        canisters: vec![],
        operations: vec![],
        issues: vec![],
        managers: vec![],
        metrics: vec![],
        stores: vec![],
        wallet: None,
    };
    assert!(!render(&snapshot, "").contains("Timer metrics ยท"));
    let counter =
        |total: &str, overflowed: bool| serde_json::json!({"total":total,"overflowed":overflowed});
    snapshot.metrics.push(canic_host::FleetMetrics {
        network_id: "network<script>".into(),
        canister: "owner<img>".into(),
        reported: Some(
            serde_json::from_value(serde_json::json!({
                "observed_at_ns":3_000_000_000_u64,
                "timers":{
                    "started_at_version":7,"started_at_ns":2_000_000_000_u64,
                    "accepted":counter(&u128::MAX.to_string(),true),
                    "completed":counter("4",false), "abandoned":counter("1",false),
                    "expected_failures":counter("0",false),
                    "deferred_submissions":counter("2",false), "provider_faults":counter("0",false),
                }
            }))
            .unwrap(),
        ),
        observation_error: None,
    });
    snapshot.metrics.push(canic_host::FleetMetrics {
        network_id: "network<script>".into(),
        canister: "old-owner".into(),
        reported: None,
        observation_error: Some("<script>unavailable</script>".into()),
    });
    snapshot.metrics.push(canic_host::FleetMetrics {
        network_id: "network<script>".into(),
        canister: "no-provider".into(),
        reported: Some(
            serde_json::from_value(serde_json::json!({"observed_at_ns":0,"timers":null})).unwrap(),
        ),
        observation_error: None,
    });
    let before = serde_json::to_value(&snapshot).unwrap();
    let html = render(&snapshot, "");
    let text = terminal(&snapshot, &[], true, false);
    assert!(html.contains(
        "<details class=metrics><summary>Timer metrics ยท uncertified diagnostics</summary>"
    ));
    assert!(html.contains("Runtime started at version 7"));
    assert!(html.contains("data-ns=\"2000000000\""));
    assert!(html.contains("data-ns=\"3000000000\""));
    assert!(html.contains("owner&lt;img&gt;"));
    assert!(html.contains("network&lt;script&gt;"));
    assert!(html.contains("&lt;script&gt;unavailable&lt;/script&gt;"));
    assert!(!html.contains("<script>unavailable"));
    assert_eq!(html.matches("<table class=metrics-table>").count(), 1);
    assert_eq!(html.matches("<strong>UNKNOWN</strong>").count(), 2);
    for value in [
        "Accepted",
        "Completed",
        "Abandoned",
        "Expected failures",
        "Deferred submissions",
        "Provider faults",
        "clipped",
        "exact",
        "timer metrics unavailable",
        &u128::MAX.to_string(),
    ] {
        assert!(html.contains(value), "HTML omitted {value}");
        assert!(text.contains(value), "terminal omitted {value}");
    }
    assert!(
        html.contains("<th scope=row>Expected failures</th><td><code>0</code></td><td>exact</td>")
    );
    assert_eq!(serde_json::to_value(&snapshot).unwrap(), before);
}

#[test]
fn browser_handoff_uses_localhost_and_preserves_background_lifetime() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"))
        .ancestors()
        .nth(2)
        .unwrap()
        .join("target/fleet-open-tests");
    std::fs::create_dir_all(&root).unwrap();
    let dir = crate::tests::directory(&root, "launch").unwrap();
    let report = dir.join("- report ' $(literal).html");
    std::fs::write(&report, "report retained").unwrap();
    let marker = dir.join("opened");
    let mut opener = Command::new("sh");
    opener
        .arg("-c")
        .arg("sleep 0.1; printf '%s' \"$1\" > \"$0\"")
        .arg(&marker);
    let expected = "http://localhost:8787/";
    crate::view::launch(expected, opener).unwrap();
    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(3);
    loop {
        if std::fs::read_to_string(&marker).is_ok_and(|value| value == expected) {
            break;
        }
        assert!(
            std::time::Instant::now() < deadline,
            "detached opener did not receive the exact report path"
        );
        std::thread::sleep(std::time::Duration::from_millis(10));
    }
    assert!(crate::view::launch(expected, Command::new(dir.join("missing-opener"))).is_err());
    assert_eq!(std::fs::read_to_string(report).unwrap(), "report retained");
}