0.3.15-pre.012

crates/ksp-app-raw-transaction-ingest-desk/unit_tests/dto_route.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-raw-transaction-ingest-desk/unit_tests/dto_route.rs
-// version: 4
+// version: 5
 
 #[test]
 fn pre_005_route_ids_are_exact_and_stably_ordered() {
@@ -91,3 +91,34 @@ fn pre_008_runtime_acknowledgement_serializes_only_safe_logical_identity_and_sta
         }
     }
 }
+
+#[test]
+fn pre_012_route_requests_reject_unknown_fields_and_bound_free_form_profile_identity() {
+    let start = serde_json::from_value::<crate::RawIngestRouteStartRequestDto>(serde_json::json!({
+        "commitment": "confirmed",
+        "inventoryGeneration": 1,
+        "profileId": "mainnet",
+        "routeId": "http-block-polling",
+        "endpointUrl": "https://forbidden.invalid"
+    }));
+    assert!(start.is_err());
+    let stop = serde_json::from_value::<crate::RawIngestRouteStopRequestDto>(serde_json::json!({
+        "profileId": "mainnet",
+        "routeId": "http-block-polling",
+        "workerId": "forbidden"
+    }));
+    assert!(stop.is_err());
+    let oversized = crate::RawIngestRouteStartRequestDto {
+        commitment: crate::RawIngestCommitment::Confirmed,
+        inventory_generation: 1,
+        profile_id: "x".repeat(super::RAW_INGEST_PROFILE_ID_MAX_BYTES + 1),
+        route_id: crate::RawIngestRouteId::HttpBlockPolling,
+    };
+    let oversized = oversized.validate_logical_identity();
+    assert!(oversized.is_err());
+    if let std::result::Result::Err(error) = oversized {
+        assert_eq!(error.code(), crate::ERROR_CODE_ROUTE_REQUEST_INVALID);
+    }
+    let control = crate::RawIngestRouteStopRequestDto { profile_id: "mainnet\n".to_owned(), route_id: crate::RawIngestRouteId::HttpBlockPolling };
+    assert!(control.validate_logical_identity().is_err());
+}

crates/ksp-app-raw-transaction-ingest-desk/unit_tests/frontend_logging.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-raw-transaction-ingest-desk/unit_tests/frontend_logging.rs
-// version: 1
+// version: 2
 
 #[test]
 fn frontend_log_levels_are_explicit_and_case_insensitive() {
@@ -38,3 +38,26 @@ fn arbitrary_frontend_log_target_is_rejected() {
     };
     assert_eq!(error.code(), crate::ERROR_CODE_FRONTEND_LOG_TARGET_INVALID);
 }
+
+#[test]
+fn pre_012_frontend_log_ipc_rejects_unknown_fields_and_unbounded_or_control_messages() {
+    let unknown = serde_json::from_value::<crate::FrontendLogPayloadDto>(serde_json::json!({
+        "level": "info",
+        "targetId": "main",
+        "message": "safe",
+        "endpointUrl": "https://forbidden.invalid"
+    }));
+    assert!(unknown.is_err());
+    let oversized = crate::FrontendLogPayloadDto {
+        level: "info".to_owned(),
+        target_id: "main".to_owned(),
+        message: "x".repeat(super::FRONTEND_LOG_MESSAGE_MAX_BYTES + 1),
+    };
+    let result = super::validate_payload_shape(&oversized);
+    assert!(result.is_err());
+    if let std::result::Result::Err(error) = result {
+        assert_eq!(error.code(), crate::ERROR_CODE_FRONTEND_LOG_PAYLOAD_INVALID);
+    }
+    let nul = crate::FrontendLogPayloadDto { level: "info".to_owned(), target_id: "main".to_owned(), message: "safe\0hostile".to_owned() };
+    assert!(super::validate_payload_shape(&nul).is_err());
+}

