feat: implement PartialEq on validation error types

crates/serde_valid/src/error.rs

@@ -51,13 +51,13 @@ where
 
 macro_rules! struct_error_params {
     (
-        #[derive(Debug, Clone)]
+        #[derive(Debug, Clone, PartialEq)]
         #[default_message=$default_message:literal]
         pub struct $Error:ident {
             pub $limit:ident: Vec<$type:ty>,
         }
     ) => {
-        #[derive(Debug, Clone)]
+        #[derive(Debug, Clone, PartialEq)]
         pub struct $Error {
             pub $limit: Vec<$type>,
         }
@@ -85,13 +85,13 @@ macro_rules! struct_error_params {
     };
 
     (
-        #[derive(Debug, Clone)]
+        #[derive(Debug, Clone, PartialEq)]
         #[default_message=$default_message:literal]
         pub struct $Error:ident {
             pub $limit:ident: $type:ty,
         }
     ) => {
-        #[derive(Debug, Clone)]
+        #[derive(Debug, Clone, PartialEq)]
         pub struct $Error {
             pub $limit: $type,
         }
@@ -113,11 +113,11 @@ macro_rules! struct_error_params {
     };
 
     (
-        #[derive(Debug, Clone)]
+        #[derive(Debug, Clone, PartialEq)]
         #[default_message=$default_message:literal]
         pub struct $Error:ident;
     ) => {
-        #[derive(Debug, Clone)]
+        #[derive(Debug, Clone, PartialEq)]
         pub struct $Error;
 
         impl FormatDefault for $Error {
@@ -131,39 +131,39 @@ macro_rules! struct_error_params {
 
 // Number
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The number must be `>= {}`."]
     pub struct MinimumError {
         pub minimum: Number,
     }
 );
 
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The number must be `<= {}`."]
     pub struct MaximumError {
         pub maximum: Number,
     }
 );
 
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The number must be `> {}`."]
     pub struct ExclusiveMinimumError {
         pub exclusive_minimum: Number,
     }
 );
 
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The number must be `< {}`."]
     pub struct ExclusiveMaximumError {
         pub exclusive_maximum: Number,
     }
 );
 
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The value must be multiple of `{}`."]
     pub struct MultipleOfError {
         pub multiple_of: Number,
@@ -172,23 +172,23 @@ struct_error_params!(
 
 // String
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The length of the value must be `>= {}`."]
     pub struct MinLengthError {
         pub min_length: usize,
     }
 );
 
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The length of the value must be `<= {}`."]
     pub struct MaxLengthError {
         pub max_length: usize,
     }
 );
 
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The value must match the pattern of \"{0}\"."]
     pub struct PatternError {
         pub pattern: String,
@@ -197,38 +197,38 @@ struct_error_params!(
 
 // Array
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The length of the items must be `<= {}`."]
     pub struct MaxItemsError {
         pub max_items: usize,
     }
 );
 
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The length of the items must be `>= {}`."]
     pub struct MinItemsError {
         pub min_items: usize,
     }
 );
 
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The items must be unique."]
     pub struct UniqueItemsError;
 );
 
 // Object
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The size of the properties must be `<= {}`."]
     pub struct MaxPropertiesError {
         pub max_properties: usize,
     }
 );
 
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The size of the properties must be `>= {}`."]
     pub struct MinPropertiesError {
         pub min_properties: usize,
@@ -237,7 +237,7 @@ struct_error_params!(
 
 // Generic
 struct_error_params!(
-    #[derive(Debug, Clone)]
+    #[derive(Debug, Clone, PartialEq)]
     #[default_message = "The value must be in [{:}]."]
     pub struct EnumError {
         pub candidates: Vec<Literal>,

crates/serde_valid/src/features/fluent/message.rs

@@ -1,4 +1,4 @@
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Message {
     pub id: &'static str,
     pub args: Vec<(&'static str, fluent::FluentValue<'static>)>,

crates/serde_valid/src/validation/error.rs

@@ -20,7 +20,7 @@ pub use into_error::IntoError;
 pub use message::Message;
 pub use object_errors::ObjectErrors;
 
-#[derive(Debug, Clone, serde::Serialize, thiserror::Error)]
+#[derive(Debug, Clone, PartialEq, serde::Serialize, thiserror::Error)]
 #[serde(untagged)]
 pub enum Error {
     #[error("{0}")]

crates/serde_valid/src/validation/error/array_erros.rs

@@ -2,7 +2,7 @@ use serde::ser::SerializeStruct;
 
 use super::{ItemErrorsMap, VecErrors};
 
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, Clone, PartialEq, thiserror::Error)]
 pub struct ArrayErrors<E = crate::validation::Error> {
     pub errors: VecErrors<E>,
     pub items: ItemErrorsMap<E>,

crates/serde_valid/src/validation/error/errors.rs

@@ -1,6 +1,6 @@
 use super::{ArrayErrors, ObjectErrors, VecErrors};
 
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, Clone, PartialEq, thiserror::Error)]
 pub enum Errors<E = crate::validation::Error> {
     Array(ArrayErrors<E>),
     Object(ObjectErrors<E>),

crates/serde_valid/src/validation/error/format.rs

@@ -20,6 +20,21 @@ impl<E> Clone for Format<E> {
     }
 }
 
+/// `MessageFn` is compared by function address, so two identical functions
+/// are not guaranteed to compare equal.
+impl<E> PartialEq for Format<E> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Default, Self::Default) => true,
+            (Self::Message(a), Self::Message(b)) => a == b,
+            (Self::MessageFn(a), Self::MessageFn(b)) => std::ptr::fn_addr_eq(*a, *b),
+            #[cfg(feature = "fluent")]
+            (Self::Fluent(a), Self::Fluent(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
 impl<E> Format<E> {
     pub fn into_message(self, error: E) -> crate::validation::error::Message<E> {
         crate::validation::error::Message::new(error, self)

crates/serde_valid/src/validation/error/message.rs

@@ -1,6 +1,6 @@
 use super::{Format, FormatDefault};
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Message<E> {
     error: E,
     format: Format<E>,

crates/serde_valid/src/validation/error/object_errors.rs

@@ -2,7 +2,7 @@ use serde::ser::SerializeStruct;
 
 use super::{PropertyErrorsMap, VecErrors};
 
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, Clone, PartialEq, thiserror::Error)]
 pub struct ObjectErrors<E = crate::validation::Error> {
     pub errors: VecErrors<E>,
     pub properties: PropertyErrorsMap<E>,