update to 2.0.0

Author: jbr

Cargo.toml

@@ -6,10 +6,7 @@ edition = "2018"
 
 [dependencies]
 redis = { version = "0.16.0", features = ["aio"] }
-async-session = "1.0.2"
+async-session = "2.0.0"
 
 [dev-dependencies]
 async-std = { version = "1.6.2", features = ["attributes"] }
-
-[patch.crates-io]
-async-session = { git = "https://github.com/jbr/async-session", branch = "tide" }

src/lib.rs

@@ -9,8 +9,8 @@
 //! let mut session = Session::new();
 //! session.insert("key", "value")?;
 //!
-//! let cookie_value = store.store_session(session).await.unwrap();
-//! let session = store.load_session(cookie_value).await.unwrap();
+//! let cookie_value = store.store_session(session).await?.unwrap();
+//! let session = store.load_session(cookie_value).await?.unwrap();
 //! assert_eq!(&session.get::<String>("key").unwrap(), "value");
 //! # Ok(()) }) }
 //! ```
@@ -115,32 +115,33 @@ impl RedisSessionStore {
 
 #[async_trait]
 impl SessionStore for RedisSessionStore {
-    async fn load_session(&self, cookie_value: String) -> Option<Session> {
-        let id = Session::id_from_cookie_value(&cookie_value).ok()?;
-        let mut connection = self.connection().await.ok()?;
-        let record: Option<String> = connection.get(self.prefix_key(id)).await.ok()?;
+    async fn load_session(&self, cookie_value: String) -> Result<Option<Session>> {
+        let id = Session::id_from_cookie_value(&cookie_value)?;
+        let mut connection = self.connection().await?;
+        let record: Option<String> = connection.get(self.prefix_key(id)).await?;
         match record {
-            Some(value) => serde_json::from_str(&value).ok()?,
-            None => None,
+            Some(value) => Ok(serde_json::from_str(&value)?),
+            None => Ok(None),
         }
     }
 
-    async fn store_session(&self, session: Session) -> Option<String> {
+    async fn store_session(&self, session: Session) -> Result<Option<String>> {
         let id = self.prefix_key(session.id());
-        let string = serde_json::to_string(&session).ok()?;
+        let string = serde_json::to_string(&session)?;
 
-        let mut connection = self.connection().await.ok()?;
+        let mut connection = self.connection().await?;
 
         match session.expires_in() {
-            None => connection.set(id, string).await.ok()?,
+            None => connection.set(id, string).await?,
 
-            Some(expiry) => connection
-                .set_ex(id, string, expiry.as_secs() as usize)
-                .await
-                .ok()?,
+            Some(expiry) => {
+                connection
+                    .set_ex(id, string, expiry.as_secs() as usize)
+                    .await?
+            }
         };
 
-        session.into_cookie_value()
+        Ok(session.into_cookie_value())
     }
 
     async fn destroy_session(&self, session: Session) -> Result {
@@ -183,9 +184,9 @@ mod tests {
         let mut session = Session::new();
         session.insert("key", "value")?;
         let cloned = session.clone();
-        let cookie_value = store.store_session(session).await.unwrap();
+        let cookie_value = store.store_session(session).await?.unwrap();
 
-        let loaded_session = store.load_session(cookie_value).await.unwrap();
+        let loaded_session = store.load_session(cookie_value).await?.unwrap();
         assert_eq!(cloned.id(), loaded_session.id());
         assert_eq!("value", &loaded_session.get::<String>("key").unwrap());
 
@@ -199,13 +200,13 @@ mod tests {
         let mut session = Session::new();
 
         session.insert("key", "value")?;
-        let cookie_value = store.store_session(session).await.unwrap();
+        let cookie_value = store.store_session(session).await?.unwrap();
 
-        let mut session = store.load_session(cookie_value.clone()).await.unwrap();
+        let mut session = store.load_session(cookie_value.clone()).await?.unwrap();
         session.insert("key", "other value")?;
-        assert_eq!(None, store.store_session(session).await);
+        assert_eq!(None, store.store_session(session).await?);
 
-        let session = store.load_session(cookie_value.clone()).await.unwrap();
+        let session = store.load_session(cookie_value.clone()).await?.unwrap();
         assert_eq!(&session.get::<String>("key").unwrap(), "other value");
 
         assert_eq!(1, store.count().await.unwrap());
@@ -218,18 +219,18 @@ mod tests {
         let mut session = Session::new();
         session.expire_in(Duration::from_secs(5));
         let original_expires = session.expiry().unwrap().clone();
-        let cookie_value = store.store_session(session).await.unwrap();
+        let cookie_value = store.store_session(session).await?.unwrap();
 
-        let mut session = store.load_session(cookie_value.clone()).await.unwrap();
+        let mut session = store.load_session(cookie_value.clone()).await?.unwrap();
         let ttl = store.ttl_for_session(&session).await?;
         assert!(ttl > 3 && ttl < 5);
 
         assert_eq!(session.expiry().unwrap(), &original_expires);
         session.expire_in(Duration::from_secs(10));
         let new_expires = session.expiry().unwrap().clone();
-        store.store_session(session).await;
+        store.store_session(session).await?;
 
-        let session = store.load_session(cookie_value.clone()).await.unwrap();
+        let session = store.load_session(cookie_value.clone()).await?.unwrap();
         let ttl = store.ttl_for_session(&session).await?;
         assert!(ttl > 8 && ttl < 10);
         assert_eq!(session.expiry().unwrap(), &new_expires);
@@ -250,18 +251,18 @@ mod tests {
         session.insert("key", "value")?;
         let cloned = session.clone();
 
-        let cookie_value = store.store_session(session).await.unwrap();
+        let cookie_value = store.store_session(session).await?.unwrap();
 
         assert!(store.ttl_for_session(&cloned).await? > 1);
 
-        let loaded_session = store.load_session(cookie_value.clone()).await.unwrap();
+        let loaded_session = store.load_session(cookie_value.clone()).await?.unwrap();
         assert_eq!(cloned.id(), loaded_session.id());
         assert_eq!("value", &loaded_session.get::<String>("key").unwrap());
 
         assert!(!loaded_session.is_expired());
 
         task::sleep(Duration::from_secs(2)).await;
-        assert_eq!(None, store.load_session(cookie_value).await);
+        assert_eq!(None, store.load_session(cookie_value).await?);
 
         Ok(())
     }
@@ -270,14 +271,14 @@ mod tests {
     async fn destroying_a_single_session() -> Result {
         let store = test_store().await;
         for _ in 0..3i8 {
-            store.store_session(Session::new()).await;
+            store.store_session(Session::new()).await?;
         }
 
-        let cookie = store.store_session(Session::new()).await.unwrap();
+        let cookie = store.store_session(Session::new()).await?.unwrap();
         assert_eq!(4, store.count().await?);
-        let session = store.load_session(cookie.clone()).await.unwrap();
+        let session = store.load_session(cookie.clone()).await?.unwrap();
         store.destroy_session(session.clone()).await.unwrap();
-        assert_eq!(None, store.load_session(cookie).await);
+        assert_eq!(None, store.load_session(cookie).await?);
         assert_eq!(3, store.count().await?);
 
         // attempting to destroy the session again is not an error
@@ -289,7 +290,7 @@ mod tests {
     async fn clearing_the_whole_store() -> Result {
         let store = test_store().await;
         for _ in 0..3i8 {
-            store.store_session(Session::new()).await;
+            store.store_session(Session::new()).await?;
         }
 
         assert_eq!(3, store.count().await?);
@@ -307,19 +308,19 @@ mod tests {
         store.clear_store().await?;
 
         for _ in 0..3i8 {
-            store.store_session(Session::new()).await;
+            store.store_session(Session::new()).await?;
         }
 
         let mut session = Session::new();
 
         session.insert("key", "value")?;
-        let cookie_value = store.store_session(session).await.unwrap();
+        let cookie_value = store.store_session(session).await?.unwrap();
 
-        let mut session = store.load_session(cookie_value.clone()).await.unwrap();
+        let mut session = store.load_session(cookie_value.clone()).await?.unwrap();
         session.insert("key", "other value")?;
-        assert_eq!(None, store.store_session(session).await);
+        assert_eq!(None, store.store_session(session).await?);
 
-        let session = store.load_session(cookie_value.clone()).await.unwrap();
+        let session = store.load_session(cookie_value.clone()).await?.unwrap();
         assert_eq!(&session.get::<String>("key").unwrap(), "other value");
 
         assert_eq!(4, store.count().await.unwrap());
@@ -329,7 +330,7 @@ mod tests {
 
         assert_eq!(0, other_store.count().await.unwrap());
         for _ in 0..3i8 {
-            other_store.store_session(Session::new()).await;
+            other_store.store_session(Session::new()).await?;
         }
 
         other_store.clear_store().await?;