feat: add validation compile tests

Cargo.toml

@@ -10,12 +10,15 @@ repository = "https://github.com/RustForWeb/fortifier"
 version = "0.0.1"
 
 [workspace.dependencies]
+email_address = { version = "0.2.9", default-features = false }
 fortifier = { path = "./packages/fortifier", version = "0.0.1" }
 fortifier-macros = { path = "./packages/fortifier-macros", version = "0.0.1" }
+indexmap = "2.12.0"
 regex = "1.12.2"
 serde = "1.0.228"
 serde_json = "1.0.145"
 tokio = "1.48.0"
+url = "2.5.7"
 utoipa = "5.4.0"
 
 [workspace.lints.rust]

packages/fortifier-macros/Cargo.toml

@@ -24,8 +24,12 @@ quote = "1.0.42"
 syn = "2.0.110"
 
 [dev-dependencies]
-fortifier = { workspace = true, features = ["email"] }
+email_address.workspace = true
+fortifier = { workspace = true, features = ["all-validations", "indexmap"] }
+indexmap.workspace = true
+regex.workspace = true
 trybuild = "1.0.114"
+url.workspace = true
 
 [lints]
 workspace = true

packages/fortifier-macros/src/validate/field.rs

@@ -47,9 +47,7 @@ impl<'a> ValidateField<'a> {
     ) -> Result<Self> {
         let error_ident = match &ident {
             LiteralOrIdent::Literal(literal) => format_ident!("F{literal}"),
-            LiteralOrIdent::Ident(ident) => {
-                format_ident!("{}", ident.to_string().to_case(Case::UpperCamel))
-            }
+            LiteralOrIdent::Ident(ident) => upper_camel_ident(ident),
         };
         let error_type_ident = format_ident!("{type_prefix}{error_ident}ValidationError");
 
@@ -178,3 +176,13 @@ impl<'a> ValidateField<'a> {
             .collect()
     }
 }
+
+fn upper_camel_ident(ident: &Ident) -> Ident {
+    let s = ident.to_string();
+
+    if s.starts_with("r#") {
+        format_ident!("{}", (&s[2..]).to_case(Case::UpperCamel))
+    } else {
+        format_ident!("{}", s.to_case(Case::UpperCamel))
+    }
+}

packages/fortifier-macros/src/validations/length.rs

@@ -36,6 +36,14 @@ impl Validation for Length {
             }
         })?;
 
+        if result.equal.is_some() {
+            if result.min.is_some() {
+                return Err(meta.error("`equal` and `min` are conflicting parameters"));
+            } else if result.max.is_some() {
+                return Err(meta.error("`equal` and `max` are conflicting parameters"));
+            }
+        }
+
         Ok(result)
     }
 

packages/fortifier-macros/tests/validate.rs

@@ -0,0 +1,8 @@
+use trybuild::TestCases;
+
+#[test]
+fn validate() {
+    let t = TestCases::new();
+    t.pass("tests/validate/*_pass.rs");
+    t.compile_fail("tests/validate/*_fail.rs");
+}

packages/fortifier-macros/tests/validations.rs

@@ -0,0 +1,8 @@
+use trybuild::TestCases;
+
+#[test]
+fn validations() {
+    let t = TestCases::new();
+    t.pass("tests/validations/*/*_pass.rs");
+    t.compile_fail("tests/validations/*/*_fail.rs");
+}

packages/fortifier-macros/tests/validations/email/invalid_allow_display_text_fail.rs

@@ -0,0 +1,9 @@
+use fortifier::Validate;
+
+#[derive(Validate)]
+struct EmailData<'a> {
+    #[validate(email(allow_display_text = 1))]
+    value: &'a str,
+}
+
+fn main() {}

packages/fortifier-macros/tests/validations/email/invalid_allow_display_text_fail.stderr

@@ -0,0 +1,5 @@
+error: expected boolean literal
+ --> tests/validations/email/invalid_allow_display_text_fail.rs:5:43
+  |
+5 |     #[validate(email(allow_display_text = 1))]
+  |                                           ^

packages/fortifier-macros/tests/validations/email/invalid_allow_domain_literal_fail.rs

@@ -0,0 +1,9 @@
+use fortifier::Validate;
+
+#[derive(Validate)]
+struct EmailData<'a> {
+    #[validate(email(allow_domain_literal = 1))]
+    value: &'a str,
+}
+
+fn main() {}

