Should write percent encoded cookies to HTTP response

Add cookie middleware test

src/httpresponse.rs

@@ -161,7 +161,7 @@ impl HttpResponse {
         let mut count: usize = 0;
         for v in vals {
             if let Ok(s) = v.to_str() {
-                if let Ok(c) = Cookie::parse(s) {
+                if let Ok(c) = Cookie::parse_encoded(s) {
                     if c.name() == name {
                         count += 1;
                         continue;
@@ -327,7 +327,7 @@ impl<'a> Iterator for CookieIter<'a> {
     #[inline]
     fn next(&mut self) -> Option<Cookie<'a>> {
         for v in self.iter.by_ref() {
-            if let Ok(c) = Cookie::parse(v.to_str().ok()?) {
+            if let Ok(c) = Cookie::parse_encoded(v.to_str().ok()?) {
                 return Some(c);
             }
         }

src/middleware/session.rs

@@ -255,7 +255,10 @@ impl<S: 'static, T: SessionBackend<S>> Middleware<S> for SessionStorage<T, S> {
                     .insert(Arc::new(SessionImplCell(RefCell::new(Box::new(sess)))));
                 FutOk(None)
             }
-            Err(err) => FutErr(err),
+            Err(err) => {
+                println!("Session::from_request error={:?}", &err);
+                FutErr(err)
+            }
         });
         Ok(Started::Future(Box::new(fut)))
     }
@@ -410,7 +413,7 @@ impl CookieSessionInner {
         }
 
         for cookie in jar.delta() {
-            let val = HeaderValue::from_str(&cookie.to_string())?;
+            let val = HeaderValue::from_str(&cookie.encoded().to_string())?;
             resp.headers_mut().append(header::SET_COOKIE, val);
         }
 
@@ -419,11 +422,18 @@ impl CookieSessionInner {
 
     fn load<S>(&self, req: &mut HttpRequest<S>) -> HashMap<String, String> {
         if let Ok(cookies) = req.cookies() {
+            println!("Load cookies");
             for cookie in cookies.iter() {
                 if cookie.name() == self.name {
+                    println!("cookie.name()={} | value={}", cookie.name(), cookie.value());
                     let mut jar = CookieJar::new();
                     jar.add_original(cookie.clone());
 
+                    println!("Jar cookies:");
+                    for cookie in jar.iter() {
+                        println!("cookie.name()={} | value={}", cookie.name(), cookie.value());
+                    }
+
                     let cookie_opt = match self.security {
                         CookieSecurity::Signed => jar.signed(&self.key).get(&self.name),
                         CookieSecurity::Private => {
@@ -431,9 +441,14 @@ impl CookieSessionInner {
                         }
                     };
                     if let Some(cookie) = cookie_opt {
-                        if let Ok(val) = serde_json::from_str(cookie.value()) {
-                            return val;
+                        println!("Loaded secure cookie");
+                        match serde_json::from_str(cookie.value()) {
+                            Ok(val) => return val,
+                            Err(error) => println!("serde_json Error: {}", error)
                         }
+                        //if let Ok(val) = serde_json::from_str(cookie.value()) {
+                        //    return val;
+                        //}
                     }
                 }
             }

tests/test_middleware.rs

@@ -993,3 +993,78 @@ fn test_resource_middleware_async_chain_with_error() {
     assert_eq!(num2.load(Ordering::Relaxed), 1);
     assert_eq!(num3.load(Ordering::Relaxed), 1);
 }
+
+#[cfg(feature = "session")]
+#[test]
+fn test_session_storage_middleware() {
+    use actix_web::middleware::session::{RequestSession, SessionStorage, CookieSessionBackend};
+
+    const SIMPLE_NAME: &'static str = "simple";
+    const SIMPLE_PAYLOAD: &'static str = "kantan";
+    const COMPLEX_NAME: &'static str = "test";
+    const COMPLEX_PAYLOAD: &'static str = "FJc%26continue_url%3Dhttp%253A%252F%252Fconnectivitycheck.gstatic.com%252Fgenerate_204";
+
+    let mut srv = test::TestServer::with_factory(move || {
+        App::new()
+            .middleware(SessionStorage::new(CookieSessionBackend::signed(&[0; 32]).secure(false)))
+            .resource("/index", move |r| {
+                r.f(|req| {
+                    //let res = req.session().set(COMPLEX_NAME, COMPLEX_PAYLOAD);
+                    //assert!(res.is_ok());
+                    //let value = req.session().get::<String>(COMPLEX_NAME);
+                    //assert!(value.is_ok());
+                    //let value = value.unwrap();
+                    //assert!(value.is_some());
+                    //assert_eq!(value.unwrap(), COMPLEX_PAYLOAD);
+
+                    let res = req.session().set(SIMPLE_NAME, SIMPLE_PAYLOAD);
+                    assert!(res.is_ok());
+                    let value = req.session().get::<String>(SIMPLE_NAME);
+                    assert!(value.is_ok());
+                    let value = value.unwrap();
+                    assert!(value.is_some());
+                    assert_eq!(value.unwrap(), SIMPLE_PAYLOAD);
+
+                    HttpResponse::Ok()
+                })
+            }).resource("/expect_cookie", move |r| {
+                r.f(|req| {
+                    let cookies = req.cookies().expect("To get cookies");
+                    println!("Cookies:");
+                    for cookie in cookies.iter() {
+                        println!("{}={}", cookie.name(), cookie.value());
+                    }
+
+                    let value = req.session().get::<String>(SIMPLE_NAME);
+                    assert!(value.is_ok());
+                    let value = value.unwrap();
+                    assert!(value.is_some());
+                    assert_eq!(value.unwrap(), SIMPLE_PAYLOAD);
+
+                    let value = req.session().get::<String>(COMPLEX_NAME);
+                    assert!(value.is_ok());
+                    let value = value.unwrap();
+                    assert!(value.is_some());
+                    assert_eq!(value.unwrap(), COMPLEX_PAYLOAD);
+
+                    HttpResponse::Ok()
+                })
+            })
+    });
+
+    let request = srv.get().uri(srv.url("/index")).finish().unwrap();
+    let response = srv.execute(request.send()).unwrap();
+
+    assert!(response.headers().contains_key("set-cookie"));
+    let set_cookie = response.headers().get("set-cookie");
+    assert!(set_cookie.is_some());
+    let set_cookie = set_cookie.unwrap().to_str().expect("Convert to str");
+
+    let request = srv.get()
+        .uri(srv.url("/expect_cookie"))
+        .header("cookie", set_cookie.split(';').next().unwrap())
+        .finish()
+        .unwrap();
+
+    srv.execute(request.send()).unwrap();
+}