v0.3.4-pre.005

crates/ksp-store-postgres-lib/unit_tests/raw_account.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/unit_tests/raw_account.rs
-// version: 1
+// version: 2
 
 fn network() -> ksp_store_api::RawNetworkId {
     return match ksp_store_api::RawNetworkId::new("devnet") {
@@ -219,3 +219,106 @@ fn pre_004_account_wrong_network_guard_is_pre_io_and_static() {
     assert_eq!(error.phase(), "raw_account_state_network");
     return;
 }
+
+#[test]
+fn pre_005_account_acquisition_input_guard_requires_network_and_exact_reference() {
+    let backend = network();
+    let valid_state = match super::decode_raw_account_state_row(&backend, state_row()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid account state rejected: {error:?}"),
+    };
+    let valid_observation = match super::decode_raw_account_observation_row(&backend, observation_row()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid account observation rejected: {error:?}"),
+    };
+    assert!(super::ensure_acquisition_inputs(&backend, &valid_state, &valid_observation).is_ok());
+    let foreign = match ksp_store_api::RawNetworkId::new("mainnet-beta") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid foreign network rejected: {error:?}"),
+    };
+    let foreign_state = match super::decode_raw_account_state_row(&foreign, state_row()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid foreign account state rejected: {error:?}"),
+    };
+    let foreign_observation = match super::decode_raw_account_observation_row(&foreign, observation_row()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid foreign account observation rejected: {error:?}"),
+    };
+    let error = super::ensure_acquisition_inputs(&backend, &foreign_state, &foreign_observation).err();
+    assert_eq!(error.map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::WrongNetwork));
+    let mut mismatched_row = observation_row();
+    mismatched_row.account_state_hash = vec![9; 32];
+    let mismatched_observation = match super::decode_raw_account_observation_row(&backend, mismatched_row) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid mismatched observation model rejected: {error:?}"),
+    };
+    let error = super::ensure_acquisition_inputs(&backend, &valid_state, &mismatched_observation).err();
+    assert_eq!(error.map(|value| return value.kind()), std::option::Option::Some(crate::PostgresBackendErrorKind::Conflict));
+    return;
+}
+
+#[test]
+fn pre_005_account_state_idempotence_compares_complete_content_not_state_hash_only() {
+    let backend = network();
+    let first = match super::decode_raw_account_state_row(&backend, state_row()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid account state rejected: {error:?}"),
+    };
+    let identical = match super::decode_raw_account_state_row(&backend, state_row()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid identical account state rejected: {error:?}"),
+    };
+    assert!(super::raw_account_states_equal(&first, &identical));
+    let mut divergent_row = state_row();
+    divergent_row.lamports_text = (u64::MAX - 1).to_string();
+    let divergent = match super::decode_raw_account_state_row(&backend, divergent_row) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid divergent account state rejected: {error:?}"),
+    };
+    assert_eq!(first.reference(), divergent.reference());
+    assert!(!super::raw_account_states_equal(&first, &divergent));
+    return;
+}
+
+#[test]
+fn pre_005_account_observation_idempotence_compares_optional_metadata_exactly() {
+    let backend = network();
+    let first = match super::decode_raw_account_observation_row(&backend, observation_row()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid account observation rejected: {error:?}"),
+    };
+    let identical = match super::decode_raw_account_observation_row(&backend, observation_row()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid identical account observation rejected: {error:?}"),
+    };
+    assert_eq!(first, identical);
+    let mut divergent_row = observation_row();
+    divergent_row.write_version_text = std::option::Option::Some((u64::MAX - 1).to_string());
+    let divergent = match super::decode_raw_account_observation_row(&backend, divergent_row) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => panic!("valid divergent account observation rejected: {error:?}"),
+    };
+    assert_eq!(first.observation_key(), divergent.observation_key());
+    assert_eq!(first.account(), divergent.account());
+    assert_ne!(first, divergent);
+    return;
+}
+
+#[test]
+fn pre_005_account_origin_encoding_is_exact_and_static() {
+    let cases = [
+        (ksp_store_api::RawAcquisitionOrigin::Backfill, "backfill"),
+        (ksp_store_api::RawAcquisitionOrigin::Import, "import"),
+        (ksp_store_api::RawAcquisitionOrigin::Live, "live"),
+        (ksp_store_api::RawAcquisitionOrigin::Repair, "repair"),
+        (ksp_store_api::RawAcquisitionOrigin::Replay, "replay"),
+    ];
+    for (origin, expected) in cases {
+        let encoded = match super::encode_origin(origin) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => panic!("valid account origin rejected: {error:?}"),
+        };
+        assert_eq!(encoded, expected);
+    }
+    return;
+}