Cleanup schemars tests (#862)

Author: jonasbb

serde_with/Cargo.toml

@@ -239,7 +239,7 @@ required-features = ["alloc"]
 
 [[test]]
 name = "schemars_0_8"
-path = "tests/schemars_0_8.rs"
+path = "tests/schemars_0_8/main.rs"
 required-features = ["schemars_0_8"]
 
 [[test]]

serde_with/tests/schemars_0_8.rs renamed to serde_with/tests/schemars_0_8/main.rs

@@ -56,7 +56,8 @@ macro_rules! declare_snapshot_test {
             schema.push('\n');
 
             let filename = concat!("./", module_path!(), "::", stringify!($test), ".json")
-                .replace("::", "/");
+                .replace("::", "/")
+                .replace("schemars_0_8/", "");
 
             let expected = expect_file![filename];
             expected.assert_eq(&schema);
@@ -95,7 +96,7 @@ fn schemars_basic() {
     let mut schema = serde_json::to_string_pretty(&schema).expect("schema could not be serialized");
     schema.push('\n');
 
-    let expected = expect_file!["./schemars_0_8/schemars_basic.json"];
+    let expected = expect_file!["./schemars_basic.json"];
     expected.assert_eq(&schema);
 }
 
@@ -174,7 +175,7 @@ fn schemars_deserialize_only_bug_735() {
     let mut schema = serde_json::to_string_pretty(&schema).expect("schema could not be serialized");
     schema.push('\n');
 
-    let expected = expect_file!["./schemars_0_8/schemars_deserialize_only_bug_735.json"];
+    let expected = expect_file!["./schemars_deserialize_only_bug_735.json"];
     expected.assert_eq(&schema);
 }
 

serde_with/tests/schemars_0_8/utils.rs

@@ -0,0 +1,57 @@
+#![allow(dead_code, missing_docs)]
+
+use serde::Serialize;
+
+#[track_caller]
+pub fn check_matches_schema<T>(value: &serde_json::Value)
+where
+    T: schemars_0_8::JsonSchema,
+{
+    use jsonschema::Validator;
+    use std::fmt::Write;
+
+    let schema_object = serde_json::to_value(schemars_0_8::schema_for!(T))
+        .expect("schema for T could not be serialized to json");
+    let schema = match Validator::new(&schema_object) {
+        Ok(schema) => schema,
+        Err(e) => panic!("schema for T was not a valid JSON schema: {e}"),
+    };
+
+    if let Err(err) = schema.validate(value) {
+        let mut message = String::new();
+
+        let _ = writeln!(
+            &mut message,
+            "Object was not valid according to its own schema:"
+        );
+
+        let _ = writeln!(&mut message, "  -> {err}");
+        let _ = writeln!(&mut message);
+        let _ = writeln!(&mut message, "Object Value:");
+        let _ = writeln!(
+            &mut message,
+            "{}",
+            serde_json::to_string_pretty(&value).unwrap_or_else(|e| format!("> error: {e}"))
+        );
+        let _ = writeln!(&mut message);
+        let _ = writeln!(&mut message, "JSON Schema:");
+        let _ = writeln!(
+            &mut message,
+            "{}",
+            serde_json::to_string_pretty(&schema_object)
+                .unwrap_or_else(|e| format!("> error: {e}"))
+        );
+
+        panic!("{}", message);
+    };
+}
+
+#[track_caller]
+pub fn check_valid_json_schema<T>(value: &T)
+where
+    T: schemars_0_8::JsonSchema + Serialize,
+{
+    let value = serde_json::to_value(value).expect("could not serialize T to json");
+
+    check_matches_schema::<T>(&value);
+}

serde_with/tests/schemars_0_9/utils.rs

@@ -1,82 +1,6 @@
 #![allow(dead_code, missing_docs)]
 
-use core::fmt::Debug;
-use expect_test::Expect;
-use pretty_assertions::assert_eq;
-use serde::{de::DeserializeOwned, Serialize};
-
-#[track_caller]
-pub fn is_equal<T>(value: T, expected: Expect)
-where
-    T: Debug + DeserializeOwned + PartialEq + Serialize,
-{
-    let serialized = serde_json::to_string_pretty(&value).unwrap();
-    expected.assert_eq(&serialized);
-    assert_eq!(
-        value,
-        serde_json::from_str::<T>(&serialized).unwrap(),
-        "Deserialization differs from expected value."
-    );
-}
-
-/// Like [`is_equal`] but not pretty-print
-#[track_caller]
-pub fn is_equal_compact<T>(value: T, expected: Expect)
-where
-    T: Debug + DeserializeOwned + PartialEq + Serialize,
-{
-    let serialized = serde_json::to_string(&value).unwrap();
-    expected.assert_eq(&serialized);
-    assert_eq!(
-        value,
-        serde_json::from_str::<T>(&serialized).unwrap(),
-        "Deserialization differs from expected value."
-    );
-}
-
-#[track_caller]
-pub fn check_deserialization<T>(value: T, deserialize_from: &str)
-where
-    T: Debug + DeserializeOwned + PartialEq,
-{
-    assert_eq!(
-        value,
-        serde_json::from_str::<T>(deserialize_from).unwrap(),
-        "Deserialization differs from expected value."
-    );
-}
-
-#[track_caller]
-pub fn check_serialization<T>(value: T, serialize_to: Expect)
-where
-    T: Debug + Serialize,
-{
-    serialize_to.assert_eq(&serde_json::to_string_pretty(&value).unwrap());
-}
-
-#[track_caller]
-pub fn check_error_serialization<T>(value: T, error_msg: Expect)
-where
-    T: Debug + Serialize,
-{
-    error_msg.assert_eq(
-        &serde_json::to_string_pretty(&value)
-            .unwrap_err()
-            .to_string(),
-    );
-}
-
-#[track_caller]
-pub fn check_error_deserialization<T>(deserialize_from: &str, error_msg: Expect)
-where
-    T: Debug + DeserializeOwned,
-{
-    error_msg.assert_eq(
-        &serde_json::from_str::<T>(deserialize_from)
-            .unwrap_err()
-            .to_string(),
-    );
-}
+use serde::Serialize;
 
 #[track_caller]
 pub fn check_matches_schema<T>(value: &serde_json::Value)

serde_with/tests/utils.rs

@@ -77,59 +77,3 @@ where
             .to_string(),
     );
 }
