Add some core lightweight tests

Author: Quantumplation

src/broadcast/destination.rs

@@ -7,7 +7,7 @@ use aws_sdk_kinesis::{types::ShardIteratorType, Client as KinesisClient};
 use bytes::Bytes;
 use hex::ToHex;
 use serde::{ser::SerializeSeq, Deserialize, Deserializer, Serialize, Serializer};
-use tracing::{info, trace, warn};
+use tracing::{info, warn};
 use utxorpc::spec::sync::BlockRef;
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -262,3 +262,94 @@ where
             .collect()
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_point_to_string() {
+        let point = BlockRef {
+            index: 12345,
+            hash: bytes::Bytes::from(vec![0xde, 0xad, 0xbe, 0xef]),
+        };
+        let result = point_to_string(&point);
+        assert_eq!(result, "12345/deadbeef");
+    }
+
+    #[test]
+    fn test_string_to_point() {
+        let input = "12345/deadbeef".to_string();
+        let result = string_to_point(input).unwrap();
+        assert_eq!(result.index, 12345);
+        assert_eq!(result.hash, bytes::Bytes::from(vec![0xde, 0xad, 0xbe, 0xef]));
+    }
+
+    #[test]
+    fn test_point_roundtrip() {
+        let original = BlockRef {
+            index: 98765,
+            hash: bytes::Bytes::from(vec![
+                0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
+            ]),
+        };
+        let serialized = point_to_string(&original);
+        let deserialized = string_to_point(serialized).unwrap();
+        assert_eq!(original.index, deserialized.index);
+        assert_eq!(original.hash, deserialized.hash);
+    }
+
+    #[test]
+    fn test_string_to_point_invalid_format() {
+        let result = string_to_point("invalid".to_string());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_string_to_point_invalid_hex() {
+        let result = string_to_point("12345/notvalidhex".to_string());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_string_to_point_invalid_index() {
+        let result = string_to_point("notanumber/deadbeef".to_string());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_destination_serde_roundtrip() {
+        let dest = Destination {
+            pk: "test-dest".to_string(),
+            stream_arn: "arn:aws:kinesis:us-east-1:123456789:stream/test".to_string(),
+            shard_id: "shard-0".to_string(),
+            filter: None,
+            sequence_number: Some("12345".to_string()),
+            last_seen_point: BlockRef {
+                index: 100,
+                hash: bytes::Bytes::from(vec![0xaa, 0xbb, 0xcc, 0xdd]),
+            },
+            recovery_points: vec![
+                BlockRef {
+                    index: 90,
+                    hash: bytes::Bytes::from(vec![0x11, 0x22, 0x33, 0x44]),
+                },
+                BlockRef {
+                    index: 95,
+                    hash: bytes::Bytes::from(vec![0x55, 0x66, 0x77, 0x88]),
+                },
+            ],
+            enabled: true,
+            skip_repair: false,
+        };
+
+        let json = serde_json::to_string(&dest).unwrap();
+        let deserialized: Destination = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(dest.pk, deserialized.pk);
+        assert_eq!(dest.last_seen_point.index, deserialized.last_seen_point.index);
+        assert_eq!(dest.last_seen_point.hash, deserialized.last_seen_point.hash);
+        assert_eq!(dest.recovery_points.len(), deserialized.recovery_points.len());
+        assert_eq!(dest.recovery_points[0].index, deserialized.recovery_points[0].index);
+    }
+}

src/broadcast/filter.rs

@@ -126,3 +126,253 @@ impl FilterConfig {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_token_filter_policy_match() {
+        let policy_id = vec![0x01, 0x02, 0x03];
+        let filter = TokenFilter::Policy { policy: policy_id.clone() };
+
+        let assets = vec![
+            Multiasset {
+                policy_id: policy_id.clone().into(),
+                assets: vec![],
+                redeemer: None,
+            }
+        ];
+
+        assert!(filter.applies(&assets));
+    }
+
+    #[test]
+    fn test_token_filter_policy_no_match() {
+        let filter = TokenFilter::Policy { policy: vec![0x01, 0x02, 0x03] };
+
+        let assets = vec![
+            Multiasset {
+                policy_id: vec![0xff, 0xee, 0xdd].into(),
+                assets: vec![],
+                redeemer: None,
+            }
+        ];
+
+        assert!(!filter.applies(&assets));
+    }
+
+    #[test]
+    fn test_token_filter_asset_id_match() {
+        let policy_id = vec![0x01, 0x02, 0x03];
+        let asset_name = vec![0x04, 0x05];
+        let filter = TokenFilter::AssetId {
+            policy: policy_id.clone(),
+            asset_name: asset_name.clone(),
+        };
+
+        let assets = vec![
+            Multiasset {
+                policy_id: policy_id.clone().into(),
+                assets: vec![
+                    utxorpc::spec::cardano::Asset {
+                        name: asset_name.clone().into(),
+                        output_coin: 100,
+                        mint_coin: 0,
+                    }
+                ],
+                redeemer: None,
+            }
+        ];
+
+        assert!(filter.applies(&assets));
+    }
+
+    #[test]
+    fn test_token_filter_asset_id_wrong_policy() {
+        let filter = TokenFilter::AssetId {
+            policy: vec![0x01, 0x02, 0x03],
+            asset_name: vec![0x04, 0x05],
+        };
+
+        let assets = vec![
+            Multiasset {
+                policy_id: vec![0xff, 0xee, 0xdd].into(),
+                assets: vec![
+                    utxorpc::spec::cardano::Asset {
+                        name: vec![0x04, 0x05].into(),
+                        output_coin: 100,
+                        mint_coin: 0,
+                    }
+                ],
+                redeemer: None,
+            }
+        ];
+
+        assert!(!filter.applies(&assets));
+    }
+
+    #[test]
+    fn test_token_filter_asset_id_wrong_name() {
+        let policy_id = vec![0x01, 0x02, 0x03];
+        let filter = TokenFilter::AssetId {
+            policy: policy_id.clone(),
+            asset_name: vec![0x04, 0x05],
+        };
+
+        let assets = vec![
+            Multiasset {
+                policy_id: policy_id.clone().into(),
+                assets: vec![
+                    utxorpc::spec::cardano::Asset {
+                        name: vec![0xff, 0xee].into(),
+                        output_coin: 100,
+                        mint_coin: 0,
+                    }
+                ],
+                redeemer: None,
+            }
+        ];
+
+        assert!(!filter.applies(&assets));
+    }
+
+    #[test]
+    fn test_token_filter_empty_assets() {
+        let filter = TokenFilter::Policy { policy: vec![0x01, 0x02, 0x03] };
+        assert!(!filter.applies(&[]));
+    }
+
+    #[test]
+    fn test_filter_config_all_match() {
+        let policy1 = vec![0x01, 0x02, 0x03];
+        let policy2 = vec![0x04, 0x05, 0x06];
+
+        let filter = FilterConfig::All(vec![
+            Box::new(FilterConfig::Mint(TokenFilter::Policy { policy: policy1.clone() })),
+            Box::new(FilterConfig::Mint(TokenFilter::Policy { policy: policy2.clone() })),
+        ]);
+
+        let tx = Tx {
+            mint: vec![
+                Multiasset { policy_id: policy1.into(), assets: vec![], redeemer: None },
+                Multiasset { policy_id: policy2.into(), assets: vec![], redeemer: None },
+            ],
+            ..Default::default()
+        };
+
+        assert!(filter.applies(&tx));
+    }
+
+    #[test]
+    fn test_filter_config_all_no_match() {
+        let policy1 = vec![0x01, 0x02, 0x03];
+        let policy2 = vec![0x04, 0x05, 0x06];
+
+        let filter = FilterConfig::All(vec![
+            Box::new(FilterConfig::Mint(TokenFilter::Policy { policy: policy1.clone() })),
+            Box::new(FilterConfig::Mint(TokenFilter::Policy { policy: policy2.clone() })),
+        ]);
+
+        // Only has policy1, missing policy2
+        let tx = Tx {
+            mint: vec![
+                Multiasset { policy_id: policy1.into(), assets: vec![], redeemer: None },
+            ],
+            ..Default::default()
+        };
+
+        assert!(!filter.applies(&tx));
+    }
+
+    #[test]
+    fn test_filter_config_any_match() {
+        let policy1 = vec![0x01, 0x02, 0x03];
+        let policy2 = vec![0x04, 0x05, 0x06];
+
+        let filter = FilterConfig::Any(vec![
+            Box::new(FilterConfig::Mint(TokenFilter::Policy { policy: policy1.clone() })),
+            Box::new(FilterConfig::Mint(TokenFilter::Policy { policy: policy2 })),
+        ]);
+
+        // Only has policy1, but that's enough for Any
+        let tx = Tx {
+            mint: vec![
+                Multiasset { policy_id: policy1.into(), assets: vec![], redeemer: None },
+            ],
+            ..Default::default()
+        };
+
+        assert!(filter.applies(&tx));
+    }
+
+    #[test]
+    fn test_filter_config_any_no_match() {
+        let filter = FilterConfig::Any(vec![
+            Box::new(FilterConfig::Mint(TokenFilter::Policy { policy: vec![0x01, 0x02, 0x03] })),
+            Box::new(FilterConfig::Mint(TokenFilter::Policy { policy: vec![0x04, 0x05, 0x06] })),
+        ]);
+
+        // Has neither policy
+        let tx = Tx {
+            mint: vec![
+                Multiasset { policy_id: vec![0xff, 0xee, 0xdd].into(), assets: vec![], redeemer: None },
+            ],
+            ..Default::default()
+        };
+
+        assert!(!filter.applies(&tx));
+    }
+
+    #[test]
+    fn test_filter_config_mint() {
+        let policy_id = vec![0xaa, 0xbb, 0xcc];
+        let filter = FilterConfig::Mint(TokenFilter::Policy { policy: policy_id.clone() });
+
+        let tx = Tx {
+            mint: vec![
+                Multiasset { policy_id: policy_id.into(), assets: vec![], redeemer: None },
+            ],
+            ..Default::default()
+        };
+
+        assert!(filter.applies(&tx));
+    }
+
+    #[test]
+    fn test_filter_config_withdraw() {
+        let credential = vec![0x11, 0x22, 0x33];
+        let filter = FilterConfig::Withdraw { credential: credential.clone() };
+
+        let tx = Tx {
+            withdrawals: vec![
+                utxorpc::spec::cardano::Withdrawal {
+                    reward_account: credential.into(),
+                    coin: 1000,
+                    redeemer: None,
+                }
+            ],
+            ..Default::default()
+        };
+
+        assert!(filter.applies(&tx));
+    }
+
+    #[test]
+    fn test_filter_config_withdraw_no_match() {
+        let filter = FilterConfig::Withdraw { credential: vec![0x11, 0x22, 0x33] };
+
+        let tx = Tx {
+            withdrawals: vec![
+                utxorpc::spec::cardano::Withdrawal {
+                    reward_account: vec![0xff, 0xee, 0xdd].into(),
+                    coin: 1000,
+                    redeemer: None,
+                }
+            ],
+            ..Default::default()
+        };
+
+        assert!(!filter.applies(&tx));
+    }
+}