chore: add tests to kill mutations (#1611)

.cargo-mutants.toml

@@ -6,4 +6,7 @@
 exclude_re = [
     "cashu/src/amount.rs.*FeeAndAmounts::fee",
     "cashu/src/amount.rs.*FeeAndAmounts::amounts",
+    # PartialEq implementations are simple delegations to as_str(), well-tested
+    "cashu/src/nuts/nut00/mod.rs.*impl PartialEq<&str> for PaymentMethod",
+    "cashu/src/nuts/nut00/mod.rs.*impl PartialEq<str> for PaymentMethod",
 ]

crates/cashu/src/amount.rs

@@ -2043,4 +2043,85 @@ mod tests {
         assert_eq!(sum, Amount::from(150));
         assert_ne!(sum, Amount::ZERO);
     }
+
+    /// Tests that saturating_sub correctly subtracts amounts without underflow.
+    ///
+    /// This is critical for any saturating subtraction operations. If it returns
+    /// Default::default() (Amount::ZERO) always, or changes the comparison or
+    /// subtraction operation, calculations will be wrong.
+    ///
+    /// Mutant testing: Kills mutations that:
+    /// - Replace saturating_sub with Default::default()
+    /// - Replace > with ==, <, or >= in the comparison
+    /// - Replace - with + or / in the subtraction
+    #[test]
+    fn test_saturating_sub_normal_case() {
+        // Normal subtraction: larger - smaller
+        let amount1 = Amount::from(100);
+        let amount2 = Amount::from(30);
+        let result = amount1.saturating_sub(amount2);
+        assert_eq!(result, Amount::from(70));
+        assert_ne!(result, Amount::ZERO);
+
+        // Another normal case
+        let amount1 = Amount::from(1000);
+        let amount2 = Amount::from(1);
+        let result = amount1.saturating_sub(amount2);
+        assert_eq!(result, Amount::from(999));
+
+        // Edge case: subtraction resulting in 1
+        let amount1 = Amount::from(2);
+        let amount2 = Amount::from(1);
+        let result = amount1.saturating_sub(amount2);
+        assert_eq!(result, Amount::from(1));
+        assert_ne!(result, Amount::ZERO);
+    }
+
+    /// Tests that saturating_sub returns ZERO when subtracting a larger amount.
+    ///
+    /// This catches mutations that change the comparison operator (>, ==, <, >=)
+    /// or that don't return ZERO on underflow.
+    #[test]
+    fn test_saturating_sub_saturates_at_zero() {
+        // Subtracting larger from smaller should return ZERO
+        let amount1 = Amount::from(30);
+        let amount2 = Amount::from(100);
+        let result = amount1.saturating_sub(amount2);
+        assert_eq!(result, Amount::ZERO);
+        assert_ne!(result, Amount::from(30)); // Should not be the original value
+
+        // Another case
+        let amount1 = Amount::from(5);
+        let amount2 = Amount::from(10);
+        let result = amount1.saturating_sub(amount2);
+        assert_eq!(result, Amount::ZERO);
+
+        // Edge case: subtracting from zero
+        let amount1 = Amount::ZERO;
+        let amount2 = Amount::from(1);
+        let result = amount1.saturating_sub(amount2);
+        assert_eq!(result, Amount::ZERO);
+    }
+
+    /// Tests that saturating_sub returns ZERO when amounts are equal.
+    ///
+    /// This is a boundary case that catches comparison operator mutations.
+    #[test]
+    fn test_saturating_sub_equal_amounts() {
+        // Equal amounts should return ZERO (other > self is false when equal)
+        let amount1 = Amount::from(100);
+        let amount2 = Amount::from(100);
+        let result = amount1.saturating_sub(amount2);
+        assert_eq!(result, Amount::ZERO);
+
+        // Another equal case
+        let amount1 = Amount::from(1);
+        let amount2 = Amount::from(1);
+        let result = amount1.saturating_sub(amount2);
+        assert_eq!(result, Amount::ZERO);
+
+        // Edge case: both zero
+        let result = Amount::ZERO.saturating_sub(Amount::ZERO);
+        assert_eq!(result, Amount::ZERO);
+    }
 }

crates/cashu/src/nuts/nut00/mod.rs

@@ -1195,6 +1195,56 @@ mod tests {
         }
     }
 
+    /// Tests that is_bolt12 correctly identifies BOLT12 payment methods.
+    ///
+    /// This is critical for code that needs to distinguish between BOLT11 and BOLT12.
+    /// If is_bolt12 always returns true or false, the wrong payment flow may be used.
+    ///
+    /// Mutant testing: Kills mutations that:
+    /// - Replace is_bolt12 with true
+    /// - Replace is_bolt12 with false
+    #[test]
+    fn test_is_bolt12_with_bolt12() {
+        // BOLT12 should return true
+        let method = PaymentMethod::BOLT12;
+        assert!(method.is_bolt12());
+
+        // Known BOLT12 should also return true
+        let method = PaymentMethod::Known(KnownMethod::Bolt12);
+        assert!(method.is_bolt12());
+    }
+
+    #[test]
+    fn test_is_bolt12_with_non_bolt12() {
+        // BOLT11 should return false
+        let method = PaymentMethod::BOLT11;
+        assert!(!method.is_bolt12());
+
+        // Known BOLT11 should return false
+        let method = PaymentMethod::Known(KnownMethod::Bolt11);
+        assert!(!method.is_bolt12());
+
+        // Custom methods should return false
+        let method = PaymentMethod::Custom("paypal".to_string());
+        assert!(!method.is_bolt12());
+
+        let method = PaymentMethod::Custom("bolt12".to_string());
+        assert!(!method.is_bolt12()); // String match is not the same as actual BOLT12
+    }
+
+    /// Tests that is_bolt12 correctly distinguishes between all payment method variants.
+    #[test]
+    fn test_is_bolt12_comprehensive() {
+        // Test all variants
+        assert!(PaymentMethod::BOLT12.is_bolt12());
+        assert!(PaymentMethod::Known(KnownMethod::Bolt12).is_bolt12());
+
+        assert!(!PaymentMethod::BOLT11.is_bolt12());
+        assert!(!PaymentMethod::Known(KnownMethod::Bolt11).is_bolt12());
+        assert!(!PaymentMethod::Custom("anything".to_string()).is_bolt12());
+        assert!(!PaymentMethod::Custom("bolt12".to_string()).is_bolt12());
+    }
+
     #[test]
     fn test_witness_serialization() {
         let htlc_witness = HTLCWitness {