Accept any T: Serialize rather than just serde_json::Value

Author: davidpdrsn

CHANGELOG.md

@@ -6,7 +6,7 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 
 ## Unreleased
 
-None.
+- All methods now accept any `T: Serialize` rather than just `serde_json::Value`.
 
 ### Breaking changes
 

Cargo.toml

@@ -19,6 +19,7 @@ extend = "0.1.0"
 
 [dev-dependencies]
 version-sync = "0.8"
+serde = { version = "1.0.80", features = ["derive"] }
 
 [badges]
 travis-ci = { repository = "davidpdrsn/assert-json-diff", branch = "master" }

src/diff.rs

@@ -51,7 +51,7 @@ macro_rules! direct_compare {
                 });
             }
         }
-    }
+    };
 }
 
 impl<'a, 'b> Folder<'a> for DiffFolder<'a, 'b> {
@@ -323,6 +323,7 @@ trait Folder<'a> {
 mod test {
     #[allow(unused_imports)]
     use super::*;
+    use serde_json::json;
 
     #[test]
     fn test_diffing_leaf_json() {

src/lib.rs

@@ -1,11 +1,12 @@
-//! This crate includes macros for comparing two JSON values. It is designed to give much
-//! more helpful error messages than the standard [`assert_eq!`]. It basically does a diff of the
-//! two objects and tells you the exact differences. This is useful when asserting that two large
-//! JSON objects are the same.
+//! This crate includes macros for comparing two serializable values by diffing their JSON
+//! representations. It is designed to give much more helpful error messages than the standard
+//! [`assert_eq!`]. It basically does a diff of the two objects and tells you the exact
+//! differences. This is useful when asserting that two large JSON objects are the same.
 //!
-//! It uses the [`serde_json::Value`] type to represent JSON.
+//! It uses the [serde] and [serde_json] to perform the serialization.
 //!
-//! [`serde_json::Value`]: https://docs.serde.rs/serde_json/value/enum.Value.html
+//! [serde]: https://crates.io/crates/serde
+//! [serde_json]: https://crates.io/crates/serde_json
 //! [`assert_eq!`]: https://doc.rust-lang.org/std/macro.assert_eq.html
 //!
 //! ## Partial matching
@@ -14,10 +15,8 @@
 //! [`assert_json_include`](macro.assert_json_include.html):
 //!
 //! ```should_panic
-//! #[macro_use]
-//! extern crate assert_json_diff;
-//! #[macro_use]
-//! extern crate serde_json;
+//! use assert_json_diff::assert_json_include;
+//! use serde_json::json;
 //!
 //! fn main() {
 //!     let a = json!({
@@ -82,10 +81,8 @@
 //! of the JSON without having to specify the whole thing. For example this test passes:
 //!
 //! ```
-//! #[macro_use]
-//! extern crate assert_json_diff;
-//! #[macro_use]
-//! extern crate serde_json;
+//! use assert_json_diff::assert_json_include;
+//! use serde_json::json;
 //!
 //! fn main() {
 //!     assert_json_include!(
@@ -102,10 +99,8 @@
 //! However `expected` cannot contain additional data so this test fails:
 //!
 //! ```should_panic
-//! #[macro_use]
-//! extern crate assert_json_diff;
-//! #[macro_use]
-//! extern crate serde_json;
+//! use assert_json_diff::assert_json_include;
+//! use serde_json::json;
 //!
 //! fn main() {
 //!     assert_json_include!(
@@ -130,10 +125,8 @@
 //! If you want to ensure two JSON values are *exactly* the same, use [`assert_json_eq`](macro.assert_json_eq.html).
 //!
 //! ```rust,should_panic
-//! #[macro_use]
-//! extern crate assert_json_diff;
-//! #[macro_use]
-//! extern crate serde_json;
+//! use assert_json_diff::assert_json_eq;
+//! use serde_json::json;
 //!
 //! fn main() {
 //!     assert_json_eq!(
@@ -164,13 +157,8 @@
 )]
 #![doc(html_root_url = "https://docs.rs/assert-json-diff/1.0.3")]
 
-extern crate serde;
-#[allow(unused_imports)]
-#[macro_use]
-extern crate serde_json;
-
 use diff::{diff, Mode};
-use serde_json::Value;
+use serde::Serialize;
 
 mod core_ext;
 mod diff;
