add test for length

Author: tomoikey

src/rule/length/equal.rs

@@ -1,3 +1,17 @@
+/// This macro generates a rule that checks if the length of the target is equal to `N`
+/// # Example
+/// ```rust
+/// use refined_type::length_equal;
+/// length_equal!(5);
+///
+/// let target = "12345";
+/// let refined = LengthEqual5::new(target).unwrap();
+/// assert_eq!(refined.into_value(), "12345");
+///
+/// let target = "1234";
+/// let refined = LengthEqual5::new(target);
+/// assert!(refined.is_err());
+/// ```
 #[macro_export]
 macro_rules! length_equal {
     ($length:literal) => {
@@ -31,7 +45,7 @@ macro_rules! length_equal {
                     if target.length() == $length {
                         Ok(())
                     } else {
-                        Err(Error::new(format!("target length is not equal to {}", $length)))
+                        Err($crate::result::Error::new(format!("target length is not equal to {}", $length)))
                     }
                 }
             }

src/rule/length/grater.rs

@@ -1,3 +1,16 @@
+/// This macro generates a rule that checks if the length of the target is greater than `N`
+/// # Example
+/// ```rust
+/// use refined_type::length_greater_than;
+/// length_greater_than!(5);
+///
+/// let target = "123456";
+/// let refined = LengthGreaterThan5::new(target).unwrap();
+/// assert_eq!(refined.into_value(), "123456");
+///
+/// let target = "12345";
+/// let refined = LengthGreaterThan5::new(target);
+/// assert!(refined.is_err());
 #[macro_export]
 macro_rules! length_greater_than {
     ($length:literal) => {
@@ -30,7 +43,7 @@ macro_rules! length_greater_than {
                     if target.length() > $length {
                         Ok(())
                     } else {
-                        Err(Error::new(format!("target length is not greater than {}", $length)))
+                        Err($crate::result::Error::new(format!("target length is not greater than {}", $length)))
                     }
                 }
             }

src/rule/length/less.rs

@@ -1,3 +1,17 @@
+/// This macro generates a rule that checks if the length of the target is less than `N`
+/// # Example
+/// ```rust
+/// use refined_type::length_less_than;
+/// length_less_than!(5);
+///
+/// let target = "1234";
+/// let refined = LengthLessThan5::new(target).unwrap();
+/// assert_eq!(refined.into_value(), "1234");
+///
+/// let target = "12345";
+/// let refined = LengthLessThan5::new(target);
+/// assert!(refined.is_err());
+/// ```
 #[macro_export]
 macro_rules! length_less_than {
     ($length:literal) => {
@@ -31,7 +45,7 @@ macro_rules! length_less_than {
                     if target.length() < $length {
                         Ok(())
                     } else {
-                        Err(Error::new(format!("target length is not less than {}", $length)))
+                        Err($crate::result::Error::new(format!("target length is not less than {}", $length)))
                     }
                 }
             }

tests/length.rs

@@ -0,0 +1,93 @@
+use refined_type::{length_equal, length_greater_than, length_less_than, Refined};
+use refined_type::rule::composer::{And, Or};
+
+length_greater_than!(5);
+length_equal!(5, 10);
+length_less_than!(10);
+
+#[test]
+fn test_length() -> Result<(), refined_type::result::Error> {
+    type Password = Refined<
+        And<
+            Or<LengthEqualRule5<String>, LengthGreaterThanRule5<String>>,
+            Or<LengthLessThanRule10<String>, LengthEqualRule10<String>>,
+        >,
+    >;
+    let raw_password = "password";
+    let password = Password::new(raw_password.to_string())?;
+    assert_eq!(password.into_value(), "password");
+    Ok(())
+}
+
+#[test]
+fn test_length_fail() {
+    type Password = Refined<
+        And<
+            And<LengthEqualRule5<String>, LengthGreaterThanRule5<String>>,
+            And<LengthLessThanRule10<String>, LengthEqualRule10<String>>,
+        >,
+    >;
+    let raw_password = "password password";
+    let password = Password::new(raw_password.to_string());
+    assert!(password.is_err());
+}
+
+#[test]
+fn test_length_greater_than_5() -> Result<(), refined_type::result::Error> {
+    let target = "123456";
+    let refined = LengthGreaterThan5::new(target)?;
+    assert_eq!(refined.into_value(), "123456");
+    Ok(())
+}
+
+#[test]
+fn test_length_greater_than_5_fail() {
+    let target = "1234";
+    let refined = LengthGreaterThan5::new(target);
+    assert!(refined.is_err());
+}
+
+#[test]
+fn test_length_equal_5() -> Result<(), refined_type::result::Error> {
+    let target = "12345";
+    let refined = LengthEqual5::new(target)?;
+    assert_eq!(refined.into_value(), "12345");
+    Ok(())
+}
+
+#[test]
+fn test_length_equal_5_fail() {
+    let target = "1234";
+    let refined = LengthEqual5::new(target);
+    assert!(refined.is_err());
+}
+
+#[test]
+fn test_length_equal_10() -> Result<(), refined_type::result::Error> {
+    let target = "1234567890";
+    let refined = LengthEqual10::new(target)?;
+    assert_eq!(refined.into_value(), "1234567890");
+    Ok(())
+}
+
+#[test]
+fn test_length_equal_10_fail() {
+    let target = "123456789";
+    let refined = LengthEqual10::new(target);
+    assert!(refined.is_err());
+}
+
+#[test]
+fn test_length_less_than_10() -> Result<(), refined_type::result::Error> {
+    let target = "123456789";
+    let refined = LengthLessThan10::new(target)?;
+    assert_eq!(refined.into_value(), "123456789");
+    Ok(())
+}
+
+#[test]
+fn test_length_less_than_10_fail() {
+    let target = "1234567890";
+    let refined = LengthLessThan10::new(target);
+    assert!(refined.is_err());
+}