v0.3.15-pre.005

crates/ksp-app-raw-transaction-ingest-desk/tests/dependency_boundary.rs

@@ -0,0 +1,70 @@
+// file: crates/ksp-app-raw-transaction-ingest-desk/tests/dependency_boundary.rs
+// version: 1
+
+//! Dependency-boundary canaries for the Raw Transaction Ingest Desk scaffold.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+fn app_root() -> std::path::PathBuf {
+    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+}
+
+fn read_text(path: &std::path::Path) -> String {
+    let source = std::fs::read_to_string(path);
+    assert!(source.is_ok(), "unable to read {}", path.display());
+    return match source {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => String::new(),
+    };
+}
+
+#[test]
+fn pre_005_manifest_is_scaffold_only_and_backend_neutral() {
+    let manifest = read_text(app_root().join("Cargo.toml").as_path());
+    for required in ["ksp-config-lib", "ksp-core-lib", "ksp-logging-lib", "tauri-plugin-tracing"] {
+        assert!(manifest.contains(required), "missing scaffold dependency {required}");
+    }
+    for forbidden in [
+        "ksp-onchain-transport-lib",
+        "ksp-store-lib",
+        "ksp-store-api",
+        "ksp-store-postgres-lib",
+        "ksp-worker-api",
+        "ksp-worker-raw-transaction-ingest-lib",
+        "ksp-job-backfill-lib",
+        "reqwest",
+        "tokio-postgres",
+        "tonic",
+        "yellowstone-grpc",
+    ] {
+        assert!(!manifest.contains(forbidden), "scaffold opens forbidden dependency {forbidden}");
+    }
+}
+
+#[test]
+fn pre_005_production_sources_do_not_construct_transport_store_or_worker_runtime() {
+    let root = app_root().join("src");
+    let entries = std::fs::read_dir(root.as_path());
+    assert!(entries.is_ok());
+    if let std::result::Result::Ok(entries) = entries {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.extension().and_then(std::ffi::OsStr::to_str) != std::option::Option::Some("rs") {
+                continue;
+            }
+            let source = read_text(path.as_path());
+            for forbidden in [
+                "HttpTransportPool",
+                "WsTransportSettings",
+                "YellowstoneGrpcChannel",
+                "ksp_store_lib::Store",
+                "RawTransactionIngestWorker",
+                "RawTransactionIngestRuntimeResources",
+            ] {
+                assert!(!source.contains(forbidden), "{} contains premature runtime marker {forbidden}", path.display());
+            }
+        }
+    }
+}

crates/ksp-app-raw-transaction-ingest-desk/tests/desktop_contract.rs

