466 lines
22 KiB
Rust
466 lines
22 KiB
Rust
// file: crates/ksp-app-backfill-desk/tests/desktop_contract.rs
|
|
// version: 17
|
|
|
|
//! 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_json(path: &std::path::Path) -> serde_json::Value {
|
|
let source = read_text(path);
|
|
let parsed = serde_json::from_str(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_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"));
|
|
}
|
|
|
|
#[test]
|
|
fn pre_003_composite_packaging_follows_atomic_config_registry_contract() {
|
|
let root = app_root();
|
|
let config = read_json(root.join("tauri.conf.json").as_path());
|
|
let resources = config
|
|
.get("bundle")
|
|
.and_then(|value| {
|
|
return value.get("resources");
|
|
})
|
|
.and_then(serde_json::Value::as_object);
|
|
assert!(resources.is_some());
|
|
let resources = match resources {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => return,
|
|
};
|
|
assert_eq!(resources.len(), 15);
|
|
for required in [
|
|
"../../config/composite.ksp-app-backfill-desk.json",
|
|
"../../config/composite.ksp-app-solprices-desk.json",
|
|
"../../config/composite.ksp-app-store-desk.json",
|
|
"../../config/composite.ksp-app-wallet-desk.json",
|
|
"../../config/std.logging.json",
|
|
"../../config/std.offchain_transport.json",
|
|
"../../config/std.store.json",
|
|
"../../config/std.transport.json",
|
|
"../../config/std.wallet.json",
|
|
"../../config/schemas/composite.schema.json",
|
|
"../../config/schemas/std.logging.schema.json",
|
|
"../../config/schemas/std.offchain_transport.schema.json",
|
|
"../../config/schemas/std.store.schema.json",
|
|
"../../config/schemas/std.transport.schema.json",
|
|
"../../config/schemas/std.wallet.schema.json",
|
|
] {
|
|
assert!(resources.contains_key(required), "missing packaged Config resource {required}");
|
|
}
|
|
let tauri = read_text(root.join("src/tauri.rs").as_path());
|
|
assert!(tauri.contains("prepare_packaged_runtime"));
|
|
assert!(tauri.contains("resource_dir"));
|
|
assert!(tauri.contains("set_current_dir"));
|
|
}
|
|
|
|
#[test]
|
|
fn pre_003_bootstrap_keeps_logging_composition_separate_from_transport_runtime() {
|
|
let root = app_root();
|
|
let bootstrap = read_text(root.join("src/bootstrap.rs").as_path());
|
|
assert!(bootstrap.contains("FILE_ID_COMPOSITE_KSP_APP_BACKFILL_DESK"));
|
|
assert!(bootstrap.contains("COMPOSITE_COMPONENT_ID_LOGGING"));
|
|
assert!(bootstrap.contains("COMPOSITE_COMPONENT_ID_TRANSPORT"));
|
|
assert!(bootstrap.contains("COMPOSITE_COMPONENT_ID_STORE"));
|
|
assert!(bootstrap.contains("LogFilterLevel::Trace"));
|
|
for forbidden in ["HttpTransportPool", "Store::open", "BackfillJobRuntime", "BackfillRequest"] {
|
|
assert!(!bootstrap.contains(forbidden), "bootstrap.rs absorbs another runtime responsibility: {forbidden}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_004_transport_runtime_builds_pool_and_validates_both_required_rpc_methods() {
|
|
let root = app_root();
|
|
let transport = read_text(root.join("src/transport_runtime.rs").as_path());
|
|
assert!(transport.contains("HttpTransportPool::new"));
|
|
assert!(transport.contains("getSignaturesForAddress"));
|
|
assert!(transport.contains("getTransaction"));
|
|
assert!(transport.contains("select_for_method"));
|
|
assert!(transport.contains("configured_networks"));
|
|
assert!(transport.contains("compatible_backfill_http_routes"));
|
|
assert!(transport.contains("endpoint.provider()"));
|
|
for forbidden in ["url()", "Store::open", "BackfillJobRuntime", "BackfillRequest"] {
|
|
assert!(!transport.contains(forbidden), "pre.004 opens or projects forbidden surface {forbidden}");
|
|
}
|
|
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("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}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_006_mainnet_default_and_http_route_selector_are_explicit_without_start_runtime() {
|
|
let root = app_root();
|
|
let workspace = root.join("../..");
|
|
let composite = read_text(workspace.join("config/composite.ksp-app-backfill-desk.json").as_path());
|
|
assert!(composite.contains("\"default_profile\": \"mainnet\""));
|
|
assert!(composite.contains("\"profile_id\": \"mainnet_backfill_pool\""));
|
|
let transport = read_text(workspace.join("config/std.transport.json").as_path());
|
|
for required in ["mainnet_backfill_pool", "backfill_pool", "backfill_publicnode", "backfill_solana_public", "solana-rpc.publicnode.com"] {
|
|
assert!(transport.contains(required), "missing Backfill HTTP route marker {required}");
|
|
}
|
|
let frontend = read_text(root.join("frontend/ts/main.ts").as_path());
|
|
assert!(frontend.contains("Backfill Desk HTTP route selection changed"));
|
|
assert!(frontend.contains("backfill_options"));
|
|
let html = read_text(root.join("frontend/main.html").as_path());
|
|
assert!(html.contains("backfillHttpRoute"));
|
|
for forbidden in ["grpc", "websocket"] {
|
|
assert!(!frontend.contains(forbidden), "pre.006 frontend opens deferred runtime marker {forbidden}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_007_campaign_dto_and_backend_mapping_remain_the_authoritative_start_input() {
|
|
let root = app_root();
|
|
let manifest = read_text(root.join("Cargo.toml").as_path());
|
|
assert!(manifest.contains("ksp-job-api = { path = \"../ksp-job-api\" }"));
|
|
assert!(manifest.contains("ksp-job-backfill-lib = { path = \"../ksp-job-backfill-lib\" }"));
|
|
let dto = read_text(root.join("src/dto_backfill.rs").as_path());
|
|
for required in [
|
|
"BackfillStartRequestDto",
|
|
"BackfillRequestPreviewDto",
|
|
"MAX_BACKFILL_CANDIDATES",
|
|
"MAX_BACKFILL_HYDRATION_CONCURRENCY",
|
|
"MAX_BACKFILL_PAGES",
|
|
"MAX_BACKFILL_PAGE_SIZE",
|
|
] {
|
|
assert!(dto.contains(required), "missing pre.007 DTO/request bound marker {required}");
|
|
}
|
|
let mapping = read_text(root.join("src/backfill_request.rs").as_path());
|
|
for required in ["BackfillRequest::new", "HttpRoleName::new", "latest_address", "before_address", "after_address", "explicit_signatures"] {
|
|
assert!(mapping.contains(required), "missing strict Backfill request mapping marker {required}");
|
|
}
|
|
let tauri = read_text(root.join("src/tauri.rs").as_path());
|
|
assert!(tauri.contains("backfill_validate_request"));
|
|
let html = read_text(root.join("frontend/main.html").as_path());
|
|
for required in [
|
|
"backfillCampaignForm",
|
|
"backfillScopeKind",
|
|
"backfillCommitment",
|
|
"backfillAddress",
|
|
"backfillAnchorSignature",
|
|
"backfillExplicitSignatures",
|
|
"backfillMinContextSlot",
|
|
"validateBackfillRequest",
|
|
"Valider la requête",
|
|
] {
|
|
assert!(html.contains(required), "missing campaign form marker {required}");
|
|
}
|
|
let frontend = read_text(root.join("frontend/ts/main.ts").as_path());
|
|
assert!(frontend.contains("backfill_validate_request"));
|
|
assert!(frontend.contains("Backfill Desk campaign validation requested"));
|
|
assert!(frontend.contains("Aucun job n'a été démarré"));
|
|
assert!(frontend.contains("backfill_validate_request"));
|
|
assert!(tauri.contains("backfill_validate_request"));
|
|
}
|
|
|
|
#[test]
|
|
fn pre_008_start_installs_handle_before_non_blocking_spawn_and_keeps_single_run_backend_owned() {
|
|
let root = app_root();
|
|
let state = read_text(root.join("src/app_state.rs").as_path());
|
|
let run = read_text(root.join("src/backfill_run.rs").as_path());
|
|
let tauri = read_text(root.join("src/tauri.rs").as_path());
|
|
let html = read_text(root.join("frontend/main.html").as_path());
|
|
let frontend = read_text(root.join("frontend/ts/main.ts").as_path());
|
|
assert!(state.contains("BackfillJobRuntime::new(mapped)"));
|
|
let handle_index = state.find("let handle = runtime.handle();");
|
|
let install_index = state.find("self.backfill_runs.install(job_id.clone(), handle, retained_request)");
|
|
assert!(handle_index.is_some());
|
|
assert!(install_index.is_some());
|
|
if let (std::option::Option::Some(handle_index), std::option::Option::Some(install_index)) = (handle_index, install_index) {
|
|
assert!(handle_index < install_index);
|
|
}
|
|
assert!(run.contains("ERROR_CODE_BACKFILL_RUN_ACTIVE"));
|
|
assert!(run.contains("std::sync::Mutex<std::option::Option<ActiveBackfillRun>>"));
|
|
assert!(tauri.contains("backfill_start"));
|
|
let prepare_index = tauri.find("state.prepare_backfill_start(request)");
|
|
assert!(prepare_index.is_some());
|
|
if let std::option::Option::Some(prepare_index) = prepare_index {
|
|
let start_tail = &tauri[prepare_index..];
|
|
let spawn_index = start_tail.find("tauri::async_runtime::spawn(async move");
|
|
assert!(spawn_index.is_some());
|
|
}
|
|
assert!(html.contains("startBackfillRequest"));
|
|
assert!(html.contains("Démarrer le backfill"));
|
|
assert!(frontend.contains("Backfill Desk campaign Start requested"));
|
|
assert!(frontend.contains("backfill_start"));
|
|
}
|
|
|
|
#[test]
|
|
fn pre_009_latest_value_monitoring_uses_snapshot_source_event_bridge_and_resynchronization_command() {
|
|
let root = app_root();
|
|
let run = read_text(root.join("src/backfill_run.rs").as_path());
|
|
let status = read_text(root.join("src/backfill_status.rs").as_path());
|
|
let tauri = read_text(root.join("src/tauri.rs").as_path());
|
|
let frontend = read_text(root.join("frontend/ts/main.ts").as_path());
|
|
assert!(run.contains("last_terminal"));
|
|
assert!(run.contains("current_notification"));
|
|
assert!(status.contains("BackfillRunStatusDto"));
|
|
assert!(status.contains("checkpoint_present"));
|
|
assert!(status.contains("contiguous_completed"));
|
|
assert!(tauri.contains("backfill_status"));
|
|
assert!(tauri.contains("wait_for_change"));
|
|
assert!(tauri.contains("ksp-backfill-status") || tauri.contains("BACKFILL_STATUS_EVENT_NAME"));
|
|
assert!(frontend.contains("listen<BackfillRunStatusDto>"));
|
|
assert!(frontend.contains("syncBackfillStatus"));
|
|
assert!(!frontend.contains("parseBackfillLog"));
|
|
}
|
|
|
|
#[test]
|
|
fn pre_010_cancel_is_targeted_idempotent_and_shutdown_requests_cooperative_cancellation_before_exit() {
|
|
let root = app_root();
|
|
let state = read_text(root.join("src/app_state.rs").as_path());
|
|
let run = read_text(root.join("src/backfill_run.rs").as_path());
|
|
let tauri = read_text(root.join("src/tauri.rs").as_path());
|
|
let html = read_text(root.join("frontend/main.html").as_path());
|
|
let frontend = read_text(root.join("frontend/ts/main.ts").as_path());
|
|
assert!(run.contains("current.job_id.as_str() != job_id"));
|
|
assert!(run.contains("current.handle.cancel()"));
|
|
assert!(run.contains("ERROR_CODE_BACKFILL_RUN_MISMATCH"));
|
|
assert!(state.contains("cancel_backfill"));
|
|
assert!(state.contains("cancel_active_backfill_for_shutdown"));
|
|
assert!(tauri.contains("backfill_cancel"));
|
|
assert!(tauri.contains("cancel_active_backfill_for_shutdown"));
|
|
let shutdown_cancel = tauri.find("cancel_active_backfill_for_shutdown");
|
|
let shutdown_exit = tauri.find("app_handle.exit(0)");
|
|
assert!(shutdown_cancel.is_some());
|
|
assert!(shutdown_exit.is_some());
|
|
if let (std::option::Option::Some(cancel), std::option::Option::Some(exit)) = (shutdown_cancel, shutdown_exit) {
|
|
assert!(cancel < exit);
|
|
}
|
|
assert!(html.contains("cancelBackfillRun"));
|
|
assert!(html.contains("Annuler"));
|
|
assert!(frontend.contains("backfill_cancel"));
|
|
assert!(frontend.contains("{ jobId: status.jobId }"));
|
|
}
|
|
|
|
#[test]
|
|
fn pre_011_resume_reissues_rust_only_checkpoint_for_new_backend_job_without_ipc_checkpoint_material() {
|
|
let root = app_root();
|
|
let workspace = root.join("../..");
|
|
let checkpoint = read_text(workspace.join("crates/ksp-job-backfill-lib/src/checkpoint.rs").as_path());
|
|
assert!(checkpoint.contains("reissue_for_job"));
|
|
let request = read_text(workspace.join("crates/ksp-job-backfill-lib/src/request.rs").as_path());
|
|
assert!(request.contains("pub fn resume_for_job"));
|
|
assert!(request.contains("validate_request_checkpoint"));
|
|
assert!(request.contains("checkpoint.reissue_for_job(job_id.clone())"));
|
|
let run = read_text(root.join("src/backfill_run.rs").as_path());
|
|
for required in ["TerminalBackfillRun", "request: ksp_job_backfill_lib::BackfillRequest", "snapshot().checkpoint()", "resume_for_job(job_id, checkpoint)"] {
|
|
assert!(run.contains(required), "missing Rust-only Resume ownership marker {required}");
|
|
}
|
|
let state = read_text(root.join("src/app_state.rs").as_path());
|
|
for required in ["prepare_backfill_resume", "options.composition_ready", "store_network_matches", "role_available"] {
|
|
assert!(state.contains(required), "missing Resume admission marker {required}");
|
|
}
|
|
let tauri = read_text(root.join("src/tauri.rs").as_path());
|
|
assert!(tauri.contains("backfill_resume"));
|
|
assert!(tauri.contains("spawn_backfill_launch"));
|
|
let frontend = read_text(root.join("frontend/ts/main.ts").as_path());
|
|
assert!(frontend.contains("resumeBackfillRun"));
|
|
assert!(frontend.contains("checkpointPresent"));
|
|
assert!(frontend.contains("backfill_resume"));
|
|
let html = read_text(root.join("frontend/main.html").as_path());
|
|
assert!(html.contains("resumeBackfillRun"));
|
|
assert!(html.contains("Reprendre"));
|
|
}
|
|
|
|
#[test]
|
|
fn pre_012_free_address_autocomplete_is_html_datalist_derived_from_core_registry() {
|
|
let root = app_root();
|
|
let dto = read_text(root.join("src/dto_common.rs").as_path());
|
|
assert!(dto.contains("ksp_core_lib::entries()"));
|
|
assert!(dto.contains("ProgramIdAutocompleteOptionDto"));
|
|
assert!(dto.contains("program_id_autocomplete_options"));
|
|
let html = read_text(root.join("frontend/main.html").as_path());
|
|
assert!(html.contains("list=\"backfillProgramIds\""));
|
|
assert!(html.contains("<datalist id=\"backfillProgramIds\"></datalist>"));
|
|
assert!(html.contains("toute adresse Solana valide reste acceptée"));
|
|
let frontend = read_text(root.join("frontend/ts/main.ts").as_path());
|
|
for required in [
|
|
"renderProgramIdAutocomplete(options.programIdOptions)",
|
|
"option.value = program.programId",
|
|
"option.dataset.code = program.code",
|
|
"option.dataset.domain = program.domain",
|
|
"registryMatch: selected !== null",
|
|
"Backfill Desk Program ID autocomplete dataset rendered",
|
|
] {
|
|
assert!(frontend.contains(required), "missing pre.012 autocomplete marker {required}");
|
|
}
|
|
for forbidden in
|
|
["AddressLookupTab1e1111111111111111111111111", "ComputeBudget111111111111111111111111111111", "Vote111111111111111111111111111111111111111"]
|
|
{
|
|
assert!(!frontend.contains(forbidden), "frontend hardcodes canonical Program ID {forbidden}");
|
|
assert!(!html.contains(forbidden), "HTML hardcodes canonical Program ID {forbidden}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pre_013_final_v1_command_and_frontend_control_inventory_is_exact() {
|
|
let root = app_root();
|
|
let tauri = read_text(root.join("src/tauri.rs").as_path());
|
|
let commands = [
|
|
"backfill_cancel",
|
|
"backfill_options",
|
|
"backfill_resume",
|
|
"backfill_start",
|
|
"backfill_status",
|
|
"backfill_validate_request",
|
|
"emit_frontend_log",
|
|
"get_runtime_status",
|
|
"splash_frontend_ready",
|
|
];
|
|
for command in commands {
|
|
assert!(tauri.contains(format!("fn {command}").as_str()), "missing final Tauri command {command}");
|
|
}
|
|
assert_eq!(tauri.matches("#[tauri::command]").count(), commands.len());
|
|
for forbidden in ["backfill_reset", "backfill_delete", "backfill_retry", "backfill_schedule", "backfill_history"] {
|
|
assert!(!tauri.contains(forbidden), "unexpected V1 Tauri command marker {forbidden}");
|
|
}
|
|
let frontend = read_text(root.join("frontend/main.html").as_path());
|
|
for required in ["startBackfillRequest", "cancelBackfillRun", "resumeBackfillRun", "refreshBackfillStatus", "backfillProgramIds"] {
|
|
assert!(frontend.contains(required), "missing final frontend control {required}");
|
|
}
|
|
}
|