v0.3.3-pre.004

2026-08-30 11:00:07 +02:00
parent 56fadb364a
commit 917e602a87
14 changed files with 1368 additions and 45 deletions
--- a/crates/ksp-store-postgres-lib/unit_tests/raw_transaction.rs
+++ b/crates/ksp-store-postgres-lib/unit_tests/raw_transaction.rs
@@ -0,0 +1,183 @@
+// file: crates/ksp-store-postgres-lib/unit_tests/raw_transaction.rs
+// version: 1
+
+fn network() -> ksp_store_api::RawNetworkId {
+    return match ksp_store_api::RawNetworkId::new("devnet") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid test network rejected: {error:?}"),
+    };
+}
+
+fn transaction_row(state: &str) -> super::RawTransactionDbRow {
+    return super::RawTransactionDbRow {
+        archive_payload: std::option::Option::None,
+        block_time_unix_millis: std::option::Option::Some(1_700_000_000_000),
+        content_hash: vec![7; 32],
+        format_id: "ksp.raw.transaction".to_owned(),
+        format_version: i64::from(u32::MAX),
+        payload: std::option::Option::Some(vec![1, 2, 3, 4]),
+        retention_state: state.to_owned(),
+        signature: vec![9; 64],
+        slot_text: u64::MAX.to_string(),
+    };
+}
+
+#[test]
+fn pre_004_full_and_archived_rows_round_trip_without_integer_narrowing() {
+    let network = network();
+    let full = super::decode_raw_transaction_row(&network, transaction_row("full"));
+    let full = match full {
+        std::result::Result::Ok(std::option::Option::Some(value)) => value,
+        other => panic!("valid full row rejected: {other:?}"),
+    };
+    assert_eq!(full.slot(), u64::MAX);
+    assert_eq!(full.block_time().map(|value| return value.unix_millis()), std::option::Option::Some(1_700_000_000_000));
+    assert_eq!(full.payload().format_version(), u32::MAX);
+    assert_eq!(full.payload().bytes(), &[1, 2, 3, 4]);
+    assert_eq!(full.reference().network().as_str(), "devnet");
+    assert_eq!(full.reference().signature().as_bytes(), &[9; 64]);
+    let mut archived_row = transaction_row("archived");
+    archived_row.payload = std::option::Option::None;
+    archived_row.archive_payload = std::option::Option::Some(vec![5, 6, 7]);
+    let archived = super::decode_raw_transaction_row(&network, archived_row);
+    let archived = match archived {
+        std::result::Result::Ok(std::option::Option::Some(value)) => value,
+        other => panic!("valid archived row rejected: {other:?}"),
+    };
+    assert_eq!(archived.slot(), u64::MAX);
+    assert_eq!(archived.payload().bytes(), &[5, 6, 7]);
+    return;
+}
+
+#[test]
+fn pre_004_purged_get_returns_none_and_rejects_payload_or_block_time_residue() {
+    let network = network();
+    let mut purged_row = transaction_row("purged");
+    purged_row.payload = std::option::Option::None;
+    purged_row.archive_payload = std::option::Option::None;
+    purged_row.block_time_unix_millis = std::option::Option::None;
+    let purged = super::decode_raw_transaction_row(&network, purged_row);
+    assert!(matches!(purged, std::result::Result::Ok(std::option::Option::None)));
+    let mut malformed = transaction_row("purged");
+    malformed.archive_payload = std::option::Option::None;
+    malformed.block_time_unix_millis = std::option::Option::None;
+    let malformed = super::decode_raw_transaction_row(&network, malformed);
+    assert_eq!(malformed.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
+    return;
+}
+
+#[test]
+fn pre_004_observation_row_reconstructs_complete_safe_provenance() {
+    let network = network();
+    let row = super::RawObservationDbRow {
+        acquisition_method: "transactionSubscribe".to_owned(),
+        capture_session_id: std::option::Option::Some("capture-1".to_owned()),
+        commitment: std::option::Option::Some("confirmed".to_owned()),
+        endpoint_id: std::option::Option::Some("publicnode-devnet".to_owned()),
+        filter_id: std::option::Option::Some("filter-1".to_owned()),
+        observation_key: vec![3; 32],
+        observed_at_unix_millis: std::option::Option::Some(1_699_999_999_000),
+        origin: "live".to_owned(),
+        protocol: "solana-ws".to_owned(),
+        provider: "publicnode".to_owned(),
+        received_at_unix_millis: 1_700_000_000_000,
+        source_payload_hash: std::option::Option::Some(vec![4; 32]),
+        source_payload_size_bytes: std::option::Option::Some(64 * 1024 * 1024),
+        transaction_signature: vec![8; 64],
+    };
+    let decoded = super::decode_raw_observation_row(&network, row);
+    let decoded = match decoded {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid observation row rejected: {error:?}"),
+    };
+    assert_eq!(decoded.observation_key().as_bytes(), &[3; 32]);
+    assert_eq!(decoded.transaction().network().as_str(), "devnet");
+    assert_eq!(decoded.transaction().signature().as_bytes(), &[8; 64]);
+    assert_eq!(decoded.provenance().provider().as_str(), "publicnode");
+    assert_eq!(decoded.provenance().protocol().as_str(), "solana-ws");
+    assert_eq!(decoded.provenance().acquisition_method().as_str(), "transactionSubscribe");
+    assert_eq!(decoded.provenance().capture_session_id().map(|value| return value.as_str()), std::option::Option::Some("capture-1"));
+    assert_eq!(decoded.provenance().commitment().map(|value| return value.as_str()), std::option::Option::Some("confirmed"));
+    assert_eq!(decoded.provenance().endpoint_id().map(|value| return value.as_str()), std::option::Option::Some("publicnode-devnet"));
+    assert_eq!(decoded.provenance().filter_id().map(|value| return value.as_str()), std::option::Option::Some("filter-1"));
+    assert_eq!(decoded.provenance().observed_at().map(|value| return value.unix_millis()), std::option::Option::Some(1_699_999_999_000));
+    assert_eq!(decoded.provenance().received_at().unix_millis(), 1_700_000_000_000);
+    assert_eq!(decoded.provenance().source_payload_hash().map(|value| return *value.as_bytes()), std::option::Option::Some([4; 32]));
+    assert_eq!(decoded.provenance().source_payload_size_bytes(), std::option::Option::Some(64 * 1024 * 1024));
+    return;
+}
+
+#[test]
+fn pre_004_hostile_rows_map_to_static_data_invalid_without_echoing_values() {
+    let network = network();
+    let mut oversized_slot = transaction_row("full");
+    oversized_slot.slot_text = "18446744073709551616".to_owned();
+    let slot_error = super::decode_raw_transaction_row(&network, oversized_slot).err();
+    assert_eq!(slot_error.as_ref().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
+    assert_eq!(slot_error.as_ref().map(|value| return value.phase()), std::option::Option::Some("raw_transaction_slot"));
+    let mut bad_hash = transaction_row("full");
+    bad_hash.content_hash = vec![1; 31];
+    let hash_error = super::decode_raw_transaction_row(&network, bad_hash).err();
+    assert_eq!(hash_error.as_ref().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
+    assert!(!format!("{hash_error:?}").contains("18446744073709551616"));
+    let bad_origin = super::decode_origin("https://hostile.invalid/secret");
+    let origin_error = bad_origin.err();
+    assert_eq!(origin_error.as_ref().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
+    assert!(!format!("{origin_error:?}").contains("hostile.invalid"));
+    return;
+}
+
+#[test]
+fn pre_004_retention_and_tombstone_decoding_is_exact() {
+    assert!(matches!(super::decode_retention_state("full"), std::result::Result::Ok(ksp_store_api::RawRetentionState::Full)));
+    assert!(matches!(super::decode_retention_state("archived"), std::result::Result::Ok(ksp_store_api::RawRetentionState::Archived)));
+    assert!(matches!(super::decode_retention_state("purged"), std::result::Result::Ok(ksp_store_api::RawRetentionState::Purged)));
+    assert_eq!(
+        super::decode_retention_state("compacted").err().map(|value| return value.kind()),
+        std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid),
+    );
+    let network = network();
+    let row = super::RawTombstoneDbRow {
+        block_time_unix_millis: std::option::Option::None,
+        content_hash: vec![6; 32],
+        format_id: "ksp.raw.transaction".to_owned(),
+        format_version: i64::from(u32::MAX),
+        retention_state: "purged".to_owned(),
+        signature: vec![2; 64],
+        slot_text: u64::MAX.to_string(),
+    };
+    let tombstone = super::decode_raw_tombstone_row(&network, row);
+    let tombstone = match tombstone {
+        std::result::Result::Ok(std::option::Option::Some(value)) => value,
+        other => panic!("valid tombstone row rejected: {other:?}"),
+    };
+    assert_eq!(tombstone.slot(), u64::MAX);
+    assert_eq!(tombstone.format_version(), u32::MAX);
+    assert_eq!(tombstone.content_hash().as_bytes(), &[6; 32]);
+    assert_eq!(tombstone.reference().signature().as_bytes(), &[2; 64]);
+    let malformed = super::RawTombstoneDbRow {
+        block_time_unix_millis: std::option::Option::Some(1),
+        content_hash: vec![6; 32],
+        format_id: "ksp.raw.transaction".to_owned(),
+        format_version: 1,
+        retention_state: "purged".to_owned(),
+        signature: vec![2; 64],
+        slot_text: "1".to_owned(),
+    };
+    let malformed = super::decode_raw_tombstone_row(&network, malformed);
+    assert_eq!(malformed.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::DataInvalid));
+    return;
+}
+
+#[test]
+fn pre_004_wrong_network_is_rejected_by_the_private_pre_io_guard() {
+    let backend_network = network();
+    let other_network = match ksp_store_api::RawNetworkId::new("mainnet-beta") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid alternate network rejected: {error:?}"),
+    };
+    let reference = ksp_store_api::RawTransactionReference::new(other_network, ksp_store_api::RawTransactionSignature::new([1; 64]));
+    let rejected = super::ensure_network(&backend_network, &reference, "test_network");
+    assert_eq!(rejected.err().map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::WrongNetwork));
+    return;
+}