v0.3.7-pre.002

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

@@ -0,0 +1,121 @@
+// file: crates/ksp-app-backfill-desk/tests/desktop_contract.rs
+// version: 1
+
+//! Structural desktop contract checks for the Backfill 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 workspace_root() -> std::path::PathBuf {
+    return app_root().join("../..");
+}
+
+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 read_bytes(path: &std::path::Path) -> std::vec::Vec<u8> {
+    let source = std::fs::read(path);
+    assert!(source.is_ok(), "unable to read {}", path.display());
+    return match source {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => std::vec::Vec::new(),
+    };
+}
+
+#[test]
+fn pre_002_rust_package_is_mixed_lib_bin_and_workspace_member() {
+    let root = app_root();
+    let manifest = read_text(root.join("Cargo.toml").as_path());
+    assert!(manifest.contains("name = \"ksp-app-backfill-desk\""));
+    assert!(manifest.contains("name = \"ksp_app_backfill_desk_lib\""));
+    assert!(manifest.contains("[[bin]]"));
+    let workspace = read_text(workspace_root().join("Cargo.toml").as_path());
+    assert!(workspace.contains("crates/ksp-app-backfill-desk"));
+    let launcher = read_text(root.join("src/main.rs").as_path());
+    assert!(launcher.contains("ksp_app_backfill_desk_lib::run"));
+    assert!(launcher.contains("try_lock_exclusive"));
+}
+
+#[test]
+fn pre_002_vite_and_tauri_identity_use_reserved_ports_and_crate_local_hooks() {
+    let root = app_root();
+    let vite = read_text(root.join("vite.config.ts").as_path());
+    assert!(vite.contains("port: 1436"));
+    assert!(vite.contains("port: 1437"));
+    assert!(vite.contains("strictPort: true"));
+    let tauri = read_text(root.join("tauri.conf.json").as_path());
+    assert!(tauri.contains("KSP Backfill Desk"));
+    assert!(tauri.contains("com.sasedev.ksp-app-backfill-desk"));
+    assert!(tauri.contains("http://localhost:1436"));
+    assert!(tauri.contains("npm run dev"));
+    assert!(tauri.contains("npm run build"));
+    assert!(tauri.contains("../../../builds/khadhroony-solana-project/ksp-app-backfill-desk/dist"));
+}
+
+#[test]
+fn pre_002_package_dependencies_match_desk_baseline() {
+    let package = read_text(app_root().join("package.json").as_path());
+    for required in [
+        "@fltsci/tauri-plugin-tracing",
+        "@fortawesome/fontawesome-free",
+        "@tauri-apps/api",
+        "bootstrap",
+        "resize-observer-polyfill",
+        "simplebar",
+        "@tauri-apps/cli",
+        "@types/bootstrap",
+        "@types/node",
+        "sass-embedded",
+        "typescript",
+        "vite",
+    ] {
+        assert!(package.contains(required), "missing Desk package baseline dependency {required}");
+    }
+    assert!(!package.contains("package-lock"));
+}
+
+#[test]
+fn pre_002_splash_assets_and_styles_match_existing_desk_template() {
+    let root = app_root();
+    let reference = workspace_root().join("crates/ksp-app-solprices-desk");
+    for relative in ["frontend/fonts/DOS_Amazigh.ttf", "frontend/imgs/logo.png", "frontend/imgs/splash.png", "icons/favicon.png", "icons/favicon.ico"] {
+        assert_eq!(read_bytes(root.join(relative).as_path()), read_bytes(reference.join(relative).as_path()), "Desk asset differs: {relative}");
+    }
+    let splash = read_text(root.join("frontend/splash.html").as_path());
+    assert!(splash.contains("imgs/splash.png"));
+    assert!(splash.contains("Backfill Desk"));
+    let splash_style = read_text(root.join("frontend/sass/splash.scss").as_path());
+    let reference_style = read_text(reference.join("frontend/sass/splash.scss").as_path());
+    let normalized = splash_style.replace("crates/ksp-app-backfill-desk", "crates/ksp-app-solprices-desk").replace("// version: 1", "// version: 2");
+    assert_eq!(normalized, reference_style);
+}
+
+#[test]
+fn pre_002_shell_and_splash_use_shared_frontend_tooling() {
+    let root = app_root();
+    let shell = read_text(root.join("frontend/main.html").as_path());
+    for required in ["app-header", "app-sidebar", "app-sidebar-scroll", "app-content", "app-footer", "data-simplebar"] {
+        assert!(shell.contains(required), "Backfill Desk shell is missing template marker {required}");
+    }
+    let main = read_text(root.join("frontend/ts/main.ts").as_path());
+    assert!(main.contains("resize-observer-polyfill"));
+    assert!(main.contains("simplebar"));
+    assert!(main.contains("bootstrap"));
+    assert!(main.contains("Backfill Desk frontend control clicked"));
+    assert!(main.contains("Backfill Desk navigation tab clicked"));
+    assert!(main.contains("Backfill Desk runtime status refresh button clicked"));
+    let splash = read_text(root.join("frontend/ts/splash.ts").as_path());
+    assert!(splash.contains("Splash opacity animation started"));
+    assert!(splash.contains("Backfill Desk splash frontend loaded"));
+}

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

