v0.3.11-pre.003

crates/ksp-worker-raw-transaction-ingest-lib/tests/dependency_boundary.rs

@@ -1,7 +1,7 @@
 // file: crates/ksp-worker-raw-transaction-ingest-lib/tests/dependency_boundary.rs
-// version: 1
+// version: 2
 
-//! Dependency firewall canaries for the RAW transaction ingest Worker skeleton.
+//! Dependency firewall canaries for the RAW transaction ingest Worker foundation.
 
 #[test]
 fn pre_002_manifest_dependency_surface_is_exact() {
@@ -46,28 +46,26 @@ fn pre_002_manifest_keeps_forbidden_layers_and_live_sources_out() {
     ] {
         assert!(!dependencies.contains(forbidden), "forbidden Worker dependency present: {forbidden}");
     }
-    assert!(!manifest.contains("[dev-dependencies]"), "pre.002 requires no test-only dependency");
-    assert!(!manifest.contains("[build-dependencies]"), "pre.002 requires no build dependency");
+    assert!(!manifest.contains("[dev-dependencies]"), "foundation requires no test-only dependency");
+    assert!(!manifest.contains("[build-dependencies]"), "foundation requires no build dependency");
     return;
 }
 
 #[test]
-fn pre_002_crate_root_contains_no_runtime_behavior_or_public_contract_yet() {
+fn pre_003_source_surface_opens_identity_and_settings_without_runtime_behavior() {
     let root = include_str!("../src/lib.rs");
-    for forbidden in [
-        "pub mod ",
-        "pub struct ",
-        "pub enum ",
-        "pub trait ",
-        "pub fn ",
-        "tokio::",
-        "ksp_store_lib::",
-        "ksp_raw_transaction_lib::",
-        "ksp_worker_api::",
-        "start(",
-        "spawn(",
+    for required in [
+        "mod error;",
+        "mod identity;",
+        "mod settings;",
+        "pub use self::error::ERROR_CODE_RAW_TRANSACTION_INGEST_SETTINGS_INVALID;",
+        "pub use self::identity::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE;",
+        "pub use self::settings::RawTransactionIngestSettings;",
     ] {
-        assert!(!root.contains(forbidden), "pre.002 crate root opened behavior too early: {forbidden}");
+        assert!(root.contains(required), "required pre.003 crate-root contract missing: {required}");
+    }
+    for forbidden in ["pub mod ", "tokio::", "start(", "spawn(", "JoinHandle", "JoinSet", "mpsc::", "watch::", "ksp_onchain_transport_lib::"] {
+        assert!(!root.contains(forbidden), "pre.003 opened runtime behavior too early: {forbidden}");
     }
     return;
 }

crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs

@@ -0,0 +1,74 @@
+// file: crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs
+// version: 4
+
+//! External public-surface proofs for the RAW transaction ingest Worker identity and settings foundation.
+
+#[test]
+fn pre_003_kind_code_and_settings_are_consumable_from_crate_root() {
+    assert_eq!(ksp_worker_raw_transaction_ingest_lib::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE, "raw_transaction_ingest");
+    let kind_result = ksp_worker_api::WorkerKindCode::new(ksp_worker_raw_transaction_ingest_lib::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE);
+    assert!(kind_result.is_ok());
+    let kind = match kind_result {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(kind.as_str(), "raw_transaction_ingest");
+    let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let worker_id = match ksp_worker_api::WorkerId::new("raw-ingest-mainnet-001") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let settings = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings::with_defaults(network, worker_id);
+    assert_eq!(settings.network().as_str(), "mainnet");
+    assert_eq!(settings.worker_id().as_str(), "raw-ingest-mainnet-001");
+    assert_eq!(settings.admission_queue_capacity(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY);
+    assert_eq!(settings.persistence_concurrency(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY);
+    assert_eq!(settings.shutdown_drain_timeout(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT);
+    return;
+}
+
+#[test]
+fn pre_003_invalid_network_and_worker_identity_remain_owned_by_lower_contracts() {
+    let network = ksp_store_lib::RawNetworkId::new("");
+    let worker_id = ksp_worker_api::WorkerId::new("invalid worker id");
+    assert!(network.is_err());
+    assert!(worker_id.is_err());
+    let network_error = match network {
+        std::result::Result::Ok(_) => return,
+        std::result::Result::Err(value) => value,
+    };
+    assert_eq!(network_error.code(), ksp_store_lib::ERROR_CODE_RAW_MODEL_INVALID);
+    let worker_error = match worker_id {
+        std::result::Result::Ok(_) => return,
+        std::result::Result::Err(value) => value,
+    };
+    assert_eq!(worker_error.code(), ksp_worker_api::ERROR_CODE_WORKER_ID_INVALID);
+    return;
+}
+
+#[test]
+fn pre_003_runtime_bound_errors_are_stable_and_do_not_echo_values() {
+    let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let worker_id = match ksp_worker_api::WorkerId::new("raw-ingest-mainnet-001") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let result = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings::new(network, worker_id, 0, 8, std::time::Duration::from_secs(5));
+    assert!(result.is_err());
+    let error = match result {
+        std::result::Result::Ok(_) => return,
+        std::result::Result::Err(value) => value,
+    };
+    assert_eq!(error.code(), ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_SETTINGS_INVALID);
+    assert_eq!(error.message(), "invalid RAW transaction ingest Worker settings");
+    assert_eq!(error.context().len(), 1);
+    assert_eq!(error.context()[0].value(), "admission_queue_capacity");
+    assert!(!std::format!("{error:?}").contains("raw-ingest-mainnet-001"));
+    return;
+}