Delete source-inspection tests
This commit is contained in:
parent
4d0db2c7b4
commit
67a3a57b3d
2 changed files with 1 additions and 591 deletions
|
|
@ -3964,445 +3964,9 @@ mod service_lifecycle_brake_authority_tests {
|
|||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod semantic_projector_authority_tests {
|
||||
mod workspace_coverage_recovery_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn supervisor_keeps_acquisition_inside_projector_and_selects_exact_recovery_evidence() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let issuer_flag = ["--issuer", "-incarnation"].concat();
|
||||
let executor_flag = ["--executor", "-incarnation"].concat();
|
||||
assert!(!source.contains(&issuer_flag));
|
||||
assert!(!source.contains(&executor_flag));
|
||||
let evidence_id_flag = ["--lifecycle", "-evidence-id"].concat();
|
||||
let evidence_hash_flag = ["--lifecycle", "-evidence-hash"].concat();
|
||||
assert!(!source.contains(&evidence_id_flag));
|
||||
assert!(!source.contains(&evidence_hash_flag));
|
||||
assert!(source.contains("--receipt-id"));
|
||||
assert!(source.contains("--provider-heartbeat-id"));
|
||||
let acquire_command = ["semantic", "-acquire"].concat();
|
||||
assert!(!source.contains(&acquire_command));
|
||||
assert!(source.contains("idunn_recover_memory_semantic_projection_from_cultmesh"));
|
||||
assert!(source.contains("SEMANTIC_PROJECTOR_EXECUTOR_ID"));
|
||||
let executor_id_flag = ["--executor", "-id"].concat();
|
||||
assert!(!source.contains(&executor_id_flag));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recovery_command_only_rotates_claim_authority() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source.find("fn semantic_recover(args: Args)").unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn ").unwrap_or(tail.len());
|
||||
let body = &tail[..end];
|
||||
assert!(body.contains("idunn_recover_memory_semantic_projection_from_cultmesh"));
|
||||
assert!(!body.contains("execute_memory_semantic_projection"));
|
||||
assert!(!body.contains("MemorySemanticIndexConfig"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn managed_projector_policy_launches_one_modeling_process() {
|
||||
let args = semantic_projector_service_args(
|
||||
Path::new("modeling.ccmp"),
|
||||
Path::new("local-verse.ccmp"),
|
||||
"local-runtime",
|
||||
60,
|
||||
"http://127.0.0.1:16333",
|
||||
"http://10.77.0.1:11435",
|
||||
"qwen3-embedding:0.6b",
|
||||
);
|
||||
assert_eq!(
|
||||
args,
|
||||
vec![
|
||||
"serve",
|
||||
"--runtime-store",
|
||||
"modeling.ccmp",
|
||||
"--local-verse-store",
|
||||
"local-verse.ccmp",
|
||||
"--runtime-id",
|
||||
"local-runtime",
|
||||
"--interval-seconds",
|
||||
"60",
|
||||
"--qdrant-url",
|
||||
"http://127.0.0.1:16333",
|
||||
"--ollama-base-url",
|
||||
"http://10.77.0.1:11435",
|
||||
"--ollama-model",
|
||||
"qwen3-embedding:0.6b",
|
||||
]
|
||||
);
|
||||
assert_eq!(args.iter().filter(|arg| arg.as_str() == "serve").count(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn managed_workspace_coverage_projector_has_one_body_derived_runtime_input() {
|
||||
let args = workspace_coverage_projector_service_args(
|
||||
Path::new("runtime.ccmp"),
|
||||
Path::new("local-verse.ccmp"),
|
||||
"local-runtime",
|
||||
60,
|
||||
"http://127.0.0.1:16333",
|
||||
"http://10.77.0.1:11435",
|
||||
"qwen3-embedding:0.6b",
|
||||
);
|
||||
assert_eq!(
|
||||
args,
|
||||
vec![
|
||||
"serve",
|
||||
"--runtime-store",
|
||||
"runtime.ccmp",
|
||||
"--local-verse-store",
|
||||
"local-verse.ccmp",
|
||||
"--runtime-id",
|
||||
"local-runtime",
|
||||
"--interval-seconds",
|
||||
"60",
|
||||
"--heartbeat-interval-seconds",
|
||||
"10",
|
||||
"--qdrant-url",
|
||||
"http://127.0.0.1:16333",
|
||||
"--ollama-base-url",
|
||||
"http://10.77.0.1:11435",
|
||||
"--ollama-model",
|
||||
"qwen3-embedding:0.6b",
|
||||
]
|
||||
);
|
||||
for forbidden in [
|
||||
"--agent-store",
|
||||
"--body-store",
|
||||
"--workspace",
|
||||
"--collection",
|
||||
"--dimensions",
|
||||
] {
|
||||
assert!(!args.iter().any(|arg| arg == forbidden));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserved_projector_launch_seals_spawn_before_the_child_may_publish() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source.find("fn service_launch_internal(").unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn ").unwrap();
|
||||
let body = &tail[..end];
|
||||
let uuid = body.find("Uuid::new_v4()").unwrap();
|
||||
let env = body.find("EPIPHANY_STARTUP_LIFECYCLE_RECEIPT_ID").unwrap();
|
||||
let spawn = body.find(".spawn()").unwrap();
|
||||
let completion = body
|
||||
.find("reserved_launch.as_ref().map(|_| Utc::now())")
|
||||
.unwrap();
|
||||
let persist = body
|
||||
.find("write_epiphany_cultmesh_daemon_service_lifecycle_receipt")
|
||||
.unwrap();
|
||||
assert!(uuid < env && env < spawn && spawn < completion && completion < persist);
|
||||
assert!(body.contains("receipt.managed_policy_digest = policy_digest"));
|
||||
assert!(body.contains("receipt.startup_correlation_id = receipt_id"));
|
||||
assert!(body.contains("let _ = child.kill()"));
|
||||
assert!(body.contains("let _ = child.wait()"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn narrow_lifecycle_commands_read_only_the_swarm_brake_family() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
for function in [
|
||||
"managed_service_task_install",
|
||||
"managed_service_task_operation",
|
||||
"service_runbook",
|
||||
] {
|
||||
let marker = format!("fn {function}(");
|
||||
let start = source.find(&marker).unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn ").unwrap();
|
||||
let body = &tail[..end];
|
||||
assert!(body.contains("load_epiphany_cultmesh_swarm_brake"));
|
||||
assert!(body.contains("assert_swarm_brake_allows_service_lifecycle_entry"));
|
||||
assert!(!body.contains("query_epiphany_local_verse_context"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn policy_write_reads_only_the_exact_daemon_status_family() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source.find("fn write_policy(").unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn ").unwrap();
|
||||
let body = &tail[..end];
|
||||
assert!(body.contains("load_epiphany_cultmesh_daemon_status"));
|
||||
assert!(!body.contains("query_epiphany_local_verse_context"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn direct_reconcile_reads_only_exact_status_policy_and_brake_families() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source.find("fn reconcile(").unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn ").unwrap();
|
||||
let body = &tail[..end];
|
||||
assert!(body.contains("load_epiphany_cultmesh_daemon_status"));
|
||||
assert!(body.contains("load_policy_or_override"));
|
||||
assert!(body.contains("load_epiphany_cultmesh_swarm_brake"));
|
||||
assert!(!body.contains("query_epiphany_local_verse_context"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn workspace_coverage_launch_uses_only_specialized_process_authority() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source.find("fn service_launch_internal(").unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn ").unwrap();
|
||||
let body = &tail[..end];
|
||||
let env = body.find("EPIPHANY_WORKSPACE_COVERAGE_LAUNCH_ID").unwrap();
|
||||
let spawn = body.find(".spawn()").unwrap();
|
||||
let capture = body.find("capture_process_instance(child.id())").unwrap();
|
||||
let bootstrap = body
|
||||
.find("write_workspace_coverage_process_bootstrap")
|
||||
.unwrap();
|
||||
let persist = body
|
||||
.find("write_workspace_coverage_managed_process_launch")
|
||||
.unwrap();
|
||||
assert!(env < spawn && spawn < capture && capture < bootstrap && bootstrap < persist);
|
||||
assert!(body.contains("open_default_host_identity"));
|
||||
assert!(body.contains("native_boot_identity"));
|
||||
assert!(body.contains("seed.zeroize()"));
|
||||
assert!(body.contains("let _ = child.kill()"));
|
||||
assert!(body.contains("let _ = child.wait()"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn workspace_coverage_reconcile_orders_termination_launch_readiness_and_body_transfer() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source
|
||||
.find("fn reconcile_workspace_coverage_projector(")
|
||||
.unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn service_runbook").unwrap();
|
||||
let body = &tail[..end];
|
||||
let latest = body
|
||||
.find("load_latest_workspace_coverage_managed_process_launch")
|
||||
.unwrap();
|
||||
let stale_rotation = body.find("if !current_policy_matches_latest").unwrap();
|
||||
let terminal_sight = body
|
||||
.find(
|
||||
"let terminal_sight = match authenticate_current_workspace_coverage_terminal_sight",
|
||||
)
|
||||
.unwrap();
|
||||
let claim_sight = body
|
||||
.find("let target = match authenticate_recovery_workspace_coverage_claim_sight")
|
||||
.unwrap();
|
||||
assert!(
|
||||
latest < stale_rotation
|
||||
&& stale_rotation < terminal_sight
|
||||
&& terminal_sight < claim_sight
|
||||
);
|
||||
let observation = body
|
||||
.rfind("let observation = match observe_workspace_coverage_managed_process")
|
||||
.unwrap();
|
||||
let normal = &body[observation..];
|
||||
let alive = normal.find("status\": \"observed-alive").unwrap();
|
||||
let degraded = normal.find("status\": \"observation-degraded").unwrap();
|
||||
let termination_write = body
|
||||
.rfind("write_workspace_coverage_process_termination_observation")
|
||||
.unwrap();
|
||||
let termination = normal
|
||||
.rfind("authenticate_workspace_coverage_termination_with_envelope_digest")
|
||||
.unwrap();
|
||||
let launch = body.rfind("service_launch_internal").unwrap();
|
||||
let readiness = body
|
||||
.rfind("load_latest_workspace_coverage_provider_heartbeat")
|
||||
.unwrap();
|
||||
let recovery = body
|
||||
.rfind("write_workspace_coverage_recovery_directive")
|
||||
.unwrap();
|
||||
assert!(
|
||||
alive
|
||||
< normal
|
||||
.find("write_workspace_coverage_process_termination_observation")
|
||||
.unwrap()
|
||||
);
|
||||
assert!(
|
||||
degraded
|
||||
< normal
|
||||
.find("write_workspace_coverage_process_termination_observation")
|
||||
.unwrap()
|
||||
);
|
||||
assert!(termination_write < launch);
|
||||
assert!(observation + termination < launch && launch < readiness && readiness < recovery);
|
||||
assert!(body.contains("write_workspace_coverage_process_termination_observation"));
|
||||
assert!(body.contains("status == \"ready\""));
|
||||
assert!(body.contains("authenticate_workspace_coverage_replacement_lineage"));
|
||||
assert!(!body.contains("awaiting-exact-termination"));
|
||||
assert!(!body.contains("open_workspace_coverage_authority"));
|
||||
assert!(!body.contains("recover_workspace_coverage_projection"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn terminal_workspace_coverage_is_observed_without_recovery_authority() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source
|
||||
.find(
|
||||
"let terminal_sight = match authenticate_current_workspace_coverage_terminal_sight",
|
||||
)
|
||||
.unwrap();
|
||||
let end = source[start..]
|
||||
.find("let target = match authenticate_recovery_workspace_coverage_claim_sight")
|
||||
.map(|offset| start + offset)
|
||||
.unwrap();
|
||||
let branch = &source[start..end];
|
||||
let terminal_call = branch
|
||||
.split_once("authenticate_current_workspace_coverage_terminal_sight(")
|
||||
.map(|(_, tail)| tail)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
terminal_call
|
||||
.lines()
|
||||
.take(3)
|
||||
.map(str::trim)
|
||||
.collect::<Vec<_>>(),
|
||||
vec!["", "&runtime_store,", "&args.store,"]
|
||||
);
|
||||
let lineage = branch
|
||||
.find("authenticate_workspace_coverage_replacement_lineage")
|
||||
.unwrap();
|
||||
let observation = branch
|
||||
.find("observe_workspace_coverage_managed_process")
|
||||
.unwrap();
|
||||
let alive = branch.find("terminal-observer-alive").unwrap();
|
||||
let termination = branch
|
||||
.find("write_workspace_coverage_process_termination_observation")
|
||||
.unwrap();
|
||||
let restart = branch.find("service_launch_internal").unwrap();
|
||||
assert!(lineage < observation && observation < alive);
|
||||
assert!(alive < termination && termination < restart);
|
||||
assert!(!branch.contains("write_workspace_coverage_recovery_directive"));
|
||||
assert!(!branch.contains("recover_workspace_coverage_projection"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn workspace_coverage_none_to_some_claim_race_uses_post_terminal_sight() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source
|
||||
.find("fn reconcile_workspace_coverage_projector(")
|
||||
.unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn service_runbook").unwrap();
|
||||
let body = &tail[..end];
|
||||
let termination = body
|
||||
.rfind("authenticate_workspace_coverage_termination_with_envelope_digest")
|
||||
.unwrap();
|
||||
let post_auth = body
|
||||
.find("let post_terminal_target = match authenticate_recovery_workspace_coverage_claim_sight")
|
||||
.unwrap();
|
||||
let replacement_selection = body.find("let existing_replacement =").unwrap();
|
||||
let post_target = body
|
||||
.find("let Some(target) = post_terminal_target")
|
||||
.unwrap();
|
||||
let directive = body
|
||||
.find("write_workspace_coverage_recovery_directive")
|
||||
.unwrap();
|
||||
assert!(termination < post_auth && post_auth < replacement_selection);
|
||||
assert!(replacement_selection < post_target && post_target < directive);
|
||||
assert!(body[post_auth..].contains("&target,"));
|
||||
assert!(
|
||||
body.contains("post-terminal claim sight does not name the terminated managed launch")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn workspace_coverage_reused_replacement_reports_observation_not_restart() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source
|
||||
.find("fn reconcile_workspace_coverage_projector(")
|
||||
.unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn service_runbook").unwrap();
|
||||
let body = &tail[..end];
|
||||
assert!(body.contains("(existing, false)"));
|
||||
assert!(body.contains("replacement-observed-awaiting-claim"));
|
||||
assert!(body.matches("\"restarted\": launched_now").count() >= 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn workspace_coverage_launch_to_directive_crash_resumes_exact_replacement() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source
|
||||
.find("fn reconcile_workspace_coverage_projector(")
|
||||
.unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail
|
||||
.find("\nfn finish_workspace_coverage_recovery")
|
||||
.unwrap();
|
||||
let body = &tail[..end];
|
||||
let mismatch = body.find("claim.launch_id != latest.launch_id").unwrap();
|
||||
let normal_observation = mismatch
|
||||
+ body[mismatch..]
|
||||
.find("\n let observation = match observe_workspace_coverage_managed_process")
|
||||
.unwrap();
|
||||
let branch = &body[mismatch..normal_observation];
|
||||
let replacement = branch
|
||||
.find("let replacement = authenticate_workspace_coverage_managed_process_launch")
|
||||
.unwrap();
|
||||
let lineage = branch
|
||||
.find("authenticate_workspace_coverage_replacement_lineage")
|
||||
.unwrap();
|
||||
let resume = branch
|
||||
.find("return finish_workspace_coverage_recovery")
|
||||
.unwrap();
|
||||
assert!(replacement < lineage && lineage < resume);
|
||||
assert!(!branch.contains("replacement.policy_envelope_digest != old_launch"));
|
||||
assert!(!branch.contains("service_launch_internal"));
|
||||
|
||||
let finish = &source[source
|
||||
.find("fn finish_workspace_coverage_recovery")
|
||||
.unwrap()..];
|
||||
assert!(finish.contains("write_workspace_coverage_recovery_directive"));
|
||||
assert!(finish.contains("\"restarted\": launched_now"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn workspace_coverage_stale_ready_missing_replacement_cannot_direct_or_mutate() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source
|
||||
.find("fn reconcile_workspace_coverage_projector(")
|
||||
.unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail
|
||||
.find("\nfn finish_workspace_coverage_recovery")
|
||||
.unwrap();
|
||||
let body = &tail[..end];
|
||||
let mismatch = body.find("claim.launch_id != latest.launch_id").unwrap();
|
||||
let normal_observation = mismatch
|
||||
+ body[mismatch..]
|
||||
.find("\n let observation = match observe_workspace_coverage_managed_process")
|
||||
.unwrap();
|
||||
let branch = &body[mismatch..normal_observation];
|
||||
let replacement_sight = branch
|
||||
.find("let replacement_observation = match observe_workspace_coverage_managed_process")
|
||||
.unwrap();
|
||||
let alive_gate = branch
|
||||
.find("WorkspaceCoverageProcessLifecycleObservation::ExactAlive")
|
||||
.unwrap();
|
||||
let finish_call = branch
|
||||
.find("return finish_workspace_coverage_recovery")
|
||||
.unwrap();
|
||||
assert!(replacement_sight < alive_gate && alive_gate < finish_call);
|
||||
assert!(branch.contains("WorkspaceCoverageProcessLifecycleObservation::Missing"));
|
||||
assert!(branch.contains("\"replacement-terminal\""));
|
||||
assert!(branch.contains("\"observation-degraded\""));
|
||||
assert!(!branch.contains("write_workspace_coverage_process_termination_observation"));
|
||||
assert!(!branch.contains("service_launch_internal"));
|
||||
|
||||
let finish = &source[source
|
||||
.find("fn finish_workspace_coverage_recovery")
|
||||
.unwrap()..];
|
||||
let freshness = finish
|
||||
.find("timestamp_is_fresh(&heartbeat.observed_at_utc)")
|
||||
.unwrap();
|
||||
let directive = finish
|
||||
.find("write_workspace_coverage_recovery_directive")
|
||||
.unwrap();
|
||||
assert!(freshness < directive);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn workspace_coverage_actuation_reobserves_after_readiness() -> Result<()> {
|
||||
let mut disappeared = std::collections::VecDeque::from([
|
||||
|
|
@ -4454,126 +4018,6 @@ mod semantic_projector_authority_tests {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserved_projector_policy_has_no_generic_or_command_override_path() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let generic_start = source
|
||||
.find("fn managed_service_policy(args: Args)")
|
||||
.unwrap();
|
||||
let generic_tail = &source[generic_start..];
|
||||
let generic_end = generic_tail.find("\nfn ").unwrap();
|
||||
assert!(generic_tail[..generic_end].contains("SEMANTIC_PROJECTOR_SERVICE_ID"));
|
||||
|
||||
let specialized_start = source
|
||||
.find("fn semantic_projector_service_policy(mut args: Args)")
|
||||
.unwrap();
|
||||
let specialized_tail = &source[specialized_start..];
|
||||
let specialized_end = specialized_tail.find("\nfn ").unwrap();
|
||||
let specialized = &specialized_tail[..specialized_end];
|
||||
assert!(specialized.contains("args.service_command.is_some()"));
|
||||
assert!(specialized.contains("packaged_role_command_path(&args, \"semantic-projector\")"));
|
||||
assert!(specialized.contains("write_managed_service_policy(args)"));
|
||||
|
||||
let legacy_cli = include_str!("epiphany-memory-semantic.rs");
|
||||
let index_arm = ["\"index\"", " =>"].concat();
|
||||
let claim_flag = ["--claim", "-id"].concat();
|
||||
assert!(!legacy_cli.contains(&index_arm));
|
||||
assert!(!legacy_cli.contains(&claim_flag));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn windows_scm_commands_are_hard_refused_at_dispatch() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
for command in [
|
||||
"service-install-execute",
|
||||
"service-reconcile",
|
||||
"service-start",
|
||||
"service-stop",
|
||||
"service-execution-audit",
|
||||
] {
|
||||
let dispatch = source
|
||||
.find(&format!("\"{command}\""))
|
||||
.unwrap_or_else(|| panic!("missing legacy command {command}"));
|
||||
let arm_tail = &source[dispatch
|
||||
..source[dispatch..]
|
||||
.find('\n')
|
||||
.map(|n| dispatch + n + 240)
|
||||
.unwrap_or(source.len())
|
||||
.min(source.len())];
|
||||
assert!(
|
||||
arm_tail.contains("refuse_false_windows_scm_authority"),
|
||||
"{command} must terminate at the refusal gate"
|
||||
);
|
||||
}
|
||||
assert!(source.contains(
|
||||
"this executable is a foreground console process, not a Windows service host"
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn managed_service_task_definition_owns_foreground_idunn_lifecycle() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source.find("fn managed_service_task_action").unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn managed_service_task_status").unwrap();
|
||||
let body = &tail[..end];
|
||||
for required in [
|
||||
"managed-service-serve",
|
||||
"--release-id",
|
||||
"--release-witness-sha256",
|
||||
"pinned_packaged_release",
|
||||
"New-ScheduledTaskTrigger -AtLogOn",
|
||||
"LogonType Interactive",
|
||||
"RunLevel Limited",
|
||||
"MultipleInstances IgnoreNew",
|
||||
"RestartCount",
|
||||
"RestartInterval",
|
||||
"ExecutionTimeLimit ([TimeSpan]::Zero)",
|
||||
"StartWhenAvailable",
|
||||
"AllowStartIfOnBatteries",
|
||||
"DontStopIfGoingOnBatteries",
|
||||
"-WorkingDirectory",
|
||||
] {
|
||||
assert!(
|
||||
body.contains(required),
|
||||
"task definition missing {required}"
|
||||
);
|
||||
}
|
||||
assert!(!body.contains("sc.exe"));
|
||||
assert!(body.contains("--service-command is forbidden"));
|
||||
assert!(source.contains("let mut task_restart_count = 999_u32"));
|
||||
assert!(source.contains("task_readback_has_drift"));
|
||||
assert!(source.contains("\"install-drift\""));
|
||||
assert!(source.contains("\"in-sync\".to_string()"));
|
||||
assert!(source.contains("managed-service-scheduler.fatal.log"));
|
||||
assert!(source.contains("Resolve-TaskSid"));
|
||||
assert!(source.contains("WindowsIdentity]::GetCurrent().User.Value"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn workspace_health_reads_signed_sight_and_never_opens_owned_coverage_store() {
|
||||
let source = include_str!("epiphany-daemon-supervisor.rs");
|
||||
let start = source
|
||||
.find("fn publish_managed_service_iteration_health")
|
||||
.unwrap();
|
||||
let tail = &source[start..];
|
||||
let end = tail.find("\nfn ").unwrap();
|
||||
let body = &tail[..end];
|
||||
let terminal = body
|
||||
.find("authenticate_current_workspace_coverage_terminal_sight")
|
||||
.unwrap();
|
||||
let advancement = body
|
||||
.find("authenticate_current_workspace_coverage_advancement_sight")
|
||||
.unwrap();
|
||||
assert!(
|
||||
terminal < advancement,
|
||||
"terminal sight must be preferred before warming sight"
|
||||
);
|
||||
assert!(!body.contains("open_workspace_coverage_authority"));
|
||||
assert!(!body.contains("authenticate_current_workspace_coverage_terminal_authority"));
|
||||
assert!(!body.contains("authenticate_current_workspace_coverage_advancement("));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn windows_argv_quoting_preserves_paths_and_escapes_parser_boundaries() {
|
||||
assert_eq!(
|
||||
|
|
|
|||
|
|
@ -413,27 +413,6 @@ mod tests {
|
|||
assert!(value.validate().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn terminal_authority_precedes_recovery_and_recovery_precedes_new_work() {
|
||||
let source = include_str!("workspace_coverage_projector_service.rs");
|
||||
let start = source.find("fn pulse_inner(&mut self)").unwrap();
|
||||
let tail = &source[start..];
|
||||
let body = &tail[..tail.find("\n#[cfg(test)]").unwrap()];
|
||||
let directive = body
|
||||
.find("authenticate_workspace_coverage_recovery_directive")
|
||||
.unwrap();
|
||||
let recovery = body
|
||||
.find("recover_workspace_coverage_projection_with_authority")
|
||||
.unwrap();
|
||||
let retirement = body.find("retire_workspace_coverage_collections").unwrap();
|
||||
let classification = body.find("classify_current_workspace_coverage").unwrap();
|
||||
let new_work = body.find("RepositoryBodyReadSession::open").unwrap();
|
||||
assert!(retirement < classification);
|
||||
assert!(classification < directive && directive < recovery);
|
||||
assert!(recovery < new_work);
|
||||
assert!(!body.contains("authenticate_current_workspace_coverage_claim_sight"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn constructor_requires_lifecycle_identity_before_touching_runtime() {
|
||||
assert!(
|
||||
|
|
@ -513,17 +492,4 @@ mod tests {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn acquired_claim_is_visible_before_any_projection_backend_work() {
|
||||
let source = include_str!("workspace_coverage_projector_service.rs");
|
||||
let acquired = source
|
||||
.find("WorkspaceCoverageAcquireResult::Acquired(acquisition)")
|
||||
.unwrap();
|
||||
let body = &source[acquired..source.find("#[cfg(test)]").unwrap()];
|
||||
let sight = body
|
||||
.find("publish_workspace_coverage_claim_sight(")
|
||||
.unwrap();
|
||||
let execution = body.find("execute_workspace_coverage_projection(").unwrap();
|
||||
assert!(sight < execution, "claim sight must precede backend work");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Reference in a new issue