v0.3.13-pre.009

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

@@ -1,5 +1,5 @@
 // file: crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/admission.rs
-// version: 5
+// version: 6
 
 fn material(
     network: &str,
@@ -311,3 +311,104 @@ async fn v0_3_13_pre_008_distinct_source_keys_produce_distinct_idempotent_observ
     assert_ne!(first.observation().observation_key(), second.observation().observation_key());
     return;
 }
+
+#[tokio::test(flavor = "current_thread")]
+async fn v0_3_13_pre_009_duplicate_storm_cannot_starve_second_ready_source_on_bounded_admission() {
+    let (network, initial_material) = match material("mainnet", 60, "AQID") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let (_, peer_material) = match material("mainnet", 99, "BwgJ") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let initial_provenance = match provenance() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let storm_provenance = match provenance() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let peer_provenance = match provenance() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let (mut admission, sender) = crate::RawTransactionAdmission::new(1);
+    assert!(
+        sender
+            .send(crate::RawTransactionIngress {
+                material: initial_material,
+                network: network.clone(),
+                provenance: initial_provenance,
+                source_key: [60_u8; 32],
+            })
+            .await
+            .is_ok()
+    );
+    let storm_sender = sender.clone();
+    let storm_network = network.clone();
+    let storm_task = tokio::spawn(async move {
+        for _ in 0..8 {
+            let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64(
+                storm_network.clone(),
+                ksp_store_lib::RawTransactionSignature::new([61_u8; 64]),
+                42,
+                std::option::Option::Some(1_700_000_000),
+                "BAUG",
+                ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+                ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+                ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
+            );
+            if storm_sender
+                .send(crate::RawTransactionIngress {
+                    material,
+                    network: storm_network.clone(),
+                    provenance: storm_provenance.clone(),
+                    source_key: [61_u8; 32],
+                })
+                .await
+                .is_err()
+            {
+                return false;
+            }
+        }
+        return true;
+    });
+    tokio::task::yield_now().await;
+    let peer_sender = sender.clone();
+    let peer_network = network.clone();
+    let peer_task = tokio::spawn(async move {
+        return peer_sender
+            .send(crate::RawTransactionIngress { material: peer_material, network: peer_network, provenance: peer_provenance, source_key: [99_u8; 32] })
+            .await
+            .is_ok();
+    });
+    tokio::task::yield_now().await;
+    assert_eq!(admission.queue_depth(), 1);
+    let first = match admission.receive(&network).await {
+        std::result::Result::Ok(std::option::Option::Some(value)) => value,
+        _ => return,
+    };
+    assert_eq!(first.transaction().reference().signature().as_bytes(), &[60_u8; 64]);
+    let second = match admission.receive(&network).await {
+        std::result::Result::Ok(std::option::Option::Some(value)) => value,
+        _ => return,
+    };
+    assert_eq!(second.transaction().reference().signature().as_bytes(), &[61_u8; 64]);
+    let third = match admission.receive(&network).await {
+        std::result::Result::Ok(std::option::Option::Some(value)) => value,
+        _ => return,
+    };
+    assert_eq!(third.transaction().reference().signature().as_bytes(), &[99_u8; 64]);
+    for _ in 0..7 {
+        let next = admission.receive(&network).await;
+        assert!(matches!(next, std::result::Result::Ok(std::option::Option::Some(_))));
+        assert!(admission.queue_depth() <= 1);
+    }
+    let peer_joined = peer_task.await;
+    assert!(matches!(peer_joined, std::result::Result::Ok(true)));
+    let storm_joined = storm_task.await;
+    assert!(matches!(storm_joined, std::result::Result::Ok(true)));
+    return;
+}