@@ -0,0 +1,115 @@
+// file: crates/ksp-app-backfill-desk/tests/desktop_security.rs
+// version: 1
+
+//! Security and dependency-boundary checks for the Backfill 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 collect_files(directory: &std::path::Path, extension: &str, files: &mut std::vec::Vec<std::path::PathBuf>) {
+    let entries = std::fs::read_dir(directory);
+    let entries = match entries {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    for entry in entries {
+        let entry = match entry {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => continue,
+        };
+        let path = entry.path();
+        if path.is_dir() {
+            collect_files(path.as_path(), extension, files);
+            continue;
+        }
+        if path.extension().and_then(std::ffi::OsStr::to_str) == std::option::Option::Some(extension) {
+            files.push(path);
+        }
+    }
+}
+
+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_002_capability_surface_is_core_plus_tracing_only() {
+    let root = app_root();
+    let capability = read_text(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));
+    }
+    let manifest = read_text(root.join("Cargo.toml").as_path());
+    assert!(manifest.contains("tauri-plugin-tracing.workspace = true"));
+    for forbidden in
+        ["ksp-job-backfill-lib", "ksp-onchain-transport-lib", "ksp-store-lib", "ksp-store-api", "ksp-store-postgres-lib", "reqwest", "tokio-postgres"]
+    {
+        assert!(!manifest.contains(forbidden), "pre.002 opens a later-layer dependency: {forbidden}");
+    }
+}
+
+#[test]
+fn pre_002_frontend_has_no_network_persistence_or_native_dialog_surface() {
+    let root = app_root();
+    let mut typescript = std::vec::Vec::new();
+    collect_files(root.join("frontend/ts").as_path(), "ts", &mut typescript);
+    assert!(!typescript.is_empty());
+    for path in typescript {
+        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 scaffold surface {forbidden}", path.display());
+        }
+    }
+}
+
+#[test]
+fn pre_002_tauri_commands_remain_centralized() {
+    let root = app_root();
+    let mut rust_files = std::vec::Vec::new();
+    collect_files(root.join("src").as_path(), "rs", &mut rust_files);
+    let mut command_count = 0usize;
+    for path in rust_files {
+        let source = read_text(path.as_path());
+        let count = source.matches("#[tauri::command]").count();
+        if path.file_name().and_then(std::ffi::OsStr::to_str) == std::option::Option::Some("tauri.rs") {
+            command_count += count;
+        } else {
+            assert_eq!(count, 0, "{} declares a Tauri command outside tauri.rs", path.display());
+        }
+    }
+    assert_eq!(command_count, 3);
+}
+
+#[test]
+fn pre_002_frontend_instrumentation_avoids_business_or_secret_payloads() {
+    let root = app_root();
+    let main = read_text(root.join("frontend/ts/main.ts").as_path());
+    for required in [
+        "Backfill Desk frontend control clicked",
+        "Backfill Desk navigation tab clicked",
+        "Backfill Desk runtime status refresh button clicked",
+        "Frontend IPC command requested",
+    ] {
+        if required == "Frontend IPC command requested" {
+            let invoke = read_text(root.join("frontend/ts/invoke.ts").as_path());
+            assert!(invoke.contains(required));
+        } else {
+            assert!(main.contains(required));
+        }
+    }
+    for forbidden in ["JSON.stringify(status)", "signature", "address", "apiKey", "authorization", "database_url"] {
+        assert!(!main.contains(forbidden));
+    }
+}

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

@@ -0,0 +1,14 @@
+// file: crates/ksp-app-backfill-desk/tests/public_api.rs
+// version: 1
+
+//! Public API checks for the KSP Backfill 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_backfill_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<()>>());
+}