v0.2.12-pre.002

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

@@ -0,0 +1,100 @@
+// file: crates/ksp-app-solprices-desk/tests/desktop_contract.rs
+// version: 1
+
+//! Desktop scaffold contract audits for SOL Prices Desk `0.2.12-pre.002`.
+
+fn app_root() -> std::path::PathBuf {
+    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+}
+
+fn read_json(path: &std::path::Path) -> serde_json::Value {
+    let source = std::fs::read_to_string(path);
+    assert!(source.is_ok(), "unable to read {}", path.display());
+    let source = match source {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return serde_json::Value::Null,
+    };
+    let parsed = serde_json::from_str::<serde_json::Value>(source.as_str());
+    assert!(parsed.is_ok(), "unable to parse {}", path.display());
+    return match parsed {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => serde_json::Value::Null,
+    };
+}
+
+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_shell_uses_reserved_ports_windows_and_owned_backend_paths() {
+    let root = app_root();
+    let tauri = read_json(root.join("tauri.conf.json").as_path());
+    assert_eq!(tauri.pointer("/productName").and_then(serde_json::Value::as_str), std::option::Option::Some("KSP SOL Prices Desk"));
+    assert_eq!(tauri.pointer("/identifier").and_then(serde_json::Value::as_str), std::option::Option::Some("com.sasedev.ksp-app-solprices-desk"));
+    assert_eq!(tauri.pointer("/version").and_then(serde_json::Value::as_str), std::option::Option::Some("0.2.12-pre.2"));
+    assert_eq!(tauri.pointer("/build/devUrl").and_then(serde_json::Value::as_str), std::option::Option::Some("http://localhost:1434"));
+    assert_eq!(tauri.pointer("/build/beforeDevCommand/script").and_then(serde_json::Value::as_str), std::option::Option::Some("npm run dev"));
+    assert_eq!(tauri.pointer("/build/beforeDevCommand/cwd").and_then(serde_json::Value::as_str), std::option::Option::Some("."));
+    assert_eq!(tauri.pointer("/build/beforeBuildCommand/script").and_then(serde_json::Value::as_str), std::option::Option::Some("npm run build"));
+    assert_eq!(tauri.pointer("/build/beforeBuildCommand/cwd").and_then(serde_json::Value::as_str), std::option::Option::Some("."));
+    assert_eq!(
+        tauri.pointer("/build/frontendDist").and_then(serde_json::Value::as_str),
+        std::option::Option::Some("../../../builds/khadhroony-solana-project/ksp-app-solprices-desk/dist"),
+    );
+    let windows = tauri.pointer("/app/windows").and_then(serde_json::Value::as_array);
+    assert!(windows.is_some());
+    let labels = match windows {
+        std::option::Option::Some(values) => {
+            values.iter().filter_map(|window| return window.get("label").and_then(serde_json::Value::as_str)).collect::<std::vec::Vec<_>>()
+        },
+        std::option::Option::None => return,
+    };
+    assert_eq!(labels, ["splash", "main"]);
+    let vite = read_text(root.join("vite.config.ts").as_path());
+    assert!(vite.contains("port: 1434"));
+    assert!(vite.contains("port: 1435"));
+    assert!(vite.contains("strictPort: true"));
+    assert!(!vite.contains("ksp-app-wallet-desk"));
+}
+
+#[test]
+fn pre_002_package_is_mixed_lib_bin_and_frontend_is_scaffold_only() {
+    let root = app_root();
+    let manifest = read_text(root.join("Cargo.toml").as_path());
+    assert!(manifest.contains("name = \"ksp-app-solprices-desk\""));
+    assert!(manifest.contains("name = \"ksp_app_solprices_desk_lib\""));
+    assert!(manifest.contains("[[bin]]"));
+    let main_rs = read_text(root.join("src/main.rs").as_path());
+    assert!(main_rs.contains("ksp_app_solprices_desk_lib::run"));
+    let lib_rs = read_text(root.join("src/lib.rs").as_path());
+    assert!(lib_rs.contains("pub use self::tauri::run"));
+    let tauri_rs = read_text(root.join("src/tauri.rs").as_path());
+    assert!(tauri_rs.contains("tauri::generate_handler![emit_frontend_log, runtime_status, splash_frontend_ready]"));
+    let main_html = read_text(root.join("frontend/main.html").as_path());
+    assert!(main_html.contains("data-view=\"prices\""));
+    assert!(main_html.contains("data-view=\"diagnostics\""));
+    assert!(!main_html.contains("<table"));
+}
+
+#[test]
+fn pre_002_packaging_contains_current_ten_config_resources_only() {
+    let root = app_root();
+    let tauri = read_json(root.join("tauri.conf.json").as_path());
+    let resources = tauri.pointer("/bundle/resources").and_then(serde_json::Value::as_object);
+    assert!(resources.is_some());
+    if let std::option::Option::Some(resources) = resources {
+        assert_eq!(resources.len(), 10);
+        assert!(!resources.contains_key("../../config/composite.ksp-app-solprices-desk.json"));
+        assert!(resources.contains_key("../../config/std.offchain_transport.json"));
+        assert!(resources.contains_key("../../config/schemas/std.offchain_transport.schema.json"));
+    }
+    let tauri_source = read_text(root.join("src/tauri.rs").as_path());
+    assert!(tauri_source.contains("ksp_config_lib::prepare_packaged_runtime"));
+    assert!(tauri_source.contains("std::env::set_current_dir(layout.runtime_root())"));
+}

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

@@ -0,0 +1,89 @@
+// file: crates/ksp-app-solprices-desk/tests/desktop_security.rs
+// version: 1
+
+//! Security and ownership canaries for the non-functional SOL Prices Desk scaffold.
+
+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"));
+    assert!(!manifest.contains("tauri-plugin-dialog"));
+    assert!(!manifest.contains("ksp-offchain-transport-lib"));
+    assert!(!manifest.contains("reqwest"));
+}
+
+#[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_and_price_runtime_is_absent() {
+    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!(!source.contains("MarketPriceService"), "{} advances market-price runtime before pre.003", path.display());
+        assert!(!source.contains("refresh_market_price"), "{} advances refresh commands before their planned tranche", path.display());
+    }
+    assert_eq!(command_count, 3);
+}

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

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