277 lines
13 KiB
Rust
277 lines
13 KiB
Rust
// file: crates/ksp-app-raw-transaction-ingest-desk/tests/desktop_contract.rs
|
|
// version: 9
|
|
|
|
//! 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_006_route_inventory_is_backend_owned_and_keeps_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"));
|
|
assert!(tauri.contains("get_route_inventory"));
|
|
for forbidden in ["start_worker", "stop_worker", "RawTransactionIngestWorker", "Store::open"] {
|
|
assert!(!tauri.contains(forbidden), "scaffold Tauri surface contains premature runtime marker {forbidden}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_005_fix_002_shell_reuses_common_light_template_and_bounds_route_foundation() {
|
|
let html = read_text(app_root().join("frontend/main.html").as_path());
|
|
for required in [
|
|
"<header class=\"app-header\">",
|
|
"navbar h-100 py-0 bg-light text-dark",
|
|
"col-auto app-sidebar border-end bg-body-tertiary",
|
|
"col app-content app-scrollable h-100",
|
|
"card app-shell-card mx-auto shadow-sm border-0",
|
|
"id=\"routeFoundation\" class=\"row g-3 app-route-grid\"",
|
|
] {
|
|
assert!(html.contains(required), "missing common shell marker: {required}");
|
|
}
|
|
for forbidden in ["app-header bg-dark", "app-sidebar bg-dark text-light", "app-content flex-grow-1"] {
|
|
assert!(!html.contains(forbidden), "obsolete shell marker remains: {forbidden}");
|
|
}
|
|
let styles = read_text(app_root().join("frontend/sass/_app.scss").as_path());
|
|
for required in [
|
|
".app-scrollable {",
|
|
".app-shell-card {",
|
|
".app-route-grid {",
|
|
".app-route-grid > * {",
|
|
"min-width: 0;",
|
|
"max-width: 100%;",
|
|
"overflow: hidden;",
|
|
"overflow-wrap: anywhere;",
|
|
] {
|
|
assert!(styles.contains(required), "missing bounded layout marker: {required}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_006_frontend_projects_profile_network_generation_and_safe_route_reasons() {
|
|
let html = read_text(app_root().join("frontend/main.html").as_path());
|
|
for required in ["id=\"routeProfile\"", "id=\"routeNetwork\"", "id=\"routeInventoryGeneration\"", "id=\"routeFoundation\""] {
|
|
assert!(html.contains(required), "missing route inventory UI marker: {required}");
|
|
}
|
|
let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
|
|
for required in ["get_route_inventory", "missing_ws_block_capability", "missing_required_secret", "Config route inventory"] {
|
|
assert!(main.contains(required), "missing route inventory frontend marker: {required}");
|
|
}
|
|
for forbidden in ["endpointUrl", "connectionUri", "apiKey", "sourceKey", "x-token"] {
|
|
assert!(!main.contains(forbidden), "frontend exposes forbidden physical marker: {forbidden}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_007_start_preflight_is_backend_owned_generation_bound_and_does_not_launch_worker() {
|
|
let dto = read_text(app_root().join("src/dto_route.rs").as_path());
|
|
for required in
|
|
["RawIngestCommitment", "RawIngestRouteStartRequestDto", "inventory_generation", "profile_id", "route_id", "RawIngestRouteStartValidationDto"]
|
|
{
|
|
assert!(dto.contains(required), "missing pre.007 Start DTO marker: {required}");
|
|
}
|
|
let tauri = read_text(app_root().join("src/tauri.rs").as_path());
|
|
assert!(tauri.contains("validate_route_start"));
|
|
for forbidden in ["start_worker", "stop_worker", "start_with_runtime_resources", "Store::open"] {
|
|
assert!(!tauri.contains(forbidden), "pre.007 Tauri surface contains premature runtime marker {forbidden}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_009_start_stop_controls_are_multi_route_targeted_and_backend_owned() {
|
|
let tauri = read_text(app_root().join("src/tauri.rs").as_path());
|
|
for required in ["start_route", "stop_route", "RawIngestRouteStopRequestDto", "launch.monitor().await"] {
|
|
assert!(tauri.contains(required), "missing pre.009 Tauri runtime marker {required}");
|
|
}
|
|
let html = read_text(app_root().join("frontend/main.html").as_path());
|
|
for required in ["id=\"routeCommitment\"", "id=\"routeRuntimeState\"", "id=\"routeRuntimeIdentity\"", "Runtime multi-route / Store partagé"] {
|
|
assert!(html.contains(required), "missing pre.009 frontend runtime marker {required}");
|
|
}
|
|
assert!(!html.contains("id=\"stopRoute\""));
|
|
let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
|
|
for required in ["activeRuntimes", "targeted route Stop requested", "start_route", "stop_route", "RawIngestRouteStopRequestDto"] {
|
|
assert!(main.contains(required), "missing pre.009 frontend control marker {required}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_010_runtime_monitoring_is_backend_owned_event_driven_and_resynchronizable() {
|
|
let tauri = read_text(app_root().join("src/tauri.rs").as_path());
|
|
for required in [
|
|
"get_route_monitoring",
|
|
"monitor_route_status",
|
|
"window.emit(crate::RAW_INGEST_ROUTE_STATUS_EVENT_NAME, status)",
|
|
"source.wait_for_change(observed).await",
|
|
] {
|
|
assert!(tauri.contains(required), "missing pre.010 monitoring bridge marker {required}");
|
|
}
|
|
let state = read_text(app_root().join("src/app_state.rs").as_path());
|
|
assert!(state.contains("route_monitoring(&self)"));
|
|
assert!(state.contains("pre.010-runtime-monitoring"));
|
|
}
|
|
|
|
#[test]
|
|
fn pre_011_frontend_consumes_latest_value_monitoring_and_renders_full_route_supervision() {
|
|
let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
|
|
for required in [
|
|
"listen<RawIngestRouteMonitoringDto>",
|
|
"ksp-raw-ingest-route-status",
|
|
"get_route_monitoring",
|
|
"routeMonitoring",
|
|
"syncRouteMonitoring",
|
|
"persistedTotal",
|
|
"sourceActive",
|
|
"openGapCount",
|
|
"repairTransactionHydrationTotal",
|
|
"route supervision selected",
|
|
"route monitoring resynchronization requested",
|
|
] {
|
|
assert!(main.contains(required), "missing pre.011 frontend monitoring marker {required}");
|
|
}
|
|
let html = read_text(app_root().join("frontend/main.html").as_path());
|
|
for required in [
|
|
"id=\"refreshRouteMonitoring\"",
|
|
"id=\"routeMonitoringDetail\"",
|
|
"id=\"monitorPersistedTotal\"",
|
|
"id=\"monitorSourceCounts\"",
|
|
"id=\"monitorContinuityFrontier\"",
|
|
"id=\"monitorGapList\"",
|
|
"id=\"headerStore\"",
|
|
] {
|
|
assert!(html.contains(required), "missing pre.011 supervision UI marker {required}");
|
|
}
|
|
let styles = read_text(app_root().join("frontend/sass/_app.scss").as_path());
|
|
for required in [".app-route-monitoring-summary {", ".app-monitoring-detail {", ".app-monitoring-list dd", ".app-monitoring-gaps"] {
|
|
assert!(styles.contains(required), "missing pre.011 bounded supervision style {required}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_011_fix_001_monitoring_bridge_is_bounded_and_steady_updates_preserve_route_controls() {
|
|
let tauri = read_text(app_root().join("src/tauri.rs").as_path());
|
|
for required in [
|
|
"ROUTE_MONITORING_MIN_EMIT_INTERVAL_MS: u64 = 500",
|
|
"tokio::time::sleep(std::time::Duration::from_millis(ROUTE_MONITORING_MIN_EMIT_INTERVAL_MS)).await",
|
|
"snapshot = source.current()",
|
|
] {
|
|
assert!(tauri.contains(required), "missing pre.011-fix.001 bounded relay marker {required}");
|
|
}
|
|
let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
|
|
for required in [
|
|
"const routeCards = new Map<string, HTMLElement>()",
|
|
"renderRouteMonitoringCard",
|
|
"const lifecycleChanged = previous === null || previous.state !== status.state",
|
|
"if (lifecycleChanged || !renderRouteMonitoringCard(status))",
|
|
] {
|
|
assert!(main.contains(required), "missing pre.011-fix.001 stable-control marker {required}");
|
|
}
|
|
}
|