@@ -184,8 +172,8 @@ mod diff;
 #[macro_export]
 macro_rules! assert_json_include {
     (actual: $actual:expr, expected: $expected:expr) => {{
-        let actual: serde_json::Value = $actual;
-        let expected: serde_json::Value = $expected;
+        let actual = $actual;
+        let expected = $expected;
         if let Err(error) = $crate::assert_json_include_no_panic(&actual, &expected) {
             panic!("\n\n{}\n\n", error);
         }
@@ -209,8 +197,8 @@ macro_rules! assert_json_include {
 #[macro_export]
 macro_rules! assert_json_eq {
     ($lhs:expr, $rhs:expr) => {{
-        let lhs: serde_json::Value = $lhs;
-        let rhs: serde_json::Value = $rhs;
+        let lhs = $lhs;
+        let rhs = $rhs;
         if let Err(error) = $crate::assert_json_eq_no_panic(&lhs, &rhs) {
             panic!("\n\n{}\n\n", error);
         }
@@ -225,7 +213,14 @@ macro_rules! assert_json_eq {
 /// Instead it returns a `Result` where the error is the message that would be passed to `panic!`.
 /// This is might be useful if you want to control how failures are reported and don't want to deal
 /// with panics.
-pub fn assert_json_include_no_panic(actual: &Value, expected: &Value) -> Result<(), String> {
+pub fn assert_json_include_no_panic<Actual, Expected>(
+    actual: &Actual,
+    expected: &Expected,
+) -> Result<(), String>
+where
+    Actual: Serialize,
+    Expected: Serialize,
+{
     assert_json_no_panic(actual, expected, Mode::Lenient)
 }
 
@@ -234,12 +229,33 @@ pub fn assert_json_include_no_panic(actual: &Value, expected: &Value) -> Result<
 /// Instead it returns a `Result` where the error is the message that would be passed to `panic!`.
 /// This is might be useful if you want to control how failures are reported and don't want to deal
 /// with panics.
-pub fn assert_json_eq_no_panic(lhs: &Value, rhs: &Value) -> Result<(), String> {
+pub fn assert_json_eq_no_panic<Lhs, Rhs>(lhs: &Lhs, rhs: &Rhs) -> Result<(), String>
+where
+    Lhs: Serialize,
+    Rhs: Serialize,
+{
     assert_json_no_panic(lhs, rhs, Mode::Strict)
 }
 
-fn assert_json_no_panic(lhs: &Value, rhs: &Value, mode: Mode) -> Result<(), String> {
-    let diffs = diff(lhs, rhs, mode);
+fn assert_json_no_panic<Lhs, Rhs>(lhs: &Lhs, rhs: &Rhs, mode: Mode) -> Result<(), String>
+where
+    Lhs: Serialize,
+    Rhs: Serialize,
+{
+    let lhs = serde_json::to_value(lhs).unwrap_or_else(|err| {
+        panic!(
+            "Couldn't convert left hand side value to JSON. Serde error: {}",
+            err
+        )
+    });
+    let rhs = serde_json::to_value(rhs).unwrap_or_else(|err| {
+        panic!(
+            "Couldn't convert right hand side value to JSON. Serde error: {}",
+            err
+        )
+    });
+
+    let diffs = diff(&lhs, &rhs, mode);
 
     if diffs.is_empty() {
         Ok(())
@@ -256,6 +272,7 @@ fn assert_json_no_panic(lhs: &Value, rhs: &Value, mode: Mode) -> Result<(), Stri
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serde_json::{json, Value};
     use std::fmt::Write;
 
     #[test]

tests/integration_test.rs

@@ -1,9 +1,8 @@
-#[macro_use]
-extern crate assert_json_diff;
-#[macro_use]
-extern crate serde_json;
-
-use assert_json_diff::{assert_json_eq_no_panic, assert_json_include_no_panic};
+use serde::Serialize;
+use assert_json_diff::{
+    assert_json_eq, assert_json_eq_no_panic, assert_json_include, assert_json_include_no_panic,
+};
+use serde_json::json;
 
 #[test]
 fn can_pass() {
@@ -62,3 +61,75 @@ fn exact_match_without_panicing() {
 
     assert!(assert_json_eq_no_panic(&json!([1, 2, 3]), &json!("foo")).is_err());
 }
+
+#[derive(Serialize)]
+struct User {
+    id: i32,
+    username: String
+}
+
+#[test]
+fn include_with_serializable() {
+    let user = User {
+        id: 1,
+        username: "bob".to_string(),
+    };
+
+    assert_json_include!(
+        actual: json!({
+            "id": 1,
+            "username": "bob",
+            "email": "bob@example.com"
+        }),
+        expected: user,
+    );
+}
+
+#[test]
+fn include_with_serializable_ref() {
+    let user = User {
+        id: 1,
+        username: "bob".to_string(),
+    };
+
+    assert_json_include!(
+        actual: &json!({
+            "id": 1,
+            "username": "bob",
+            "email": "bob@example.com"
+        }),
+        expected: &user,
+    );
+}
+
+#[test]
+fn eq_with_serializable() {
+    let user = User {
+        id: 1,
+        username: "bob".to_string(),
+    };
+
+    assert_json_eq!(
+        json!({
+            "id": 1,
+            "username": "bob"
+        }),
+        user,
+    );
+}
+
+#[test]
+fn eq_with_serializable_ref() {
+    let user = User {
+        id: 1,
+        username: "bob".to_string(),
+    };
+
+    assert_json_eq!(
+        &json!({
+            "id": 1,
+            "username": "bob"
+        }),
+        &user,
+    );
+}