packages/fortifier-macros/tests/validations/email/invalid_allow_domain_literal_fail.stderr

@@ -0,0 +1,5 @@
+error: expected boolean literal
+ --> tests/validations/email/invalid_allow_domain_literal_fail.rs:5:45
+  |
+5 |     #[validate(email(allow_domain_literal = 1))]
+  |                                             ^

packages/fortifier-macros/tests/validations/email/invalid_minimum_sub_domains_fail.rs

@@ -0,0 +1,9 @@
+use fortifier::Validate;
+
+#[derive(Validate)]
+struct EmailData<'a> {
+    #[validate(email(minimum_sub_domains = -1))]
+    value: &'a str,
+}
+
+fn main() {}

packages/fortifier-macros/tests/validations/email/invalid_minimum_sub_domains_fail.stderr

@@ -0,0 +1,5 @@
+error: invalid digit found in string
+ --> tests/validations/email/invalid_minimum_sub_domains_fail.rs:5:44
+  |
+5 |     #[validate(email(minimum_sub_domains = -1))]
+  |                                            ^

packages/fortifier-macros/tests/validations/email/types_pass.rs

@@ -0,0 +1,31 @@
+use email_address::EmailAddress;
+use fortifier::{EmailError, Validate, ValidationErrors};
+
+#[derive(Validate)]
+struct EmailData<'a> {
+    #[validate(email)]
+    r#str: &'a str,
+    #[validate(email)]
+    string: String,
+    #[validate(email)]
+    email_address: EmailAddress,
+}
+
+fn main() {
+    let data = EmailData {
+        r#str: "admin",
+        string: "admin@".to_owned(),
+        email_address: EmailAddress::new_unchecked("Admin <admin@localhost>"),
+    };
+
+    assert_eq!(
+        data.validate_sync(),
+        Err(ValidationErrors::from_iter([
+            EmailDataValidationError::Str(EmailError::from(email_address::Error::MissingSeparator)),
+            EmailDataValidationError::String(EmailError::from(email_address::Error::DomainEmpty)),
+            EmailDataValidationError::EmailAddress(EmailError::from(
+                email_address::Error::UnsupportedDisplayName
+            )),
+        ]))
+    );
+}

packages/fortifier-macros/tests/validations/email/unknown_fail.rs

@@ -0,0 +1,9 @@
+use fortifier::Validate;
+
+#[derive(Validate)]
+struct EmailData<'a> {
+    #[validate(email(unknown = true))]
+    value: &'a str,
+}
+
+fn main() {}

packages/fortifier-macros/tests/validations/email/unknown_fail.stderr

@@ -0,0 +1,5 @@
+error: unknown parameter
+ --> tests/validations/email/unknown_fail.rs:5:22
+  |
+5 |     #[validate(email(unknown = true))]
+  |                      ^^^^^^^

packages/fortifier-macros/tests/validations/length/conflict_max_fail.rs

@@ -0,0 +1,9 @@
+use fortifier::Validate;
+
+#[derive(Validate)]
+struct LengthData<'a> {
+    #[validate(length(equal = 1, max = 2))]
+    value: &'a str,
+}
+
+fn main() {}

packages/fortifier-macros/tests/validations/length/conflict_max_fail.stderr

@@ -0,0 +1,5 @@
+error: `equal` and `max` are conflicting parameters
+ --> tests/validations/length/conflict_max_fail.rs:5:16
+  |
+5 |     #[validate(length(equal = 1, max = 2))]
+  |                ^^^^^^^^^^^^^^^^^^^^^^^^^^

packages/fortifier-macros/tests/validations/length/conflict_min_fail.rs

@@ -0,0 +1,9 @@
+use fortifier::Validate;
+
+#[derive(Validate)]
+struct LengthData<'a> {
+    #[validate(length(equal = 1, min = 2))]
+    value: &'a str,
+}
+
+fn main() {}

packages/fortifier-macros/tests/validations/length/conflict_min_fail.stderr

@@ -0,0 +1,5 @@
+error: `equal` and `min` are conflicting parameters
+ --> tests/validations/length/conflict_min_fail.rs:5:16
+  |
+5 |     #[validate(length(equal = 1, min = 2))]
+  |                ^^^^^^^^^^^^^^^^^^^^^^^^^^

packages/fortifier-macros/tests/validations/length/options_pass.rs

