From 6e8effdaa2b47f4056a00d301a9e7a5a1a2fd8dc Mon Sep 17 00:00:00 2001
From: Caroline Glassberg-Powell
Date: Sun, 28 Apr 2019 18:45:40 +0100
Subject: Issue #69: Change `range` to require only one arg

Currently range is hard-coded to take both max and min. This is
unhelpful in cases where we may only want to check one of the bounds.

Update so that it behaves more like the `length` validator and can take
either max or min, as well as both. Also ensure that at least one of
them is supplied.
---
 validator_derive/tests/compile-fail/range/missing_arg.rs | 15 ---------------
 validator_derive/tests/compile-fail/range/no_args.rs     |  2 +-
 validator_derive/tests/run-pass/range.rs                 |  4 ++++
 3 files changed, 5 insertions(+), 16 deletions(-)
 delete mode 100644 validator_derive/tests/compile-fail/range/missing_arg.rs

(limited to 'validator_derive/tests')

diff --git a/validator_derive/tests/compile-fail/range/missing_arg.rs b/validator_derive/tests/compile-fail/range/missing_arg.rs
deleted file mode 100644
index 3aed1f0..0000000
--- a/validator_derive/tests/compile-fail/range/missing_arg.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![feature(attr_literals)]
-
-#[macro_use] extern crate validator_derive;
-extern crate validator;
-use validator::Validate;
-
-#[derive(Validate)]
-//~^ ERROR: proc-macro derive panicked
-//~^^ HELP: Invalid attribute #[validate] on field `s`: Validator `range` requires 2 arguments: `min` and `max`
-struct Test {
-    #[validate(range(min = 2.0))]
-    s: i32,
-}
-
-fn main() {}
diff --git a/validator_derive/tests/compile-fail/range/no_args.rs b/validator_derive/tests/compile-fail/range/no_args.rs
index c2bdd03..b097b0a 100644
--- a/validator_derive/tests/compile-fail/range/no_args.rs
+++ b/validator_derive/tests/compile-fail/range/no_args.rs
@@ -4,7 +4,7 @@ use validator::Validate;
 
 #[derive(Validate)]
 //~^ ERROR: proc-macro derive panicked
