// file: crates/ksp-job-backfill-lib/tests/release_completeness.rs
// version: 9

//! Completeness canaries through the `pre.010` hardening and external-canary tranche.

#[test]
fn pre_010_production_module_inventory_is_exact() -> std::io::Result<()> {
    let source_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
    let entries = match std::fs::read_dir(source_root) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let mut names = std::vec::Vec::new();
    for entry in entries {
        let entry = match entry {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(error) => return std::result::Result::Err(error),
        };
        let file_type = match entry.file_type() {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(error) => return std::result::Result::Err(error),
        };
        if !file_type.is_file() {
            continue;
        }
        let name = match entry.file_name().into_string() {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(_) => continue,
        };
        if name.ends_with(".rs") {
            names.push(name);
        }
    }
    names.sort_unstable();
    assert_eq!(
        names,
        std::vec![
            "checkpoint.rs",
            "constants.rs",
            "conversion.rs",
            "discovery.rs",
            "error.rs",
            "execution.rs",
            "lib.rs",
            "persistence.rs",
            "request.rs",
            "runtime.rs",
        ]
    );
    return std::result::Result::Ok(());
}

#[test]
fn pre_010_surface_closes_concrete_cancellation_and_latest_value_runtime() {
    let root = include_str!("../src/lib.rs");
    for required in [
        "BackfillCandidate",
        "BackfillCandidateIdentity",
        "BackfillCommitment",
        "BackfillDiscovery",
        "BackfillDiscoveryBoundary",
        "BackfillRequest",
        "BackfillScope",
        "BackfillScopeFingerprint",
        "BackfillSignature",
        "discover_backfill_candidates",
        "BackfillRawAcquisition",
        "BackfillHydrationOutcome",
        "hydrate_backfill_candidate",
        "BackfillPersistenceOutcome",
        "BackfillEntityPersistence",
        "BackfillObservationPersistence",
        "persist_backfill_hydration",
        "BackfillCheckpoint",
        "BackfillExecutionBatch",
        "execute_backfill_discovery",
        "ERROR_CODE_BACKFILL_CHECKPOINT_INVALID",
        "ERROR_CODE_BACKFILL_EXECUTION_INVALID",
        "BackfillJobHandle",
        "BackfillJobPhase",
        "BackfillJobRuntime",
        "BackfillJobSnapshot",
        "BackfillSnapshotSource",
        "BACKFILL_JOB_KIND_CODE",
        "ERROR_CODE_BACKFILL_RUNTIME_INVALID",
    ] {
        assert!(root.contains(required), "required pre.010 public contract missing: {required}");
    }
    for forbidden in ["tokio::", "FuturesUnordered", "watch::Receiver", "watch::Sender"] {
        assert!(!root.contains(forbidden), "runtime implementation detail leaked into public root: {forbidden}");
    }
    assert!(!root.contains("pub mod "));
    return;
}

#[test]
fn pre_010_external_hardening_suite_is_present_and_scoped() {
    let hardening = include_str!("hardening.rs");
    for required in [
        "pre_010_external_error_codes_are_stable_unique_and_domain_scoped",
        "pre_010_external_request_adversarial_bounds_return_stable_codes",
        "pre_010_scope_fingerprint_is_network_sensitive_and_transport_source_independent",
        "pre_010_debug_surfaces_redact_signature_fingerprint_and_runtime_snapshot_payloads",
        "pre_010_external_runtime_handle_starts_created_and_cancellation_is_idempotent",
        "pre_010_manifest_dependency_surface_is_exact_and_backend_neutral",
        "pre_010_source_visibility_contract_uses_crate_root_for_shared_items",
        "pre_010_lower_layers_have_no_dependency_return_to_job",
        "pre_010_public_root_exposes_no_runtime_or_backend_implementation_types",
    ] {
        assert!(hardening.contains(required), "required pre.010 hardening canary missing: {required}");
    }
    return;
}