@@ -0,0 +1,35 @@
+use fortifier::{LengthError, Validate, ValidationErrors};
+
+#[derive(Validate)]
+struct LengthData<'a> {
+    #[validate(length(equal = 2))]
+    equal: &'a str,
+    #[validate(length(min = 1))]
+    min: &'a str,
+    #[validate(length(max = 4))]
+    max: &'a str,
+    #[validate(length(min = 1, max = 4))]
+    min_max: &'a str,
+}
+
+fn main() {
+    let data = LengthData {
+        equal: "a",
+        min: "",
+        max: "abcde",
+        min_max: "abcdef",
+    };
+
+    assert_eq!(
+        data.validate_sync(),
+        Err(ValidationErrors::from_iter([
+            LengthDataValidationError::Equal(LengthError::Equal {
+                equal: 2,
+                length: 1
+            }),
+            LengthDataValidationError::Min(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::Max(LengthError::Max { max: 4, length: 5 }),
+            LengthDataValidationError::MinMax(LengthError::Max { max: 4, length: 6 })
+        ]))
+    );
+}

packages/fortifier-macros/tests/validations/length/types_pass.rs

@@ -0,0 +1,71 @@
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, LinkedList, VecDeque};
+
+use fortifier::{LengthError, Validate, ValidationErrors};
+use indexmap::{IndexMap, IndexSet};
+
+#[derive(Validate)]
+struct LengthData<'a> {
+    #[validate(length(min = 1))]
+    r#str: &'a str,
+    #[validate(length(min = 1))]
+    string: String,
+    #[validate(length(min = 1))]
+    array: [usize; 0],
+    #[validate(length(min = 1))]
+    slice: &'a [usize],
+    #[validate(length(min = 1))]
+    b_tree_map: BTreeMap<usize, usize>,
+    #[validate(length(min = 1))]
+    b_tree_set: BTreeSet<usize>,
+    #[validate(length(min = 1))]
+    hash_map: HashMap<usize, usize>,
+    #[validate(length(min = 1))]
+    hash_set: HashSet<String>,
+    #[validate(length(min = 1))]
+    index_map: IndexMap<usize, usize>,
+    #[validate(length(min = 1))]
+    index_set: IndexSet<String>,
+    #[validate(length(min = 1))]
+    linked_list: LinkedList<String>,
+    #[validate(length(min = 1))]
+    vec: Vec<usize>,
+    #[validate(length(min = 1))]
+    vec_deque: VecDeque<usize>,
+}
+
+fn main() {
+    let data = LengthData {
+        r#str: "",
+        string: "".to_owned(),
+        array: [],
+        slice: &[],
+        b_tree_map: BTreeMap::default(),
+        b_tree_set: BTreeSet::default(),
+        hash_map: HashMap::default(),
+        hash_set: HashSet::default(),
+        index_map: IndexMap::default(),
+        index_set: IndexSet::default(),
+        linked_list: LinkedList::default(),
+        vec: Vec::default(),
+        vec_deque: VecDeque::default(),
+    };
+
+    assert_eq!(
+        data.validate_sync(),
+        Err(ValidationErrors::from_iter([
+            LengthDataValidationError::Str(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::String(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::Array(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::Slice(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::BTreeMap(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::BTreeSet(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::HashMap(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::HashSet(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::IndexMap(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::IndexSet(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::LinkedList(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::Vec(LengthError::Min { min: 1, length: 0 }),
+            LengthDataValidationError::VecDeque(LengthError::Min { min: 1, length: 0 }),
+        ]))
+    );
+}

packages/fortifier-macros/tests/validations/length/unknown_fail.rs

@@ -0,0 +1,9 @@
+use fortifier::Validate;
+
+#[derive(Validate)]
+struct LengthData<'a> {
+    #[validate(length(unknown = 2))]
+    value: &'a str,
+}
+
+fn main() {}

packages/fortifier-macros/tests/validations/length/unknown_fail.stderr

@@ -0,0 +1,5 @@
+error: unknown parameter
+ --> tests/validations/length/unknown_fail.rs:5:23
+  |
+5 |     #[validate(length(unknown = 2))]
+  |                       ^^^^^^^

packages/fortifier-macros/tests/validations/regex/invalid_expression_fail.rs

@@ -0,0 +1,9 @@
+use fortifier::Validate;
+
+#[derive(Validate)]
+struct RegexData<'a> {
+    #[validate(regex = "abc")]
+    value: &'a str,
+}
+
+fn main() {}