v0.3.16-pre.002

crates/ksp-store-api/unit_tests/model/raw_transaction.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-api/unit_tests/model/raw_transaction.rs
-// version: 2
+// version: 3
 
 fn network() -> std::option::Option<crate::RawNetworkId> {
     return match crate::RawNetworkId::new("mainnet".to_owned()) {
@@ -83,3 +83,60 @@ fn transaction_observation_is_separate_from_canonical_raw_payload() {
     assert_eq!(observation.provenance().provider().as_str(), "publicnode");
     return;
 }
+
+#[test]
+fn transaction_variant_identity_is_non_zero_and_keeps_transaction_scope() {
+    assert!(crate::RawTransactionVariantId::try_new(0).is_err());
+    let variant_id = match crate::RawTransactionVariantId::try_new(7) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let network = match network() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let transaction = crate::RawTransactionReference::new(network, crate::RawTransactionSignature::new([13_u8; 64]));
+    let variant = crate::RawTransactionVariantReference::new(transaction, variant_id);
+    assert_eq!(variant.variant_id().get(), 7);
+    assert_eq!(variant.transaction().network().as_str(), "mainnet");
+    assert_eq!(crate::RawTransactionVariantOrigin::Native.code(), "native");
+    assert_eq!(crate::RawTransactionVariantOrigin::Synthetic.code(), "synthetic");
+    return;
+}
+
+#[test]
+fn transaction_variant_relation_reason_pairs_are_validated() {
+    let exact = crate::RawTransactionVariantComparison::try_new(
+        crate::RawTransactionVariantRelation::Exact,
+        crate::RawTransactionVariantRelationReason::ExactCanonicalContent,
+    );
+    assert!(exact.is_ok());
+    let invalid = crate::RawTransactionVariantComparison::try_new(
+        crate::RawTransactionVariantRelation::Exact,
+        crate::RawTransactionVariantRelationReason::IncomingLogMessagesTruncated,
+    );
+    assert!(invalid.is_err());
+    let conflict = crate::RawTransactionVariantComparison::try_new(
+        crate::RawTransactionVariantRelation::Conflict,
+        crate::RawTransactionVariantRelationReason::ContentHashCollision,
+    );
+    assert!(conflict.is_ok());
+    let incomparable = crate::RawTransactionVariantComparison::try_new(
+        crate::RawTransactionVariantRelation::Incomparable,
+        crate::RawTransactionVariantRelationReason::PayloadFormatMismatch,
+    );
+    assert!(incomparable.is_ok());
+    return;
+}
+
+#[test]
+fn transaction_variant_codes_and_outcomes_are_stable_backend_neutral_contracts() {
+    assert_eq!(crate::RawTransactionVariantRelation::CompatibleLessComplete.code(), "compatible_less_complete");
+    assert_eq!(crate::RawTransactionVariantRelationReason::IncomingLogMessagesTruncated.code(), "incoming_log_messages_truncated");
+    assert_eq!(crate::RawTransactionVariantRelationReason::ContentHashCollision.code(), "content_hash_collision");
+    assert_eq!(crate::RawTransactionConflictStatus::Open.code(), "open");
+    assert_eq!(crate::RawTransactionConflictStatus::Resolved.code(), "resolved");
+    assert_ne!(crate::RawTransactionVariantWriteOutcome::InsertedCanonical, crate::RawTransactionVariantWriteOutcome::ObservedExact);
+    assert_ne!(crate::RawTransactionVariantWriteOutcome::QuarantinedConflict, crate::RawTransactionVariantWriteOutcome::PromotedCompatibleMoreComplete);
+    return;
+}