v0.3.9-pre.002

crates/ksp-worker-api/tests/dependency_boundary.rs

@@ -0,0 +1,82 @@
+// file: crates/ksp-worker-api/tests/dependency_boundary.rs
+// version: 1
+
+//! Dependency and runtime-neutrality canaries for the Worker API foundation.
+
+#[test]
+fn pre_002_manifest_has_exact_core_only_dependency_graph() {
+    let manifest = include_str!("../Cargo.toml");
+    assert!(!manifest.contains("[features]"));
+    assert!(!manifest.contains("[dev-dependencies]"));
+    assert!(!manifest.contains("[build-dependencies]"));
+    assert_eq!(manifest.matches("[dependencies]").count(), 1);
+    let dependencies_tail = manifest.split("[dependencies]").nth(1);
+    assert!(dependencies_tail.is_some());
+    let dependencies_tail = match dependencies_tail {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let dependencies = match dependencies_tail.split("[lints]").next() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    assert_eq!(manifest_dependency_names(dependencies), std::vec!["ksp-core-lib"]);
+    return;
+}
+
+#[test]
+fn pre_002_production_sources_forbid_job_runtime_domain_and_wire_dependencies() {
+    let sources = [
+        include_str!("../src/error.rs"),
+        include_str!("../src/identity.rs"),
+        include_str!("../src/lib.rs"),
+        include_str!("../src/lifecycle.rs"),
+        include_str!("../src/snapshot.rs"),
+        include_str!("../src/stop.rs"),
+    ];
+    for source in sources {
+        for forbidden in [
+            "ksp_config_lib::",
+            "ksp_interface_lib::",
+            "ksp_job_api::",
+            "ksp_logging_lib::",
+            "ksp_offchain_transport_lib::",
+            "ksp_onchain_transport_lib::",
+            "ksp_store_api::",
+            "ksp_store_lib::",
+            "reqwest::",
+            "serde::",
+            "serde_json::",
+            "solana_",
+            "tauri::",
+            "tokio::",
+            "tonic::",
+            concat!("tracing", "::"),
+        ] {
+            assert!(!source.contains(forbidden), "forbidden Worker API dependency path detected: {forbidden}");
+        }
+    }
+    return;
+}
+
+fn manifest_dependency_names(section: &str) -> std::vec::Vec<&str> {
+    let mut names = std::vec::Vec::new();
+    for line in section.lines() {
+        let content = match line.split('#').next() {
+            std::option::Option::Some(value) => value.trim(),
+            std::option::Option::None => continue,
+        };
+        if content.is_empty() {
+            continue;
+        }
+        let name = match content.split('=').next() {
+            std::option::Option::Some(value) => value.trim().trim_end_matches(".workspace"),
+            std::option::Option::None => continue,
+        };
+        if !name.is_empty() {
+            names.push(name);
+        }
+    }
+    names.sort_unstable();
+    return names;
+}

crates/ksp-worker-api/tests/public_api.rs

@@ -0,0 +1,52 @@
+// file: crates/ksp-worker-api/tests/public_api.rs
+// version: 1
+
+//! External-consumer canaries for the Worker API crate-root facade.
+
+#[test]
+fn pre_002_identity_lifecycle_stop_and_snapshot_are_consumable_from_crate_root() {
+    let id = ksp_worker_api::WorkerId::new("worker-public-001");
+    let kind = ksp_worker_api::WorkerKindCode::new("example_worker");
+    assert!(id.is_ok());
+    assert!(kind.is_ok());
+    let id = match id {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let kind = match kind {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let mut lifecycle = ksp_worker_api::WorkerLifecycle::new(id.clone(), kind.clone());
+    assert_eq!(lifecycle.state(), ksp_worker_api::WorkerState::Created);
+    assert!(lifecycle.start().is_ok());
+    assert!(lifecycle.mark_running().is_ok());
+    let stop = ksp_worker_api::WorkerStopToken::new();
+    assert!(stop.request_stop());
+    assert!(lifecycle.mark_stopping().is_ok());
+    let snapshot = ksp_worker_api::WorkerSnapshot::new(
+        id,
+        kind,
+        ksp_worker_api::WorkerSnapshotSequence::initial(),
+        lifecycle.state(),
+        ksp_worker_api::WorkerHealth::Healthy,
+        ksp_worker_api::WorkerActivity::Idle,
+    );
+    assert_eq!(snapshot.state(), ksp_worker_api::WorkerState::Stopping);
+    assert_eq!(snapshot.health(), ksp_worker_api::WorkerHealth::Healthy);
+    assert_eq!(snapshot.activity(), ksp_worker_api::WorkerActivity::Idle);
+    return;
+}
+
+#[test]
+fn pre_002_public_bounds_and_error_codes_are_exact() {
+    assert_eq!(ksp_worker_api::MAX_WORKER_ID_BYTES, 128);
+    assert_eq!(ksp_worker_api::MAX_WORKER_KIND_CODE_BYTES, 128);
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_ID_INVALID.domain(), "worker_api");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_ID_INVALID.code(), "worker_id_invalid");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_KIND_INVALID.domain(), "worker_api");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_KIND_INVALID.code(), "worker_kind_invalid");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_TRANSITION_INVALID.code(), "worker_transition_invalid");
+    assert_eq!(ksp_worker_api::ERROR_CODE_WORKER_SNAPSHOT_SEQUENCE_EXHAUSTED.code(), "worker_snapshot_sequence_exhausted");
+    return;
+}