support compare floats with tolerence, some code stole from davidpdrsn#34

Author: B-2U

Cargo.toml

@@ -16,6 +16,7 @@ documentation = "https://docs.rs/json-diff"
 edition = "2018"
 
 [dependencies]
+float-cmp = "0.10.0"
 serde_json = "1"
 serde = "1"
 

src/diff.rs

@@ -1,5 +1,6 @@
 use crate::core_ext::{Indent, Indexes};
 use crate::{CompareMode, Config, NumericMode};
+use float_cmp::{ApproxEq, FloatMargin};
 use serde_json::Value;
 use std::{collections::HashSet, fmt};
 
@@ -58,6 +59,12 @@ impl<'a, 'b> DiffFolder<'a, 'b> {
         let is_equal = match self.config.numeric_mode {
             NumericMode::Strict => self.rhs == lhs,
             NumericMode::AssumeFloat => self.rhs.as_f64() == lhs.as_f64(),
+            NumericMode::AssumeFloatEpsilon(epsilon) => match (lhs.as_f64(), self.rhs.as_f64()) {
+                (Some(lhs_f64), Some(rhs_f64)) => {
+                    lhs_f64.approx_eq(rhs_f64, float_cmp::F64Margin::default().epsilon(epsilon))
+                }
+                _ => false,
+            },
         };
         if !is_equal {
             self.acc.push(Difference {
@@ -582,6 +589,27 @@ mod test {
 
         let json = json!({ "a": 1 });
         let diffs = diff(&json, &json, Config::new(CompareMode::Strict));
-        assert_eq!(diffs, vec![]);
+        assert_eq!(diffs.len(), 0);
+    }
+
+    #[test]
+    fn test_floats_epsilon() {
+        let actual = json!(1.15);
+        let expected = json!(1);
+        let diffs = diff(
+            &actual,
+            &expected,
+            Config::new(CompareMode::Inclusive).numeric_mode(NumericMode::AssumeFloatEpsilon(0.2)),
+        );
+        assert_eq!(diffs.len(), 0);
+
+        let actual = json!(1.25);
+        let expected = json!(1);
+        let diffs = diff(
+            &actual,
+            &expected,
+            Config::new(CompareMode::Inclusive).numeric_mode(NumericMode::AssumeFloatEpsilon(0.2)),
+        );
+        assert_eq!(diffs.len(), 1);
     }
 }

src/lib.rs

@@ -342,7 +342,7 @@ where
 }
 
 /// Configuration for how JSON values should be compared.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 #[allow(missing_copy_implementations)]
 pub struct Config {
     pub(crate) compare_mode: CompareMode,
@@ -390,12 +390,15 @@ pub enum CompareMode {
 }
 
 /// How should numbers be compared.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub enum NumericMode {
     /// Different numeric types aren't considered equal.
     Strict,
     /// All numeric types are converted to float before comparison.
     AssumeFloat,
+
+    /// All numeric types are converted to integer before comparison, floats are considered equal if they differ by at most this epsilon value.
+    AssumeFloatEpsilon(f64),
 }
 
 #[cfg(test)]

tests/integration_test.rs

@@ -182,3 +182,79 @@ fn eq_with_serializable_ref() {
         &user,
     );
 }
+
+#[derive(Serialize)]
+struct Person {
+    name: String,
+    height: f64,
+}
+
+#[test]
+fn can_pass_with_exact_float_comparison() {
+    let person = Person {
+        name: "bob".to_string(),
+        height: 1.79,
+    };
+
+    assert_json_matches!(
+        &json!({
+            "name": "bob",
+            "height": 1.79
+        }),
+        &person,
+        Config::new(CompareMode::Strict).numeric_mode(NumericMode::AssumeFloat)
+    );
+}
+
+#[test]
+#[should_panic]
+fn can_fail_with_exact_float_comparison() {
+    let person = Person {
+        name: "bob".to_string(),
+        height: 1.79,
+    };
+
+    assert_json_matches!(
+        &json!({
+            "name": "bob",
+            "height": 1.7900001
+        }),
+        &person,
+        Config::new(CompareMode::Strict).numeric_mode(NumericMode::AssumeFloat)
+    );
+}
+
+#[test]
+fn can_pass_with_epsilon_based_float_comparison() {
+    let person = Person {
+        name: "bob".to_string(),
+        height: 1.79,
+    };
+
+    assert_json_matches!(
+        &json!({
+            "name": "bob",
+            "height": 1.7900001
+        }),
+        &person,
+        Config::new(CompareMode::Strict).numeric_mode(NumericMode::AssumeFloatEpsilon(0.00001))
+    );
+}
+
+#[test]
+#[should_panic]
+fn can_fail_with_epsilon_based_float_comparison() {
+    let person = Person {
+        name: "bob".to_string(),
+        height: 1.79,
+    };
+
+    assert_json_matches!(
+        &json!({
+            "name": "bob",
+            "height": 1.7901
+        }),
+        &person,
+        Config::new(CompareMode::Strict).numeric_mode(NumericMode::AssumeFloatEpsilon(0.00001))
+    );
+}