more tests for de

router/src/de.rs

@@ -487,12 +487,27 @@ mod tests {
         id: String,
     }
 
-    #[derive(Deserialize)]
+    #[derive(Debug, Deserialize)]
+    struct Test1(String, u32);
+
+    #[derive(Debug, Deserialize)]
     struct Test2 {
         key: String,
         value: u32,
     }
 
+    #[derive(Debug, Deserialize, PartialEq)]
+    #[serde(rename_all = "lowercase")]
+    enum TestEnum {
+        Val1,
+        Val2,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Test3 {
+        val: TestEnum,
+    }
+
     #[test]
     fn test_request_extract() {
         let mut router = Router::<()>::build();
@@ -518,6 +533,10 @@ mod tests {
         let mut path = Path::new("/name/32/");
         assert!(router.recognize(&mut path).is_some());
 
+        let s: Test1 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
         let s: Test2 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
         assert_eq!(s.key, "name");
         assert_eq!(s.value, 32);
@@ -545,6 +564,55 @@ mod tests {
         assert_eq!(i, 32);
     }
 
+    #[test]
+    fn test_extract_enum_value() {
+        let mut router = Router::<()>::build();
+        router.path("/{val}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: Test3 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i.val, TestEnum::Val1);
+
+        let mut path = Path::new("/val3/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: Result<Test3, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(i.is_err());
+        assert!(format!("{:?}", i).contains("unknown variant"));
+    }
+
+    #[test]
+    fn test_extract_errors() {
+        let mut router = Router::<()>::build();
+        router.path("/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: Result<Test1, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("wrong number of parameters"));
+
+        let s: Result<Test2, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("can not parse"));
+
+        let s: Result<(String, String), de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("wrong number of parameters"));
+
+        let s: Result<u32, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("can not parse"));
+    }
+
     // #[test]
     // fn test_extract_path_decode() {
     //     let mut router = Router::<()>::default();

router/src/path.rs

@@ -58,6 +58,7 @@ impl<T: RequestPath> Path<T> {
         &mut self.path
     }
 
+    /// Path
     pub fn path(&self) -> &str {
         let skip = self.skip as usize;
         let path = self.path.path();
@@ -68,7 +69,8 @@ impl<T: RequestPath> Path<T> {
         }
     }
 
-    pub fn set_path(&mut self, path: T) {
+    /// Reset inner path
+    pub fn set(&mut self, path: T) {
         self.skip = 0;
         self.path = path;
         self.segments.clear();
@@ -123,7 +125,7 @@ impl<T: RequestPath> Path<T> {
         }
     }
 
-    /// Get unprocessed part of path
+    /// Get unprocessed part of the path
     pub fn unprocessed(&self) -> &str {
         &self.path.path()[(self.skip as usize)..]
     }