v0.3.7-pre.005

crates/ksp-app-backfill-desk/tests/config_composition.rs

@@ -1,7 +1,7 @@
 // file: crates/ksp-app-backfill-desk/tests/config_composition.rs
-// version: 2
+// version: 3
 
-//! Config composite and Transport-readiness contracts for Backfill Desk through pre.004.
+//! Config composite, Transport readiness and Store-network composition contracts for Backfill Desk through pre.005.
 
 #![forbid(unsafe_code)]
 #![deny(unreachable_pub)]
@@ -156,3 +156,65 @@ fn pre_004_default_composite_builds_http_pool_for_both_backfill_rpc_methods() {
         }
     }
 }
+
+#[test]
+fn pre_005_all_composite_profiles_keep_resolved_transport_and_store_networks_identical() {
+    let engine = workspace_engine();
+    assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}");
+    let engine = match engine {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let environment = ksp_config_lib::ConfigEnvironment::load();
+    assert!(environment.is_ok(), "Config environment should load for committed Backfill Desk profiles");
+    let environment = match environment {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_BACKFILL_DESK);
+    let file_id = match file_id {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    for profile_id in ["devnet", "mainnet", "testnet"] {
+        let composite = engine.load_resolved_composite(&file_id, std::option::Option::Some(profile_id));
+        assert!(composite.is_ok(), "Backfill Desk composite profile {profile_id} should resolve: {composite:?}");
+        let composite = match composite {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => continue,
+        };
+        let transport = composite.component("transport");
+        let store = composite.component("store");
+        assert!(transport.is_some(), "profile {profile_id} should expose Transport");
+        assert!(store.is_some(), "profile {profile_id} should expose Store");
+        let (transport, store) = match (transport, store) {
+            (std::option::Option::Some(transport), std::option::Option::Some(store)) => (transport, store),
+            _ => continue,
+        };
+        let transport = engine.resolve_transport_config_profile(transport.resolved(), &environment);
+        let store = engine.resolve_store_config_profile(store.resolved(), &environment);
+        assert!(transport.is_ok(), "profile {profile_id} Transport should map: {transport:?}");
+        assert!(store.is_ok(), "profile {profile_id} Store should map: {store:?}");
+        let (transport, store) = match (transport, store) {
+            (std::result::Result::Ok(transport), std::result::Result::Ok(store)) => (transport, store),
+            _ => continue,
+        };
+        let mut networks = transport
+            .settings()
+            .endpoints()
+            .iter()
+            .filter_map(|endpoint| {
+                if endpoint.enabled() {
+                    return std::option::Option::Some(endpoint.cluster().as_str().to_owned());
+                }
+                return std::option::Option::None;
+            })
+            .collect::<std::vec::Vec<_>>();
+        networks.sort();
+        networks.dedup();
+        assert_eq!(networks.len(), 1, "profile {profile_id} must resolve exactly one enabled HTTP network");
+        if let std::option::Option::Some(transport_network) = networks.first() {
+            assert_eq!(transport_network.as_str(), store.settings().network().as_str(), "profile {profile_id} Store/Transport network mismatch");
+        }
+    }
+}

crates/ksp-app-backfill-desk/tests/desktop_contract.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-backfill-desk/tests/desktop_contract.rs
-// version: 4
+// version: 5
 
 //! Structural desktop contract checks for the Backfill Desk scaffold.
 
@@ -200,3 +200,31 @@ fn pre_004_transport_runtime_builds_pool_and_validates_both_required_rpc_methods
     let tauri = read_text(root.join("src/tauri.rs").as_path());
     assert!(tauri.contains("backfill_options"));
 }
+
+#[test]
+fn pre_005_store_readiness_proves_network_before_open_and_closes_on_main_window_exit() {
+    let root = app_root();
+    let store = read_text(root.join("src/store_runtime.rs").as_path());
+    let coherence = store.find("validate_network_coherence(store_network.as_str(), transport_network.as_str())");
+    let open = store.find("ksp_store_lib::Store::open");
+    assert!(coherence.is_some());
+    assert!(open.is_some());
+    if let (std::option::Option::Some(coherence), std::option::Option::Some(open)) = (coherence, open) {
+        assert!(coherence < open, "Store network coherence must be proven before physical Store open");
+    }
+    assert!(store.contains("store.health().await"));
+    assert!(store.contains("store.close().await"));
+    assert!(store.contains("StoreHealthState::Ready"));
+    assert!(store.contains("StoreHealthState::NotReady"));
+    assert!(!store.contains("BackfillJobRuntime"));
+    assert!(!store.contains("BackfillRequest"));
+    let app_state = read_text(root.join("src/app_state.rs").as_path());
+    assert!(app_state.contains("initialize_store"));
+    assert!(app_state.contains("pre.005-store-readiness"));
+    assert!(app_state.contains("composition_ready"));
+    assert!(app_state.contains("close_store"));
+    let tauri = read_text(root.join("src/tauri.rs").as_path());
+    for required in ["on_window_event", "WindowEvent::CloseRequested", "prevent_close", "async_runtime::spawn", "close_store", "app_handle.exit(0)"] {
+        assert!(tauri.contains(required), "missing bounded Store shutdown lifecycle marker {required}");
+    }
+}

