v0.3.14-pre.003

crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/runtime_resources.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/runtime_resources.rs
-// version: 23
+// version: 24
 
 fn grpc_endpoint(cluster: &str) -> std::option::Option<ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings> {
     return grpc_endpoint_with_identity(cluster, "yellowstone-fixture", "fixture-provider");
@@ -3347,3 +3347,73 @@ async fn v0_3_13_pre_011_stop_racing_ready_source_fault_preserves_fault_and_join
     assert_eq!(sibling_active.load(std::sync::atomic::Ordering::Acquire), 0);
     return;
 }
+
+#[test]
+fn v0_3_14_pre_003_websocket_reconnect_is_anchored_before_terminal_gap_projection() {
+    let (sender, receiver) = tokio::sync::watch::channel(crate::RawTransactionIngestProcessingFrontierProjection::empty());
+    let mut reporter = super::RawTransactionIngestProcessingFrontierReporter::new(sender);
+    assert!(reporter.observe_settled(100).is_ok());
+    assert!(reporter.observe_websocket_continuity(crate::RawTransactionIngestSourceState::Active, 0, 0).is_ok());
+    assert!(reporter.observe_websocket_continuity(crate::RawTransactionIngestSourceState::Reconnecting, 1, 0).is_ok());
+    let anchor = match reporter.websocket_incident_anchor {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => panic!("reconnect incident anchor missing"),
+    };
+    assert_eq!(anchor.start_slot(), 100);
+    assert_eq!(anchor.end_slot(), std::option::Option::None);
+    assert!(anchor.saw_reconnect());
+    assert!(!anchor.saw_overflow());
+    assert!(reporter.observe_websocket_continuity(crate::RawTransactionIngestSourceState::Active, 1, 0).is_ok());
+    let bounded = reporter.observe_websocket_post_incident_slot(105);
+    assert!(matches!(bounded, std::result::Result::Ok(true)));
+    let anchor = match reporter.websocket_incident_anchor {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => panic!("bounded reconnect incident anchor missing"),
+    };
+    assert_eq!(anchor.end_slot(), std::option::Option::Some(105));
+    let projection = *receiver.borrow();
+    assert_eq!(projection.source_reconnect_total(), 1);
+    assert_eq!(projection.source_replay_attempt_total(), 0);
+    assert_eq!(projection.source_continuity_gap_total(), 1);
+    return;
+}
+
+#[test]
+fn v0_3_14_pre_003_websocket_overflow_and_reconnect_storm_share_earliest_anchor() {
+    let (sender, receiver) = tokio::sync::watch::channel(crate::RawTransactionIngestProcessingFrontierProjection::empty());
+    let mut reporter = super::RawTransactionIngestProcessingFrontierReporter::new(sender);
+    assert!(reporter.observe_settled(200).is_ok());
+    assert!(reporter.observe_websocket_continuity(crate::RawTransactionIngestSourceState::Active, 0, 1).is_ok());
+    assert!(reporter.observe_websocket_continuity(crate::RawTransactionIngestSourceState::Reconnecting, 1, 2).is_ok());
+    let anchor = match reporter.websocket_incident_anchor {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => panic!("overflow incident anchor missing"),
+    };
+    assert_eq!(anchor.start_slot(), 200);
+    assert_eq!(anchor.end_slot(), std::option::Option::None);
+    assert!(anchor.saw_reconnect());
+    assert!(anchor.saw_overflow());
+    let projection = *receiver.borrow();
+    assert_eq!(projection.source_reconnect_total(), 1);
+    assert_eq!(projection.source_continuity_gap_total(), 3);
+    let bounded = reporter.observe_websocket_post_incident_slot(201);
+    assert!(matches!(bounded, std::result::Result::Ok(true)));
+    return;
+}
+
+#[test]
+fn v0_3_14_pre_003_websocket_incident_without_observed_slot_is_unbounded_and_counter_regression_fails() {
+    let (sender, _receiver) = tokio::sync::watch::channel(crate::RawTransactionIngestProcessingFrontierProjection::empty());
+    let mut reporter = super::RawTransactionIngestProcessingFrontierReporter::new(sender);
+    let unbounded = reporter.observe_websocket_continuity(crate::RawTransactionIngestSourceState::Reconnecting, 1, 0);
+    assert!(unbounded.is_err());
+    let unbounded = match unbounded {
+        std::result::Result::Ok(()) => return,
+        std::result::Result::Err(value) => value,
+    };
+    assert!(unbounded.context().iter().any(|context| {
+        return context.value() == "source.websocket_incident_unbounded";
+    }));
+    assert!(reporter.observe_websocket_continuity(crate::RawTransactionIngestSourceState::Active, 0, 0).is_err());
+    return;
+}