use super::super::*;
#[test]
fn local_plan_uses_configured_roles_and_local_artifact_manifest() {
let temp = TempWorkspace::new("canic-host-local-plan");
let workspace_root = temp.path().join("workspace");
let icp_root = temp.path().join("icp");
let config_dir = workspace_root.join("fleets");
fs::create_dir_all(&config_dir).expect("create config dir");
fs::write(config_dir.join("canic.toml"), SAMPLE_CONFIG).expect("write config");
write_artifact(&icp_root, "root", b"root-artifact");
write_artifact(&icp_root, "wasm_store", b"wasm-store-artifact");
write_artifact(&icp_root, "user_hub", b"user-hub-artifact");
write_release_set_manifest(&icp_root);
let plan = build_local_deployment_plan(&LocalDeploymentPlanRequest {
deployment_name: "demo-local".to_string(),
network: "local".to_string(),
workspace_root,
icp_root,
config_path: None,
runtime_variant: "local".to_string(),
build_profile: "fast".to_string(),
});
assert_eq!(plan.plan_id, "local:local:demo-local:plan");
assert_eq!(plan.deployment_identity.deployment_name, "demo-local");
assert_eq!(
plan.deployment_identity
.deployment_manifest_digest
.as_ref()
.map(String::len),
Some(64)
);
assert_eq!(
plan.deployment_identity
.canonical_runtime_config_digest
.as_ref()
.map(String::len),
Some(64)
);
assert_eq!(
plan.deployment_identity
.authority_profile_hash
.as_ref()
.map(String::len),
Some(64)
);
assert_eq!(
plan.deployment_identity
.role_topology_hash
.as_ref()
.map(String::len),
Some(64)
);
assert_eq!(
plan.deployment_identity
.artifact_set_digest
.as_ref()
.map(String::len),
Some(64)
);
assert_eq!(
plan.deployment_identity
.pool_identity_set_digest
.as_ref()
.map(String::len),
Some(64)
);
assert_eq!(
plan.role_artifacts[0]
.raw_config_sha256
.as_ref()
.map(String::len),
Some(64)
);
assert_eq!(plan.fleet_template, "demo");
assert_eq!(plan.runtime_variant, "local");
assert_eq!(plan.role_artifacts.len(), 3);
assert!(
plan.role_artifacts
.iter()
.all(|artifact| artifact.build_profile == "fast")
);
assert_plan_has_implicit_wasm_store_artifact(&plan);
assert_plan_has_user_hub_release_artifact(&plan);
assert_eq!(
plan.expected_canisters
.iter()
.map(|canister| canister.role.as_str())
.collect::<Vec<_>>(),
vec!["root", "wasm_store", "user_hub"]
);
assert_plan_excludes_declared_only_store(&plan);
let root_assumption = plan
.unresolved_assumptions
.iter()
.find(|assumption| assumption.key == "local_state.root_canister_id")
.expect("missing root identity should be recorded");
assert!(root_assumption.description.contains("--allow-unverified"));
}
#[test]
fn local_plan_uses_configured_controllers_as_expected_authority() {
let temp = TempWorkspace::new("canic-host-local-plan-controllers");
let workspace_root = temp.path().join("workspace");
let icp_root = temp.path().join("icp");
let config_dir = workspace_root.join("fleets");
fs::create_dir_all(&config_dir).expect("create config dir");
fs::write(
config_dir.join("canic.toml"),
r#"
controllers = [
"zbf4m-zw3nk-6owqc-qmluz-xhwxt-2pkky-xhjy2-kqxor-qzxsn-6d2bz-nae",
"aaaaa-aa",
]
app_index = []
[fleet]
name = "demo"
[roles.root]
kind = "root"
package = "root"
[roles.user_hub]
kind = "canister"
package = "user_hub"
[roles.user_shard]
kind = "canister"
package = "user_shard"
[roles.store]
kind = "canister"
package = "store"
[app]
init_mode = "enabled"
[app.whitelist]
[subnets.prime.canisters.root]
kind = "root"
"#,
)
.expect("write config");
write_artifact(&icp_root, "root", b"root-artifact");
let plan = build_local_deployment_plan(&LocalDeploymentPlanRequest {
deployment_name: "demo-local".to_string(),
network: "local".to_string(),
workspace_root,
icp_root,
config_path: None,
runtime_variant: "local".to_string(),
build_profile: "fast".to_string(),
});
assert_eq!(
plan.authority_profile.expected_controllers,
vec![
"aaaaa-aa".to_string(),
"zbf4m-zw3nk-6owqc-qmluz-xhwxt-2pkky-xhjy2-kqxor-qzxsn-6d2bz-nae".to_string(),
]
);
assert!(plan.authority_profile.staging_controllers.is_empty());
assert!(plan.authority_profile.emergency_controllers.is_empty());
let root_assumption = plan
.unresolved_assumptions
.iter()
.find(|assumption| assumption.key == "local_state.root_canister_id")
.expect("missing root identity should be recorded");
assert!(root_assumption.description.contains("--allow-unverified"));
}
#[test]
fn local_plan_uses_install_state_root_as_expected_canister() {
let temp = TempWorkspace::new("canic-host-local-plan-root-state");
let workspace_root = temp.path().join("workspace");
let icp_root = temp.path().join("icp");
let config_dir = workspace_root.join("fleets");
fs::create_dir_all(&config_dir).expect("create config dir");
fs::write(config_dir.join("canic.toml"), SAMPLE_CONFIG).expect("write config");
write_artifact(&icp_root, "root", b"root-artifact");
write_artifact(&icp_root, "wasm_store", b"wasm-store-artifact");
write_artifact(&icp_root, "user_hub", b"user-hub-artifact");
write_release_set_manifest(&icp_root);
let state_path = icp_root.join(".canic/local/deployments/demo-local.json");
fs::create_dir_all(state_path.parent().expect("state parent")).expect("create state dir");
fs::write(
state_path,
serde_json::to_vec_pretty(&sample_install_state("demo-local", "aaaaa-aa"))
.expect("encode state"),
)
.expect("write install state");
let plan = build_local_deployment_plan(&LocalDeploymentPlanRequest {
deployment_name: "demo-local".to_string(),
network: "local".to_string(),
workspace_root,
icp_root,
config_path: None,
runtime_variant: "local".to_string(),
build_profile: "fast".to_string(),
});
assert_eq!(
plan.deployment_identity.root_principal.as_deref(),
Some("aaaaa-aa")
);
assert_eq!(
plan.trust_domain.root_trust_anchor.as_deref(),
Some("aaaaa-aa")
);
assert!(
plan.expected_canisters
.iter()
.any(|canister| canister.role == "root"
&& canister.canister_id.as_deref() == Some("aaaaa-aa"))
);
assert!(plan.unresolved_assumptions.is_empty());
}
#[test]
fn local_plan_uses_configured_pools_as_expected_pool_identities() {
let temp = TempWorkspace::new("canic-host-local-plan-pools");
let workspace_root = temp.path().join("workspace");
let icp_root = temp.path().join("icp");
let config_dir = workspace_root.join("fleets");
fs::create_dir_all(&config_dir).expect("create config dir");
fs::write(
config_dir.join("canic.toml"),
r#"
controllers = []
app_index = []
[fleet]
name = "demo"
[roles.root]
kind = "root"
package = "root"
[roles.user_hub]
kind = "canister"
package = "user_hub"
[roles.user_shard]
kind = "canister"
package = "user_shard"
[app]
init_mode = "enabled"
[app.whitelist]
[subnets.prime.canisters.root]
kind = "root"
[subnets.prime.canisters.user_hub]
kind = "service"
[subnets.prime.canisters.user_hub.sharding.pools.user_shards]
canister_role = "user_shard"
policy.capacity = 100
policy.max_shards = 4
[subnets.prime.canisters.user_shard]
kind = "shard"
"#,
)
.expect("write config");
write_artifact(&icp_root, "root", b"root-artifact");
write_artifact(&icp_root, "user_hub", b"user-hub-artifact");
write_artifact(&icp_root, "user_shard", b"user-shard-artifact");
let plan = build_local_deployment_plan(&LocalDeploymentPlanRequest {
deployment_name: "demo-local".to_string(),
network: "local".to_string(),
workspace_root,
icp_root,
config_path: None,
runtime_variant: "local".to_string(),
build_profile: "fast".to_string(),
});
assert_eq!(
plan.expected_pool,
vec![ExpectedPoolCanisterV1 {
pool: "user_shards".to_string(),
canister_id: None,
role: Some("user_shard".to_string()),
}]
);
let inventory = sample_matching_inventory();
let diff = compare_plan_to_inventory(&plan, &inventory);
assert!(
diff.warnings
.iter()
.any(|finding| finding.code == "pool_canister_unobserved"
&& finding.subject.as_deref() == Some("user_shards:user_shard"))
);
}