crates/ksp-app-backfill-desk/tests/desktop_security.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-backfill-desk/tests/desktop_security.rs
-// version: 4
+// version: 5
 
 //! Security and dependency-boundary checks for the Backfill Desk scaffold.
 
@@ -43,7 +43,7 @@ fn read_text(path: &std::path::Path) -> String {
 }
 
 #[test]
-fn capability_surface_remains_core_plus_tracing_while_transport_is_backend_only() {
+fn capability_surface_remains_core_plus_tracing_while_transport_and_store_are_backend_only() {
     let root = app_root();
     let capability = read_text(root.join("capabilities/default.json").as_path());
     assert!(capability.contains("\"core:default\""));
@@ -54,7 +54,8 @@ fn capability_surface_remains_core_plus_tracing_while_transport_is_backend_only(
     let manifest = read_text(root.join("Cargo.toml").as_path());
     assert!(manifest.contains("tauri-plugin-tracing.workspace = true"));
     assert!(manifest.contains("ksp-onchain-transport-lib = { path = \"../ksp-onchain-transport-lib\" }"));
-    for forbidden in ["ksp-job-backfill-lib", "ksp-store-lib", "ksp-store-api", "ksp-store-postgres-lib", "reqwest", "tokio-postgres"] {
+    assert!(manifest.contains("ksp-store-lib = { path = \"../ksp-store-lib\" }"));
+    for forbidden in ["ksp-job-backfill-lib", "ksp-store-api", "ksp-store-postgres-lib", "reqwest", "tokio-postgres"] {
         assert!(!manifest.contains(forbidden), "current Backfill Desk opens a forbidden dependency: {forbidden}");
     }
 }
@@ -114,21 +115,29 @@ fn pre_002_frontend_instrumentation_avoids_business_or_secret_payloads() {
 }
 
 #[test]
-fn pre_004_opens_only_config_logging_and_onchain_transport_dependencies() {
+fn pre_005_opens_store_facade_without_backend_or_job_dependencies() {
     let root = app_root();
     let manifest = read_text(root.join("Cargo.toml").as_path());
     assert!(manifest.contains("ksp-config-lib = { path = \"../ksp-config-lib\" }"));
     assert!(manifest.contains("ksp-onchain-transport-lib = { path = \"../ksp-onchain-transport-lib\" }"));
-    for forbidden in ["ksp-job-backfill-lib", "ksp-store-lib", "ksp-store-api", "ksp-store-postgres-lib"] {
-        assert!(!manifest.contains(forbidden), "pre.004 opens a later-layer dependency: {forbidden}");
+    assert!(manifest.contains("ksp-store-lib = { path = \"../ksp-store-lib\" }"));
+    for forbidden in ["ksp-job-backfill-lib", "ksp-store-api", "ksp-store-postgres-lib", "reqwest", "tokio-postgres"] {
+        assert!(!manifest.contains(forbidden), "pre.005 opens a forbidden direct dependency: {forbidden}");
     }
     let bootstrap = read_text(root.join("src/bootstrap.rs").as_path());
     assert!(bootstrap.contains("LogFilterLevel::Trace"));
     assert!(!bootstrap.contains("HttpTransportPool"));
     assert!(!bootstrap.contains("Store::open"));
+    let store = read_text(root.join("src/store_runtime.rs").as_path());
+    assert!(store.contains("ksp_store_lib::Store::open"));
+    assert!(store.contains("store.health().await"));
+    assert!(store.contains("store.close().await"));
+    for forbidden in ["connection_uri", "postgres", "database_url", "provider()", "endpoint_url"] {
+        assert!(!store.contains(forbidden), "Store runtime leaks or depends on forbidden physical metadata marker {forbidden}");
+    }
     let dto = read_text(root.join("src/dto_common.rs").as_path());
     assert!(dto.contains("BackfillDeskOptionsDto"));
-    for forbidden in ["pub(crate) provider", "endpoint_url", "pub(crate) url", "pub(crate) credential", "pub(crate) token"] {
-        assert!(!dto.contains(forbidden), "Transport options DTO source contains forbidden field marker {forbidden}");
+    for forbidden in ["pub(crate) provider", "endpoint_url", "pub(crate) url", "pub(crate) credential", "pub(crate) token", "connection_uri"] {
+        assert!(!dto.contains(forbidden), "readiness options DTO source contains forbidden field marker {forbidden}");
     }
 }