crates/ksp-app-raw-transaction-ingest-desk/unit_tests/route_runtime.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-app-raw-transaction-ingest-desk/unit_tests/route_runtime.rs
-// version: 3
+// version: 4
 
 #[test]
 fn pre_009_multi_route_runtime_starts_without_workers_or_shared_store_material() {
@@ -63,3 +63,70 @@ fn pre_009_late_targeted_stop_waits_while_final_shared_store_is_closing() {
     let target = state.stop_target(&request);
     assert!(matches!(target, std::result::Result::Ok(super::RouteStopTarget::TerminalClosing)));
 }
+
+#[test]
+fn pre_012_stop_racing_start_marks_the_reservation_for_cooperative_stop() {
+    let state = crate::RouteRuntimeState::new();
+    let identity = super::RouteRuntimeIdentity {
+        commitment: crate::RawIngestCommitment::Confirmed,
+        inventory_generation: 12,
+        network: "mainnet".to_owned(),
+        profile_id: "mainnet".to_owned(),
+        route_id: crate::RawIngestRouteId::YellowstoneHydrated,
+    };
+    let inner = state.inner.lock();
+    assert!(inner.is_ok());
+    if let std::result::Result::Ok(mut inner) = inner {
+        inner.network = std::option::Option::Some("mainnet".to_owned());
+        inner.routes.push(super::RouteRuntimeSlot::Starting { identity: identity.clone(), stop_requested: false, token: 12 });
+    }
+    let request = crate::RawIngestRouteStopRequestDto { profile_id: "mainnet".to_owned(), route_id: crate::RawIngestRouteId::YellowstoneHydrated };
+    let target = state.stop_target(&request);
+    assert!(matches!(target, std::result::Result::Ok(super::RouteStopTarget::Starting { token: 12, .. })));
+    let inner = state.inner.lock();
+    assert!(inner.is_ok());
+    if let std::result::Result::Ok(inner) = inner {
+        assert!(matches!(inner.routes.first(), std::option::Option::Some(super::RouteRuntimeSlot::Starting { stop_requested: true, .. })));
+    }
+    let rollback = state.rollback(12);
+    assert!(matches!(rollback, std::result::Result::Ok(std::option::Option::None)));
+    let inner = state.inner.lock();
+    assert!(inner.is_ok());
+    if let std::result::Result::Ok(inner) = inner {
+        assert!(inner.routes.is_empty());
+        assert!(matches!(inner.last_terminals.first(), std::option::Option::Some(value) if value.state == crate::RawIngestRouteState::Stopped));
+    }
+}
+
+#[test]
+fn pre_012_application_shutdown_is_one_shot_and_marks_starting_routes_before_activation() {
+    let state = crate::RouteRuntimeState::new();
+    let identity = super::RouteRuntimeIdentity {
+        commitment: crate::RawIngestCommitment::Finalized,
+        inventory_generation: 13,
+        network: "mainnet".to_owned(),
+        profile_id: "mainnet".to_owned(),
+        route_id: crate::RawIngestRouteId::HttpBlockPolling,
+    };
+    let inner = state.inner.lock();
+    assert!(inner.is_ok());
+    if let std::result::Result::Ok(mut inner) = inner {
+        inner.network = std::option::Option::Some("mainnet".to_owned());
+        inner.routes.push(super::RouteRuntimeSlot::Starting { identity, stop_requested: false, token: 13 });
+    }
+    let first = state.begin_shutdown();
+    assert!(matches!(first, std::result::Result::Ok(true)));
+    let second = state.begin_shutdown();
+    assert!(matches!(second, std::result::Result::Ok(false)));
+    let admission = state.ensure_start_admission_open();
+    assert!(admission.is_err());
+    if let std::result::Result::Err(error) = admission {
+        assert_eq!(error.code(), crate::ERROR_CODE_ROUTE_RUNTIME_SHUTTING_DOWN);
+    }
+    let inner = state.inner.lock();
+    assert!(inner.is_ok());
+    if let std::result::Result::Ok(inner) = inner {
+        assert!(inner.shutting_down);
+        assert!(matches!(inner.routes.first(), std::option::Option::Some(super::RouteRuntimeSlot::Starting { stop_requested: true, .. })));
+    }
+}