@@ -0,0 +1,124 @@
+// file: crates/ksp-app-raw-transaction-ingest-desk/tests/desktop_contract.rs
+// version: 1
+
+//! Desktop scaffold contract canaries for Raw Transaction Ingest Desk.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+fn app_root() -> std::path::PathBuf {
+    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+}
+
+fn read_text(path: &std::path::Path) -> String {
+    let source = std::fs::read_to_string(path);
+    assert!(source.is_ok(), "unable to read {}", path.display());
+    return match source {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => String::new(),
+    };
+}
+
+#[test]
+fn pre_005_vite_and_tauri_identity_use_reserved_ports_and_crate_local_hooks() {
+    let config = std::fs::read_to_string(app_root().join("tauri.conf.json"));
+    assert!(config.is_ok());
+    let config = match config {
+        std::result::Result::Ok(value) => serde_json::from_str::<serde_json::Value>(value.as_str()),
+        std::result::Result::Err(_) => return,
+    };
+    assert!(config.is_ok());
+    if let std::result::Result::Ok(config) = config {
+        assert_eq!(config["productName"], "KSP Raw Transaction Ingest Desk");
+        assert_eq!(config["identifier"], "com.sasedev.ksp-app-raw-transaction-ingest-desk");
+        assert_eq!(config["build"]["devUrl"], "http://localhost:1440");
+    }
+    let vite = read_text(app_root().join("vite.config.ts").as_path());
+    assert!(vite.contains("port: 1440"));
+    assert!(vite.contains("strictPort: true"));
+    assert!(vite.contains("port: 1441"));
+}
+
+#[test]
+fn pre_005_rust_package_is_mixed_lib_bin_and_workspace_member() {
+    let manifest = read_text(app_root().join("Cargo.toml").as_path());
+    assert!(manifest.contains("name = \"ksp-app-raw-transaction-ingest-desk\""));
+    assert!(manifest.contains("name = \"ksp_app_raw_transaction_ingest_desk_lib\""));
+    assert!(manifest.contains("crate-type = [\"staticlib\", \"cdylib\", \"rlib\"]"));
+    let workspace = read_text(app_root().join("../../Cargo.toml").as_path());
+    assert!(workspace.contains("crates/ksp-app-raw-transaction-ingest-desk"));
+}
+
+#[test]
+fn pre_005_package_dependencies_match_current_desk_baseline() {
+    let package = std::fs::read_to_string(app_root().join("package.json"));
+    assert!(package.is_ok());
+    let package = match package {
+        std::result::Result::Ok(value) => serde_json::from_str::<serde_json::Value>(value.as_str()),
+        std::result::Result::Err(_) => return,
+    };
+    assert!(package.is_ok());
+    if let std::result::Result::Ok(package) = package {
+        let dependencies = &package["dependencies"];
+        for dependency in
+            ["@fltsci/tauri-plugin-tracing", "@fortawesome/fontawesome-free", "@tauri-apps/api", "bootstrap", "resize-observer-polyfill", "simplebar"]
+        {
+            assert!(dependencies.get(dependency).is_some(), "missing frontend dependency {dependency}");
+        }
+        assert!(dependencies.get("datatables.net-bs5").is_none());
+        let development = &package["devDependencies"];
+        for dependency in ["@tauri-apps/cli", "@types/bootstrap", "@types/node", "sass-embedded", "typescript", "vite"] {
+            assert!(development.get(dependency).is_some(), "missing frontend development dependency {dependency}");
+        }
+    }
+}
+
+#[test]
+fn pre_005_packaging_contains_current_sixteen_config_resources() {
+    let config = std::fs::read_to_string(app_root().join("tauri.conf.json"));
+    assert!(config.is_ok());
+    let config = match config {
+        std::result::Result::Ok(value) => serde_json::from_str::<serde_json::Value>(value.as_str()),
+        std::result::Result::Err(_) => return,
+    };
+    assert!(config.is_ok());
+    if let std::result::Result::Ok(config) = config {
+        let resources = config["bundle"]["resources"].as_object();
+        assert!(resources.is_some());
+        if let std::option::Option::Some(resources) = resources {
+            assert_eq!(resources.len(), 16);
+            assert!(resources.contains_key("../../config/composite.ksp-app-raw-transaction-ingest-desk.json"));
+        }
+    }
+}
+
+#[test]
+fn pre_005_splash_assets_match_existing_ksp_desk_template_byte_exact() {
+    let reference = app_root().join("../ksp-app-backfill-desk");
+    for relative in ["icons/favicon.ico", "icons/favicon.png", "frontend/fonts/DOS_Amazigh.ttf", "frontend/imgs/logo.png", "frontend/imgs/splash.png"] {
+        let current = std::fs::read(app_root().join(relative));
+        let expected = std::fs::read(reference.join(relative));
+        assert!(current.is_ok());
+        assert!(expected.is_ok());
+        if let (std::result::Result::Ok(current), std::result::Result::Ok(expected)) = (current, expected) {
+            assert_eq!(current, expected, "binary template asset differs: {relative}");
+        }
+    }
+}
+
+#[test]
+fn pre_005_route_foundation_is_backend_owned_and_has_exact_five_ids_and_seven_states() {
+    let dto = read_text(app_root().join("src/dto_route.rs").as_path());
+    for route in ["YellowstoneHydrated", "StandardLogsHydrated", "StandardBlockDirect", "HeliusTransactionHydrated", "HttpBlockPolling"] {
+        assert!(dto.contains(route));
+    }
+    for state in ["Unavailable", "Configured", "Starting", "Running", "Stopping", "Stopped", "Faulted"] {
+        assert!(dto.contains(state));
+    }
+    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
+    assert!(tauri.contains("get_route_foundation"));
+    for forbidden in ["start_worker", "stop_worker", "RawTransactionIngestWorker", "Store::open", "HttpTransportPool"] {
+        assert!(!tauri.contains(forbidden), "scaffold Tauri surface contains premature runtime marker {forbidden}");
+    }
+}

crates/ksp-app-raw-transaction-ingest-desk/tests/desktop_security.rs