-//~^^ HELP: Invalid attribute #[validate] on field `s`: Validator `range` requires 2 arguments: `min` and `max`
+//~^^ HELP: Invalid attribute #[validate] on field `s`: Validator `range` requires at least 1 argument out of `min` and `max`
 struct Test {
     #[validate(range())]
     s: i32,
diff --git a/validator_derive/tests/run-pass/range.rs b/validator_derive/tests/run-pass/range.rs
index e35f3df..520dd64 100644
--- a/validator_derive/tests/run-pass/range.rs
+++ b/validator_derive/tests/run-pass/range.rs
@@ -24,6 +24,10 @@ struct Test {
     s8: u8,
     #[validate(range(min = 18.0, max = 22))]
     s9: Option<u8>,
+    #[validate(range(min = 18.0))]
+    s10: Option<u8>,
+    #[validate(range(max = 18.0))]
+    s11: Option<u8>,
 }
 
 fn main() {}
-- 
cgit v1.2.3


From 36f6535f6d0c1b680eb396159c27c6c44e63bc79 Mon Sep 17 00:00:00 2001
From: Vincent Prouillet
Date: Wed, 1 May 2019 21:36:09 +0200
Subject: attr_literals is stable \o/

---
 validator_derive/tests/complex.rs     | 44 +++++++++++++++++------------------
 validator_derive/tests/contains.rs    |  9 ++++---
 validator_derive/tests/credit_card.rs |  9 ++++---
 validator_derive/tests/custom.rs      |  6 +++--
 validator_derive/tests/email.rs       |  9 ++++---
 validator_derive/tests/length.rs      | 17 ++++++++------
 validator_derive/tests/must_match.rs  |  9 ++++---
 validator_derive/tests/nested.rs      | 32 ++++++++++++-------------
 validator_derive/tests/phone.rs       |  9 ++++---
 validator_derive/tests/range.rs       | 17 ++++++++------
 validator_derive/tests/regex.rs       |  9 ++++---
 validator_derive/tests/schema.rs      | 13 +++++++----
 validator_derive/tests/url.rs         | 11 ++++++---
 13 files changed, 114 insertions(+), 80 deletions(-)

(limited to 'validator_derive/tests')

diff --git a/validator_derive/tests/complex.rs b/validator_derive/tests/complex.rs
index 7826a49..974fdad 100644
--- a/validator_derive/tests/complex.rs
+++ b/validator_derive/tests/complex.rs
@@ -29,16 +29,16 @@ fn validate_signup(data: &SignupData) -> Result<(), ValidationError> {
 }
 
 #[derive(Debug, Validate, Deserialize)]
-#[validate(schema(function = "validate_signup", skip_on_field_errors = "false"))]
+#[validate(schema(function = "validate_signup", skip_on_field_errors = false))]
 struct SignupData {
     #[validate(email)]
     mail: String,
     #[validate(url)]
     site: String,
-    #[validate(length(min = "1"), custom = "validate_unique_username")]
+    #[validate(length(min = 1), custom = "validate_unique_username")]
     #[serde(rename = "firstName")]
     first_name: String,
-    #[validate(range(min = "18", max = "20"))]
+    #[validate(range(min = 18, max = 20))]
     age: u32,
     #[validate]
     phone: Phone,
@@ -58,13 +58,13 @@ struct Phone {
 struct Card {
     #[validate(credit_card)]
     number: String,
-    #[validate(range(min = "100", max = "9999"))]
+    #[validate(range(min = 100, max = 9999))]
     cvv: u32,
 }
 
 #[derive(Debug, Validate, Deserialize)]
 struct Preference {
-    #[validate(length(min = "4"))]
+    #[validate(length(min = 4))]
     name: String,
     value: bool,
 }
@@ -98,8 +98,8 @@ fn failed_validation_points_to_original_field_name() {
     let res = signup.validate();
     // println!("{}", serde_json::to_string(&res).unwrap());
     assert!(res.is_err());
-    let errs = res.unwrap_err().errors();
-    assert!(errs.contains_key("firstName"));
+    let err = res.unwrap_err();
+let errs = err.errors();assert!(errs.contains_key("firstName"));
     if let ValidationErrorsKind::Field(ref err) = errs["firstName"] {
         assert_eq!(err.len(), 1);
         assert_eq!(err[0].code, "length");
@@ -167,13 +167,13 @@ fn test_can_validate_option_fields_with_lifetime() {
 
     #[derive(Debug, Validate)]
     struct PutStruct<'a> {
-        #[validate(length(min = "1", max = "10"))]
+        #[validate(length(min = 1, max = 10))]
         name: Option<&'a str>,
-        #[validate(length(min = "1", max = "10"))]
+        #[validate(length(min = 1, max = 10))]
         address: Option<Option<&'a str>>,
-        #[validate(range(min = "1", max = "100"))]
+        #[validate(range(min = 1, max = 100))]
         age: Option<Option<usize>>,
-        #[validate(range(min = "1", max = "10"))]
+        #[validate(range(min = 1, max = 10))]
         range: Option<usize>,
         #[validate(email)]
         email: Option<&'a str>,
@@ -213,17 +213,17 @@ fn test_can_validate_option_fields_without_lifetime() {
 
     #[derive(Debug, Validate)]
     struct PutStruct {
-        #[validate(length(min = "1", max = "10"))]
+        #[validate(length(min = 1, max = 10))]
         name: Option<String>,
-        #[validate(length(min = "1", max = "10"))]
+        #[validate(length(min = 1, max = 10))]
         address: Option<Option<String>>,
-        #[validate(length(min = "1", max = "10"))]
+        #[validate(length(min = 1, max = 10))]
         ids: Option<Vec<usize>>,
-        #[validate(length(min = "1", max = "10"))]
+        #[validate(length(min = 1, max = 10))]
         opt_ids: Option<Option<Vec<usize>>>,
-        #[validate(range(min = "1", max = "100"))]
+        #[validate(range(min = 1, max = 100))]
         age: Option<Option<usize>>,
-        #[validate(range(min = "1", max = "10"))]
+        #[validate(range(min = 1, max = 10))]
         range: Option<usize>,
         #[validate(email)]
         email: Option<String>,
@@ -281,13 +281,13 @@ fn test_works_with_question_mark_operator() {
 fn test_works_with_none_values() {
     #[derive(Debug, Validate)]
     struct PutStruct {
-        #[validate(length(min = "1", max = "10"))]
+        #[validate(length(min = 1, max = 10))]
         name: Option<String>,
-        #[validate(length(min = "1", max = "10"))]
+        #[validate(length(min = 1, max = 10))]
         address: Option<Option<String>>,
-        #[validate(range(min = "1", max = "100"))]
+        #[validate(range(min = 1, max = 100))]
         age: Option<Option<usize>>,
-        #[validate(range(min = "1", max = "10"))]
+        #[validate(range(min = 1, max = 10))]
         range: Option<usize>,
     }
 
@@ -304,5 +304,5 @@ where
     F: FnOnce(HashMap<&'static str, ValidationErrorsKind>),
 {
     let errors = *errors.clone();
-    f(errors.errors());
+    f(errors.errors().clone());
 }
diff --git a/validator_derive/tests/contains.rs b/validator_derive/tests/contains.rs
index 1fd568d..77880a5 100644
--- a/validator_derive/tests/contains.rs
+++ b/validator_derive/tests/contains.rs
@@ -28,7 +28,8 @@ fn value_not_containing_needle_fails_validation() {
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "contains");
@@ -46,7 +47,8 @@ fn can_specify_code_for_contains() {
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "oops");
@@ -62,7 +64,8 @@ fn can_specify_message_for_contains() {
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
diff --git a/validator_derive/tests/credit_card.rs b/validator_derive/tests/credit_card.rs
index d212c48..ca84657 100644
--- a/validator_derive/tests/credit_card.rs
+++ b/validator_derive/tests/credit_card.rs
@@ -30,7 +30,8 @@ fn bad_credit_card_fails_validation() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "credit_card");
@@ -48,7 +49,8 @@ fn can_specify_code_for_credit_card() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "oops");
@@ -65,7 +67,8 @@ fn can_specify_message_for_credit_card() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
diff --git a/validator_derive/tests/custom.rs b/validator_derive/tests/custom.rs
index c13853d..d39cbbe 100644
--- a/validator_derive/tests/custom.rs
+++ b/validator_derive/tests/custom.rs
@@ -36,7 +36,8 @@ fn can_fail_custom_fn_validation() {
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "meh");
@@ -53,7 +54,8 @@ fn can_specify_message_for_custom_fn() {
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
diff --git a/validator_derive/tests/email.rs b/validator_derive/tests/email.rs
index 665f0da..3c3f499 100644
--- a/validator_derive/tests/email.rs
+++ b/validator_derive/tests/email.rs
@@ -28,7 +28,8 @@ fn bad_email_fails_validation() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "email");
@@ -45,7 +46,8 @@ fn can_specify_code_for_email() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "oops");
@@ -61,7 +63,8 @@ fn can_specify_message_for_email() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
diff --git a/validator_derive/tests/length.rs b/validator_derive/tests/length.rs
index 6ad6272..df4a87c 100644
--- a/validator_derive/tests/length.rs
+++ b/validator_derive/tests/length.rs
@@ -8,7 +8,7 @@ use validator::Validate;
 fn can_validate_length_ok() {
     #[derive(Debug, Validate)]
     struct TestStruct {
-        #[validate(length(min = "5", max = "10"))]
+        #[validate(length(min = 5, max = 10))]
         val: String,
     }
 
@@ -21,14 +21,15 @@ fn can_validate_length_ok() {
 fn value_out_of_length_fails_validation() {
     #[derive(Debug, Validate)]
     struct TestStruct {
-        #[validate(length(min = "5", max = "10"))]
+        #[validate(length(min = 5, max = 10))]
         val: String,
     }
 
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "length");
@@ -41,13 +42,14 @@ fn value_out_of_length_fails_validation() {
 fn can_specify_code_for_length() {
     #[derive(Debug, Validate)]
     struct TestStruct {
-        #[validate(length(min = "5", max = "10", code = "oops"))]
+        #[validate(length(min = 5, max = 10, code = "oops"))]
         val: String,
     }
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "oops");
@@ -57,13 +59,14 @@ fn can_specify_code_for_length() {
 fn can_specify_message_for_length() {
     #[derive(Debug, Validate)]
     struct TestStruct {
-        #[validate(length(min = "5", max = "10", message = "oops"))]
+        #[validate(length(min = 5, max = 10, message = "oops"))]
         val: String,
     }
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
diff --git a/validator_derive/tests/must_match.rs b/validator_derive/tests/must_match.rs
index 32b3016..9b7bb10 100644
--- a/validator_derive/tests/must_match.rs
+++ b/validator_derive/tests/must_match.rs
@@ -31,7 +31,8 @@ fn not_matching_fails_validation() {
 
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "must_match");
@@ -50,7 +51,8 @@ fn can_specify_code_for_must_match() {
     let s = TestStruct { val: "bob".to_string(), val2: "bobb".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "oops");
@@ -67,7 +69,8 @@ fn can_specify_message_for_must_match() {
     let s = TestStruct { val: "bob".to_string(), val2: "bobb".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
diff --git a/validator_derive/tests/nested.rs b/validator_derive/tests/nested.rs
index a95b0ef..9e3e57f 100644
--- a/validator_derive/tests/nested.rs
+++ b/validator_derive/tests/nested.rs
@@ -11,7 +11,7 @@ use validator::{
 
 #[derive(Debug, Validate)]
 struct Root<'a> {
-    #[validate(length(min = "1"))]
+    #[validate(length(min = 1))]
     value: String,
 
     #[validate]
@@ -20,7 +20,7 @@ struct Root<'a> {
 
 #[derive(Debug, Validate)]
 struct A {
-    #[validate(length(min = "1"))]
+    #[validate(length(min = 1))]
     value: String,
 
     #[validate]
@@ -29,7 +29,7 @@ struct A {
 
 #[derive(Debug, Validate)]
 struct B {
-    #[validate(length(min = "1"))]
+    #[validate(length(min = 1))]
     value: String,
 }
 
@@ -42,13 +42,13 @@ struct ParentWithOptionalChild {
 #[derive(Debug, Validate)]
 struct ParentWithVectorOfChildren {
     #[validate]
-    #[validate(length(min = "1"))]
+    #[validate(length(min = 1))]
     child: Vec<Child>,
 }
 
 #[derive(Debug, Validate, Serialize)]
 struct Child {
-    #[validate(length(min = "1"))]
+    #[validate(length(min = 1))]
     value: String,
 }
 
@@ -71,8 +71,8 @@ fn failed_validation_points_to_original_field_names() {
 
     let res = root.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().errors();
-    assert_eq!(errs.len(), 2);
+    let err = res.unwrap_err();
+let errs = err.errors();assert_eq!(errs.len(), 2);
     assert!(errs.contains_key("value"));
     if let ValidationErrorsKind::Field(ref errs) = errs["value"] {
         assert_eq!(errs.len(), 1);
@@ -118,8 +118,8 @@ fn test_can_validate_option_fields_without_lifetime() {
 
     let res = instance.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().errors();
-    assert_eq!(errs.len(), 1);
+    let err = res.unwrap_err();
+let errs = err.errors();assert_eq!(errs.len(), 1);
     assert!(errs.contains_key("child"));
     if let ValidationErrorsKind::Struct(ref errs) = errs["child"] {
         unwrap_map(errs, |errs| {
@@ -151,8 +151,8 @@ fn test_can_validate_option_fields_with_lifetime() {
 
     let res = instance.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().errors();
-    assert_eq!(errs.len(), 1);
+    let err = res.unwrap_err();
+let errs = err.errors();assert_eq!(errs.len(), 1);
     assert!(errs.contains_key("child"));
     if let ValidationErrorsKind::Struct(ref errs) = errs["child"] {
         unwrap_map(errs, |errs| {
@@ -191,8 +191,8 @@ fn test_can_validate_vector_fields() {
 
     let res = instance.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().errors();
-    assert_eq!(errs.len(), 1);
+    let err = res.unwrap_err();
+let errs = err.errors();assert_eq!(errs.len(), 1);
     assert!(errs.contains_key("child"));
     if let ValidationErrorsKind::List(ref errs) = errs["child"] {
         assert!(errs.contains_key(&1));
@@ -228,8 +228,8 @@ fn test_field_validations_take_priority_over_nested_validations() {
 
     let res = instance.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().errors();
-    assert_eq!(errs.len(), 1);
+    let err = res.unwrap_err();
+let errs = err.errors();assert_eq!(errs.len(), 1);
     assert!(errs.contains_key("child"));
     if let ValidationErrorsKind::Field(ref errs) = errs["child"] {
         assert_eq!(errs.len(), 1);
@@ -343,5 +343,5 @@ where
     F: FnOnce(HashMap<&'static str, ValidationErrorsKind>),
 {
     let errors = *errors.clone();
-    f(errors.errors());
+    f(errors.errors().clone());
 }
diff --git a/validator_derive/tests/phone.rs b/validator_derive/tests/phone.rs
index a87d037..b692a8f 100644
--- a/validator_derive/tests/phone.rs
+++ b/validator_derive/tests/phone.rs
@@ -30,7 +30,8 @@ fn bad_phone_fails_validation() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "phone");
@@ -47,7 +48,8 @@ fn can_specify_code_for_phone() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "oops");
@@ -65,7 +67,8 @@ fn can_specify_message_for_phone() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
diff --git a/validator_derive/tests/range.rs b/validator_derive/tests/range.rs
index 4f38f18..869510a 100644
--- a/validator_derive/tests/range.rs
+++ b/validator_derive/tests/range.rs
@@ -8,7 +8,7 @@ use validator::Validate;
 fn can_validate_range_ok() {
     #[derive(Debug, Validate)]
     struct TestStruct {
-        #[validate(range(min = "5", max = "10"))]
+        #[validate(range(min = 5, max = 10))]
         val: usize,
     }
 
@@ -21,14 +21,15 @@ fn can_validate_range_ok() {
 fn value_out_of_range_fails_validation() {
     #[derive(Debug, Validate)]
     struct TestStruct {
-        #[validate(range(min = "5", max = "10"))]
+        #[validate(range(min = 5, max = 10))]
         val: usize,
     }
 
     let s = TestStruct { val: 11 };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "range");
@@ -38,13 +39,14 @@ fn value_out_of_range_fails_validation() {
 fn can_specify_code_for_range() {
     #[derive(Debug, Validate)]
     struct TestStruct {
-        #[validate(range(min = "5", max = "10", code = "oops"))]
+        #[validate(range(min = 5, max = 10, code = "oops"))]
         val: usize,
     }
     let s = TestStruct { val: 11 };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "oops");
@@ -57,13 +59,14 @@ fn can_specify_code_for_range() {
 fn can_specify_message_for_range() {
     #[derive(Debug, Validate)]
     struct TestStruct {
-        #[validate(range(min = "5", max = "10", message = "oops"))]
+        #[validate(range(min = 5, max = 10, message = "oops"))]
         val: usize,
     }
     let s = TestStruct { val: 1 };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
diff --git a/validator_derive/tests/regex.rs b/validator_derive/tests/regex.rs
index a6b9e68..7e3dfc5 100644
--- a/validator_derive/tests/regex.rs
+++ b/validator_derive/tests/regex.rs
@@ -36,7 +36,8 @@ fn bad_value_for_regex_fails_validation() {
     let s = TestStruct { val: "2".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "regex");
@@ -53,7 +54,8 @@ fn can_specify_code_for_regex() {
     let s = TestStruct { val: "2".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "oops");
@@ -69,7 +71,8 @@ fn can_specify_message_for_regex() {
     let s = TestStruct { val: "2".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
diff --git a/validator_derive/tests/schema.rs b/validator_derive/tests/schema.rs
index b45f3a1..3a45711 100644
--- a/validator_derive/tests/schema.rs
+++ b/validator_derive/tests/schema.rs
@@ -36,7 +36,8 @@ fn can_fail_schema_fn_validation() {
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("__all__"));
     assert_eq!(errs["__all__"].len(), 1);
     assert_eq!(errs["__all__"][0].code, "meh");
@@ -56,7 +57,8 @@ fn can_specify_message_for_schema_fn() {
     let s = TestStruct { val: String::new() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("__all__"));
     assert_eq!(errs["__all__"].len(), 1);
     assert_eq!(errs["__all__"][0].clone().message.unwrap(), "oops");
@@ -68,10 +70,10 @@ fn can_choose_to_run_schema_validation_even_after_field_errors() {
         Err(ValidationError::new("meh"))
     }
     #[derive(Debug, Validate)]
-    #[validate(schema(function = "invalid_schema_fn", skip_on_field_errors = "false"))]
+    #[validate(schema(function = "invalid_schema_fn", skip_on_field_errors = false))]
     struct TestStruct {
         val: String,
-        #[validate(range(min = "1", max = "10"))]
+        #[validate(range(min = 1, max = 10))]
         num: usize,
     }
 
@@ -79,7 +81,8 @@ fn can_choose_to_run_schema_validation_even_after_field_errors() {
 
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("__all__"));
     assert_eq!(errs["__all__"].len(), 1);
     assert_eq!(errs["__all__"][0].clone().code, "meh");
diff --git a/validator_derive/tests/url.rs b/validator_derive/tests/url.rs
index 0ac3cb1..3b867b9 100644
--- a/validator_derive/tests/url.rs
+++ b/validator_derive/tests/url.rs
@@ -28,7 +28,9 @@ fn bad_url_fails_validation() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "url");
@@ -44,7 +46,9 @@ fn can_specify_code_for_url() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].code, "oops");
@@ -61,7 +65,8 @@ fn can_specify_message_for_url() {
     let s = TestStruct { val: "bob".to_string() };
     let res = s.validate();
     assert!(res.is_err());
-    let errs = res.unwrap_err().field_errors();
+    let err = res.unwrap_err();
+    let errs = err.field_errors();
     assert!(errs.contains_key("val"));
     assert_eq!(errs["val"].len(), 1);
     assert_eq!(errs["val"][0].clone().message.unwrap(), "oops");
-- 
cgit v1.2.3


From 467298db852205329758f89d7c2f2639b61ad66a Mon Sep 17 00:00:00 2001
From: Vincent Prouillet
Date: Wed, 1 May 2019 22:03:17 +0200
Subject: Cargo fmt + edition 2018 for validator

---
 validator_derive/tests/complex.rs |  3 ++-
 validator_derive/tests/nested.rs  | 21 ++++++++++++++-------
 2 files changed, 16 insertions(+), 8 deletions(-)

(limited to 'validator_derive/tests')

diff --git a/validator_derive/tests/complex.rs b/validator_derive/tests/complex.rs
index 974fdad..305b0ce 100644
--- a/validator_derive/tests/complex.rs
+++ b/validator_derive/tests/complex.rs
@@ -99,7 +99,8 @@ fn failed_validation_points_to_original_field_name() {
     // println!("{}", serde_json::to_string(&res).unwrap());
     assert!(res.is_err());
     let err = res.unwrap_err();
-let errs = err.errors();assert!(errs.contains_key("firstName"));
+    let errs = err.errors();
+    assert!(errs.contains_key("firstName"));
     if let ValidationErrorsKind::Field(ref err) = errs["firstName"] {
         assert_eq!(err.len(), 1);
         assert_eq!(err[0].code, "length");
diff --git a/validator_derive/tests/nested.rs b/validator_derive/tests/nested.rs
index 9e3e57f..781f01d 100644
--- a/validator_derive/tests/nested.rs
+++ b/validator_derive/tests/nested.rs
@@ -72,7 +72,8 @@ fn failed_validation_points_to_original_field_names() {
     let res = root.validate();
     assert!(res.is_err());
     let err = res.unwrap_err();
-let errs = err.errors();assert_eq!(errs.len(), 2);
+    let errs = err.errors();
+    assert_eq!(errs.len(), 2);
     assert!(errs.contains_key("value"));
     if let ValidationErrorsKind::Field(ref errs) = errs["value"] {
         assert_eq!(errs.len(), 1);
@@ -119,7 +120,8 @@ fn test_can_validate_option_fields_without_lifetime() {
     let res = instance.validate();
     assert!(res.is_err());
     let err = res.unwrap_err();
-let errs = err.errors();assert_eq!(errs.len(), 1);
+    let errs = err.errors();
+    assert_eq!(errs.len(), 1);
     assert!(errs.contains_key("child"));
     if let ValidationErrorsKind::Struct(ref errs) = errs["child"] {
         unwrap_map(errs, |errs| {
@@ -152,7 +154,8 @@ fn test_can_validate_option_fields_with_lifetime() {
     let res = instance.validate();
     assert!(res.is_err());
     let err = res.unwrap_err();
-let errs = err.errors();assert_eq!(errs.len(), 1);
+    let errs = err.errors();
+    assert_eq!(errs.len(), 1);
     assert!(errs.contains_key("child"));
     if let ValidationErrorsKind::Struct(ref errs) = errs["child"] {
         unwrap_map(errs, |errs| {
@@ -192,7 +195,8 @@ fn test_can_validate_vector_fields() {
     let res = instance.validate();
     assert!(res.is_err());
     let err = res.unwrap_err();
-let errs = err.errors();assert_eq!(errs.len(), 1);
+    let errs = err.errors();
+    assert_eq!(errs.len(), 1);
     assert!(errs.contains_key("child"));
     if let ValidationErrorsKind::List(ref errs) = errs["child"] {
         assert!(errs.contains_key(&1));
@@ -229,7 +233,8 @@ fn test_field_validations_take_priority_over_nested_validations() {
     let res = instance.validate();
     assert!(res.is_err());
     let err = res.unwrap_err();
-let errs = err.errors();assert_eq!(errs.len(), 1);
+    let errs = err.errors();
+    assert_eq!(errs.len(), 1);
     assert!(errs.contains_key("child"));
     if let ValidationErrorsKind::Field(ref errs) = errs["child"] {
         assert_eq!(errs.len(), 1);
@@ -275,7 +280,8 @@ fn test_field_validation_errors_replaced_with_nested_validations_fails() {
                         let mut result = Ok(());
                         result = ValidationErrors::merge(result, "child", child.validate());
                         result
-                    }).collect();
+                    })
+                    .collect();
                 result = ValidationErrors::merge_all(result, "child", results);
             }
             result
@@ -313,7 +319,8 @@ fn test_field_validations_evaluated_after_nested_validations_fails() {
                         let mut result = Ok(());
                         result = ValidationErrors::merge(result, "child", child.validate());
                         result
-                    }).collect();
+                    })
+                    .collect();
                 result = ValidationErrors::merge_all(result, "child", results);
             }
 
-- 
cgit v1.2.3