-
-#[track_caller]
-pub fn check_matches_schema<T>(value: &serde_json::Value)
-where
-    T: schemars_0_8::JsonSchema,
-{
-    use jsonschema::Validator;
-    use std::fmt::Write;
-
-    if cfg!(feature = "schemars_0_8") {
-        let schema_object = serde_json::to_value(schemars_0_8::schema_for!(T))
-            .expect("schema for T could not be serialized to json");
-        let schema = match Validator::new(&schema_object) {
-            Ok(schema) => schema,
-            Err(e) => panic!("schema for T was not a valid JSON schema: {e}"),
-        };
-
-        if let Err(err) = schema.validate(value) {
-            let mut message = String::new();
-
-            let _ = writeln!(
-                &mut message,
-                "Object was not valid according to its own schema:"
-            );
-
-            let _ = writeln!(&mut message, "  -> {err}");
-            let _ = writeln!(&mut message);
-            let _ = writeln!(&mut message, "Object Value:");
-            let _ = writeln!(
-                &mut message,
-                "{}",
-                serde_json::to_string_pretty(&value).unwrap_or_else(|e| format!("> error: {e}"))
-            );
-            let _ = writeln!(&mut message);
-            let _ = writeln!(&mut message, "JSON Schema:");
-            let _ = writeln!(
-                &mut message,
-                "{}",
-                serde_json::to_string_pretty(&schema_object)
-                    .unwrap_or_else(|e| format!("> error: {e}"))
-            );
-
-            panic!("{}", message);
-        };
-    }
-}
-
-#[track_caller]
-pub fn check_valid_json_schema<T>(value: &T)
-where
-    T: schemars_0_8::JsonSchema + Serialize,
-{
-    let value = serde_json::to_value(value).expect("could not serialize T to json");
-
-    check_matches_schema::<T>(&value);
-}