@@ -0,0 +1,72 @@
+// file: crates/ksp-app-raw-transaction-ingest-desk/tests/desktop_security.rs
+// version: 1
+
+//! Desktop security canaries for the Raw Transaction Ingest Desk scaffold.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+fn app_root() -> std::path::PathBuf {
+    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+}
+
+fn read_text(path: &std::path::Path) -> String {
+    let source = std::fs::read_to_string(path);
+    assert!(source.is_ok(), "unable to read {}", path.display());
+    return match source {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => String::new(),
+    };
+}
+
+fn collect_typescript(root: &std::path::Path, files: &mut std::vec::Vec<std::path::PathBuf>) {
+    let entries = std::fs::read_dir(root);
+    if let std::result::Result::Ok(entries) = entries {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                collect_typescript(path.as_path(), files);
+            } else if path.extension().and_then(std::ffi::OsStr::to_str) == std::option::Option::Some("ts") {
+                files.push(path);
+            }
+        }
+    }
+}
+
+#[test]
+fn pre_005_capability_surface_is_core_plus_tracing_only() {
+    let capability = read_text(app_root().join("capabilities/default.json").as_path());
+    assert!(capability.contains("\"core:default\""));
+    assert!(capability.contains("\"tracing:default\""));
+    for forbidden in ["dialog:", "fs:", "http:", "shell:"] {
+        assert!(!capability.contains(forbidden));
+    }
+}
+
+#[test]
+fn pre_005_frontend_has_no_network_persistence_or_native_dialog_surface() {
+    let mut files = std::vec::Vec::new();
+    collect_typescript(app_root().join("frontend/ts").as_path(), &mut files);
+    assert!(!files.is_empty());
+    for path in files {
+        let source = read_text(path.as_path());
+        for forbidden in ["fetch(", "XMLHttpRequest", "localStorage", "sessionStorage", "window.alert(", "window.confirm(", "window.prompt("] {
+            assert!(!source.contains(forbidden), "{} contains forbidden frontend surface {forbidden}", path.display());
+        }
+    }
+}
+
+#[test]
+fn pre_005_frontend_tracing_is_control_and_command_oriented_only() {
+    let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
+    assert!(main.contains("frontend control clicked"));
+    assert!(main.contains("navigation tab clicked"));
+    assert!(main.contains("runtime status refresh requested"));
+    assert!(main.contains("route foundation refresh requested"));
+    let invoke = read_text(app_root().join("frontend/ts/invoke.ts").as_path());
+    assert!(invoke.contains("Frontend IPC command requested"));
+    for forbidden in ["apiKey", "authorization", "connectionUri", "endpointUrl", "sourceKey", "rawTransaction", "transactionPayload"] {
+        assert!(!main.contains(forbidden), "frontend contains forbidden sensitive marker {forbidden}");
+    }
+}

crates/ksp-app-raw-transaction-ingest-desk/tests/public_api.rs

@@ -0,0 +1,14 @@
+// file: crates/ksp-app-raw-transaction-ingest-desk/tests/public_api.rs
+// version: 1
+
+//! Public API checks for the KSP Raw Transaction Ingest desktop application library.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+#[test]
+fn run_entry_point_is_available_from_crate_root() {
+    let run_entry_point: fn(&[std::ffi::OsString]) -> ksp_core_lib::Result<()> = ksp_app_raw_transaction_ingest_desk_lib::run;
+    assert_eq!(std::mem::size_of_val(&run_entry_point), std::mem::size_of::<fn(&[std::ffi::OsString]) -> ksp_core_lib::Result<()>>());
+}

crates/ksp-app-raw-transaction-ingest-desk/tests/release_completeness.rs

@@ -0,0 +1,70 @@
+// file: crates/ksp-app-raw-transaction-ingest-desk/tests/release_completeness.rs
+// version: 1
+
+//! Release-completeness canaries for the Raw Transaction Ingest Desk scaffold tranche.
+
+#![forbid(unsafe_code)]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+
+fn app_root() -> std::path::PathBuf {
+    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+}
+
+fn read_text(path: &std::path::Path) -> String {
+    let source = std::fs::read_to_string(path);
+    assert!(source.is_ok(), "unable to read {}", path.display());
+    return match source {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => String::new(),
+    };
+}
+
+#[test]
+fn pre_005_production_module_inventory_is_exact_and_scaffold_only() {
+    let lib = read_text(app_root().join("src/lib.rs").as_path());
+    let expected = [
+        "mod app_state;",
+        "mod bootstrap;",
+        "mod constants;",
+        "mod dto_common;",
+        "mod dto_route;",
+        "mod errors;",
+        "mod frontend_logging;",
+        "mod logging_runtime;",
+        "mod splash;",
+        "mod tauri;",
+        "mod tw_main;",
+        "mod tw_splash;",
+    ];
+    assert_eq!(lib.matches("mod ").count(), expected.len());
+    for module in expected {
+        assert!(lib.contains(module));
+    }
+}
+
+#[test]
+fn pre_005_public_surface_exposes_only_application_run_entry_point() {
+    let lib = read_text(app_root().join("src/lib.rs").as_path());
+    let public_reexports = lib.lines().filter(|line| line.starts_with("pub use ")).collect::<std::vec::Vec<_>>();
+    assert_eq!(public_reexports, vec!["pub use self::tauri::run;"]);
+}
+
+#[test]
+fn pre_005_scaffold_keeps_start_stop_inventory_and_runtime_for_later_tranches() {
+    let app = read_text(app_root().join("src/app_state.rs").as_path());
+    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
+    for forbidden in [
+        "RawTransactionIngestWorker",
+        "RawTransactionIngestRuntimeResources",
+        "request_stop",
+        "start_with_runtime_resources",
+        "Store::open",
+        "HttpTransportPool",
+        "WsProtocolSession",
+        "YellowstoneGrpcChannel",
+    ] {
+        assert!(!app.contains(forbidden));
+        assert!(!tauri.contains(forbidden));
+    }
+}