diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 000000000..13566b81b --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/actix-extras.iml b/.idea/actix-extras.iml new file mode 100644 index 000000000..cbb03d3f1 --- /dev/null +++ b/.idea/actix-extras.iml @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 000000000..64e1ffd8a --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 000000000..35eb1ddfb --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/actix-identity/CHANGES.md b/actix-identity/CHANGES.md index c06efddc4..6b0b09bf4 100644 --- a/actix-identity/CHANGES.md +++ b/actix-identity/CHANGES.md @@ -2,6 +2,10 @@ ## Unreleased +## 0.7.0 + +- Updated the usage of HashMap with serde Map to be compatible with `actix-session@0.9.0`. + ## 0.6.0 - Add `error` module. diff --git a/actix-identity/Cargo.toml b/actix-identity/Cargo.toml index cadff8f23..4667a20db 100644 --- a/actix-identity/Cargo.toml +++ b/actix-identity/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "actix-identity" -version = "0.6.0" +version = "0.7.0" authors = [ "Nikolay Kim ", "Luca Palmieri ", @@ -19,19 +19,20 @@ all-features = true [dependencies] actix-service = "2" -actix-session = "0.8" +actix-session = "0.9" actix-utils = "3" actix-web = { version = "4", default-features = false, features = ["cookies", "secure-cookies"] } derive_more = "0.99.7" futures-core = "0.3.7" serde = { version = "1", features = ["derive"] } +serde_json = "1.0.108" tracing = { version = "0.1.30", default-features = false, features = ["log"] } [dev-dependencies] actix-http = "3" actix-web = { version = "4", default-features = false, features = ["macros", "cookies", "secure-cookies"] } -actix-session = { version = "0.8", features = ["redis-rs-session", "cookie-session"] } +actix-session = { version = "0.9", features = ["redis-rs-session", "cookie-session"] } env_logger = "0.10" reqwest = { version = "0.11", default-features = false, features = ["cookies", "json"] } diff --git a/actix-identity/src/identity.rs b/actix-identity/src/identity.rs index 9a75ede72..735c329ca 100644 --- a/actix-identity/src/identity.rs +++ b/actix-identity/src/identity.rs @@ -6,6 +6,7 @@ use actix_web::{ http::StatusCode, Error, FromRequest, HttpMessage, HttpRequest, HttpResponse, }; +use serde_json::Value; use crate::{ config::LogoutBehaviour, @@ -153,13 +154,17 @@ impl Identity { /// ``` pub fn login(ext: &Extensions, id: String) -> Result { let inner = IdentityInner::extract(ext); - inner.session.insert(ID_KEY, id)?; + inner.session.insert(ID_KEY, Value::from(id)); let now = OffsetDateTime::now_utc().unix_timestamp(); if inner.is_login_deadline_enabled { - inner.session.insert(LOGIN_UNIX_TIMESTAMP_KEY, now)?; + inner + .session + .insert(LOGIN_UNIX_TIMESTAMP_KEY, Value::from(now)); } if inner.is_visit_deadline_enabled { - inner.session.insert(LAST_VISIT_UNIX_TIMESTAMP_KEY, now)?; + inner + .session + .insert(LAST_VISIT_UNIX_TIMESTAMP_KEY, Value::from(now)); } inner.session.renew(); Ok(Self(inner)) @@ -230,7 +235,9 @@ impl Identity { pub(crate) fn set_last_visited_at(&self) -> Result<(), LoginError> { let now = OffsetDateTime::now_utc().unix_timestamp(); - self.0.session.insert(LAST_VISIT_UNIX_TIMESTAMP_KEY, now)?; + self.0 + .session + .insert(LAST_VISIT_UNIX_TIMESTAMP_KEY, Value::from(now)); Ok(()) } } diff --git a/actix-identity/tests/integration/test_app.rs b/actix-identity/tests/integration/test_app.rs index 89ba665ed..de288d369 100644 --- a/actix-identity/tests/integration/test_app.rs +++ b/actix-identity/tests/integration/test_app.rs @@ -4,6 +4,7 @@ use actix_identity::{config::IdentityMiddlewareBuilder, Identity, IdentityMiddle use actix_session::{Session, SessionStatus}; use actix_web::{web, App, HttpMessage, HttpRequest, HttpResponse, HttpServer}; use serde::{Deserialize, Serialize}; +use serde_json::Value; use crate::fixtures::session_middleware; @@ -136,7 +137,7 @@ async fn increment(session: Session, user: Option) -> HttpResponse { .get::("counter") .unwrap_or(Some(0)) .map_or(1, |inner| inner + 1); - session.insert("counter", counter).unwrap(); + session.insert("counter", Value::from(counter)); HttpResponse::Ok().json(&EndpointResponse { user_id, diff --git a/actix-session/CHANGES.md b/actix-session/CHANGES.md index cf840a947..cece30df9 100644 --- a/actix-session/CHANGES.md +++ b/actix-session/CHANGES.md @@ -2,6 +2,11 @@ ## Unreleased +## 0.9.0 + +- Replace the usages of `HashMap` with serde `Map`. +- Fix double serialization when inserting values into the session. + ## 0.8.0 - Set secure attribute when adding a session removal cookie. diff --git a/actix-session/Cargo.toml b/actix-session/Cargo.toml index 761bef971..ebe8c038c 100644 --- a/actix-session/Cargo.toml +++ b/actix-session/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "actix-session" -version = "0.8.0" +version = "0.9.0" authors = [ "Nikolay Kim ", "Luca Palmieri ", diff --git a/actix-session/examples/authentication.rs b/actix-session/examples/authentication.rs index 400971051..d0867e21d 100644 --- a/actix-session/examples/authentication.rs +++ b/actix-session/examples/authentication.rs @@ -5,6 +5,7 @@ use actix_web::{ middleware, web, App, Error, HttpResponse, HttpServer, Responder, }; use serde::{Deserialize, Serialize}; +use serde_json::Value; #[derive(Deserialize)] struct Credentials { @@ -54,7 +55,7 @@ async fn login( let credentials = credentials.into_inner(); match User::authenticate(credentials) { - Ok(user) => session.insert("user_id", user.id).unwrap(), + Ok(user) => session.insert("user_id", Value::from(user.id)), Err(err) => return Err(InternalError::from_response("", err).into()), }; diff --git a/actix-session/examples/basic.rs b/actix-session/examples/basic.rs index f1f08ae66..9e8e470d5 100644 --- a/actix-session/examples/basic.rs +++ b/actix-session/examples/basic.rs @@ -1,5 +1,6 @@ use actix_session::{storage::RedisActorSessionStore, Session, SessionMiddleware}; use actix_web::{cookie::Key, middleware, web, App, Error, HttpRequest, HttpServer, Responder}; +use serde_json::Value; /// simple handler async fn index(req: HttpRequest, session: Session) -> Result { @@ -8,9 +9,9 @@ async fn index(req: HttpRequest, session: Session) -> Result("counter")? { println!("SESSION value: {count}"); - session.insert("counter", count + 1)?; + session.insert("counter", Value::from(count + 1)); } else { - session.insert("counter", 1)?; + session.insert("counter", Value::from(1)); } Ok("Welcome!") diff --git a/actix-session/src/lib.rs b/actix-session/src/lib.rs index fbacce290..e27748960 100644 --- a/actix-session/src/lib.rs +++ b/actix-session/src/lib.rs @@ -69,6 +69,7 @@ //! //! ```no_run //! use actix_web::Error; +//! use serde_json::Value; //! use actix_session::Session; //! //! fn index(session: Session) -> Result<&'static str, Error> { @@ -76,9 +77,9 @@ //! if let Some(count) = session.get::("counter")? { //! println!("SESSION value: {}", count); //! // modify the session state -//! session.insert("counter", count + 1)?; +//! session.insert("counter", Value::from(count + 1)); //! } else { -//! session.insert("counter", 1)?; +//! session.insert("counter", Value::from(1)); //! } //! //! Ok("Welcome!") @@ -207,7 +208,7 @@ pub mod test_helpers { App, HttpResponse, Result, }; use serde::{Deserialize, Serialize}; - use serde_json::json; + use serde_json::{json, Value}; use crate::{ config::{CookieContentSecurity, PersistentSession, TtlExtensionPolicy}, @@ -238,7 +239,7 @@ pub mod test_helpers { .build(), ) .service(web::resource("/").to(|ses: Session| async move { - let _ = ses.insert("counter", 100); + ses.insert("counter", Value::from(100)); "test" })) .service(web::resource("/test/").to(|ses: Session| async move { @@ -286,7 +287,7 @@ pub mod test_helpers { .build(), ) .service(web::resource("/").to(|ses: Session| async move { - let _ = ses.insert("counter", 100); + ses.insert("counter", Value::from(100)); "test" })) .service(web::resource("/test/").to(|| async move { "no-changes-in-session" })), @@ -328,7 +329,7 @@ pub mod test_helpers { .build(), ) .service(web::resource("/").to(|ses: Session| async move { - let _ = ses.insert("counter", 100); + ses.insert("counter", Value::from(100)); "test" })) .service(web::resource("/test/").to(|| async move { "no-changes-in-session" })), @@ -674,7 +675,7 @@ pub mod test_helpers { .get::("counter") .unwrap_or(Some(0)) .map_or(1, |inner| inner + 1); - session.insert("counter", counter)?; + session.insert("counter", Value::from(counter)); Ok(HttpResponse::Ok().json(&IndexResponse { user_id, counter })) } @@ -693,7 +694,7 @@ pub mod test_helpers { async fn login(user_id: web::Json, session: Session) -> Result { let id = user_id.into_inner().user_id; - session.insert("user_id", &id)?; + session.insert("user_id", Value::from(id.clone())); session.renew(); let counter: i32 = session diff --git a/actix-session/src/middleware.rs b/actix-session/src/middleware.rs index 9bab74bf3..d640f6528 100644 --- a/actix-session/src/middleware.rs +++ b/actix-session/src/middleware.rs @@ -1,5 +1,5 @@ -use std::{collections::HashMap, convert::TryInto, fmt, future::Future, pin::Pin, rc::Rc}; - +use std::{ convert::TryInto, fmt, future::Future, pin::Pin, rc::Rc}; +use serde_json::{Map,Value}; use actix_utils::future::{ready, Ready}; use actix_web::{ body::MessageBody, @@ -360,7 +360,7 @@ fn extract_session_key(req: &ServiceRequest, config: &CookieConfiguration) -> Op async fn load_session_state( session_key: Option, storage_backend: &Store, -) -> Result<(Option, HashMap), actix_web::Error> { +) -> Result<(Option, Map), actix_web::Error> { if let Some(session_key) = session_key { match storage_backend.load(&session_key).await { Ok(state) => { @@ -378,7 +378,7 @@ async fn load_session_state( empty session." ); - Ok((None, HashMap::new())) + Ok((None, Map::new())) } } @@ -390,14 +390,14 @@ async fn load_session_state( "Invalid session state, creating a new empty session." ); - Ok((Some(session_key), HashMap::new())) + Ok((Some(session_key), Map::new())) } LoadError::Other(err) => Err(e500(err)), }, } } else { - Ok((None, HashMap::new())) + Ok((None, Map::new())) } } diff --git a/actix-session/src/session.rs b/actix-session/src/session.rs index 1cd20cd42..f76f90f51 100644 --- a/actix-session/src/session.rs +++ b/actix-session/src/session.rs @@ -1,11 +1,3 @@ -use std::{ - cell::{Ref, RefCell}, - collections::HashMap, - error::Error as StdError, - mem, - rc::Rc, -}; - use actix_utils::future::{ready, Ready}; use actix_web::{ body::BoxBody, @@ -15,7 +7,14 @@ use actix_web::{ }; use anyhow::Context; use derive_more::{Display, From}; -use serde::{de::DeserializeOwned, Serialize}; +use serde::de::DeserializeOwned; +use serde_json::{Map, Value}; +use std::{ + cell::{Ref, RefCell}, + error::Error as StdError, + mem, + rc::Rc, +}; /// The primary interface to access and modify session state. /// @@ -23,14 +22,15 @@ use serde::{de::DeserializeOwned, Serialize}; /// request handlers and it will be automatically extracted from the incoming request. /// /// ``` +/// use serde_json::Value; /// use actix_session::Session; /// /// async fn index(session: Session) -> actix_web::Result<&'static str> { /// // access session data /// if let Some(count) = session.get::("counter")? { -/// session.insert("counter", count + 1)?; +/// session.insert("counter", Value::from(count + 1)); /// } else { -/// session.insert("counter", 1)?; +/// session.insert("counter", Value::from(1)); /// } /// /// Ok("Welcome!") @@ -70,7 +70,7 @@ pub enum SessionStatus { #[derive(Default)] struct SessionInner { - state: HashMap, + state: Map, status: SessionStatus, } @@ -79,9 +79,9 @@ impl Session { /// /// It returns an error if it fails to deserialize as `T` the JSON value associated with `key`. pub fn get(&self, key: &str) -> Result, SessionGetError> { - if let Some(val_str) = self.0.borrow().state.get(key) { + if let Some(value) = self.0.borrow().state.get(key) { Ok(Some( - serde_json::from_str(val_str) + serde_json::from_value::(value.clone()) .with_context(|| { format!( "Failed to deserialize the JSON-encoded session data attached to key \ @@ -100,7 +100,7 @@ impl Session { /// Get all raw key-value data from the session. /// /// Note that values are JSON encoded. - pub fn entries(&self) -> Ref<'_, HashMap> { + pub fn entries(&self) -> Ref<'_, Map> { Ref::map(self.0.borrow(), |inner| &inner.state) } @@ -111,15 +111,8 @@ impl Session { /// Inserts a key-value pair into the session. /// - /// Any serializable value can be used and will be encoded as JSON in session data, hence why - /// only a reference to the value is taken. - /// - /// It returns an error if it fails to serialize `value` to JSON. - pub fn insert( - &self, - key: impl Into, - value: T, - ) -> Result<(), SessionInsertError> { + /// Any serializable value can be used and will be encoded as JSON in session data. + pub fn insert(&self, key: impl Into, value: Value) { let mut inner = self.0.borrow_mut(); if inner.status != SessionStatus::Purged { @@ -127,28 +120,14 @@ impl Session { inner.status = SessionStatus::Changed; } - let key = key.into(); - let val = serde_json::to_string(&value) - .with_context(|| { - format!( - "Failed to serialize the provided `{}` type instance as JSON in order to \ - attach as session data to the `{}` key", - std::any::type_name::(), - &key - ) - }) - .map_err(SessionInsertError)?; - - inner.state.insert(key, val); + inner.state.insert(key.into(), value); } - - Ok(()) } /// Remove value from the session. /// /// If present, the JSON encoded value is returned. - pub fn remove(&self, key: &str) -> Option { + pub fn remove(&self, key: &str) -> Option { let mut inner = self.0.borrow_mut(); if inner.status != SessionStatus::Purged { @@ -165,9 +144,9 @@ impl Session { /// /// Returns `None` if key was not present in session. Returns `T` if deserialization succeeds, /// otherwise returns un-deserialized JSON string. - pub fn remove_as(&self, key: &str) -> Option> { + pub fn remove_as(&self, key: &str) -> Option> { self.remove(key) - .map(|val_str| match serde_json::from_str(&val_str) { + .map(|value| match serde_json::from_value::(value.clone()) { Ok(val) => Ok(val), Err(_err) => { tracing::debug!( @@ -176,7 +155,7 @@ impl Session { std::any::type_name::() ); - Err(val_str) + Err(value) } }) } @@ -216,7 +195,7 @@ impl Session { #[allow(clippy::needless_pass_by_ref_mut)] pub(crate) fn set_session( req: &mut ServiceRequest, - data: impl IntoIterator, + data: impl IntoIterator, ) { let session = Session::get_session(&mut req.extensions_mut()); let mut inner = session.0.borrow_mut(); @@ -231,7 +210,7 @@ impl Session { #[allow(clippy::needless_pass_by_ref_mut)] pub(crate) fn get_changes( res: &mut ServiceResponse, - ) -> (SessionStatus, HashMap) { + ) -> (SessionStatus, Map) { if let Some(s_impl) = res .request() .extensions() @@ -240,7 +219,7 @@ impl Session { let state = mem::take(&mut s_impl.borrow_mut().state); (s_impl.borrow().status.clone(), state) } else { - (SessionStatus::Unchanged, HashMap::new()) + (SessionStatus::Unchanged, Map::new()) } } @@ -261,15 +240,16 @@ impl Session { /// # Examples /// ``` /// # use actix_web::*; +/// use serde_json::Value; /// use actix_session::Session; /// /// #[get("/")] /// async fn index(session: Session) -> Result { /// // access session data /// if let Some(count) = session.get::("counter")? { -/// session.insert("counter", count + 1)?; +/// session.insert("counter", Value::from(count + 1)); /// } else { -/// session.insert("counter", 1)?; +/// session.insert("counter", Value::from(1)); /// } /// /// let count = session.get::("counter")?.unwrap(); diff --git a/actix-session/src/storage/interface.rs b/actix-session/src/storage/interface.rs index 2b52c59ed..f9ab70f7a 100644 --- a/actix-session/src/storage/interface.rs +++ b/actix-session/src/storage/interface.rs @@ -1,11 +1,10 @@ -use std::collections::HashMap; - +use serde_json::{Map,Value}; use actix_web::cookie::time::Duration; use derive_more::Display; use super::SessionKey; -pub(crate) type SessionState = HashMap; +pub(crate) type SessionState = Map; /// The interface to retrieve and save the current session data from/to the chosen storage backend. /// diff --git a/actix-session/src/storage/redis_actor.rs b/actix-session/src/storage/redis_actor.rs index 975df10c9..2f801cb6a 100644 --- a/actix-session/src/storage/redis_actor.rs +++ b/actix-session/src/storage/redis_actor.rs @@ -276,9 +276,8 @@ impl SessionStore for RedisActorSessionStore { #[cfg(test)] mod tests { - use std::collections::HashMap; - use actix_web::cookie::time::Duration; + use serde_json::Map; use super::*; use crate::test_helpers::acceptance_test_suite; @@ -305,7 +304,7 @@ mod tests { let session_key = generate_session_key(); let initial_session_key = session_key.as_ref().to_owned(); let updated_session_key = store - .update(session_key, HashMap::new(), &Duration::seconds(1)) + .update(session_key, Map::new(), &Duration::seconds(1)) .await .unwrap(); assert_ne!(initial_session_key, updated_session_key.as_ref()); diff --git a/actix-session/src/storage/redis_rs.rs b/actix-session/src/storage/redis_rs.rs index 44332f8b4..f3b532661 100644 --- a/actix-session/src/storage/redis_rs.rs +++ b/actix-session/src/storage/redis_rs.rs @@ -289,10 +289,9 @@ impl RedisSessionStore { #[cfg(test)] mod tests { - use std::collections::HashMap; - use actix_web::cookie::time; use redis::AsyncCommands; + use serde_json::Map; use super::*; use crate::test_helpers::acceptance_test_suite; @@ -338,7 +337,7 @@ mod tests { let session_key = generate_session_key(); let initial_session_key = session_key.as_ref().to_owned(); let updated_session_key = store - .update(session_key, HashMap::new(), &time::Duration::seconds(1)) + .update(session_key, Map::new(), &time::Duration::seconds(1)) .await .unwrap(); assert_ne!(initial_session_key, updated_session_key.as_ref()); diff --git a/actix-session/tests/middleware.rs b/actix-session/tests/middleware.rs index 5058b8b11..8d7149b61 100644 --- a/actix-session/tests/middleware.rs +++ b/actix-session/tests/middleware.rs @@ -3,9 +3,10 @@ use actix_web::{ cookie::{time::Duration, Key}, test, web, App, Responder, }; +use serde_json::Value; async fn login(session: Session) -> impl Responder { - session.insert("user_id", "id").unwrap(); + session.insert("user_id", Value::from("id")); "Logged in" } diff --git a/actix-session/tests/opaque_errors.rs b/actix-session/tests/opaque_errors.rs index e896d93cd..e138adafd 100644 --- a/actix-session/tests/opaque_errors.rs +++ b/actix-session/tests/opaque_errors.rs @@ -1,4 +1,4 @@ -use std::{collections::HashMap, convert::TryInto}; +use std::convert::TryInto; use actix_session::{ storage::{LoadError, SaveError, SessionKey, SessionStore, UpdateError}, @@ -12,6 +12,7 @@ use actix_web::{ test, web, App, Responder, }; use anyhow::Error; +use serde_json::{Map, Value}; #[actix_web::test] async fn errors_are_opaque() { @@ -49,7 +50,7 @@ impl SessionStore for MockStore { async fn load( &self, _session_key: &SessionKey, - ) -> Result>, LoadError> { + ) -> Result>, LoadError> { Err(LoadError::Other(anyhow::anyhow!( "My error full of implementation details" ))) @@ -57,7 +58,7 @@ impl SessionStore for MockStore { async fn save( &self, - _session_state: HashMap, + _session_state: Map, _ttl: &Duration, ) -> Result { Ok("random_value".to_string().try_into().unwrap()) @@ -66,7 +67,7 @@ impl SessionStore for MockStore { async fn update( &self, _session_key: SessionKey, - _session_state: HashMap, + _session_state: Map, _ttl: &Duration, ) -> Result { #![allow(clippy::diverging_sub_expression)] @@ -85,7 +86,7 @@ impl SessionStore for MockStore { } async fn create_session(session: Session) -> impl Responder { - session.insert("user_id", "id").unwrap(); + session.insert("user_id", Value::from("id")); "Created" } diff --git a/actix-session/tests/session.rs b/actix-session/tests/session.rs index 53319e653..6e4c421ab 100644 --- a/actix-session/tests/session.rs +++ b/actix-session/tests/session.rs @@ -1,22 +1,23 @@ use actix_session::{SessionExt, SessionStatus}; use actix_web::{test, HttpResponse}; +use serde_json::Value; #[actix_web::test] async fn session() { let req = test::TestRequest::default().to_srv_request(); let session = req.get_session(); - session.insert("key", "value").unwrap(); + session.insert("key", Value::from("value")); let res = session.get::("key").unwrap(); assert_eq!(res, Some("value".to_string())); - session.insert("key2", "value2").unwrap(); + session.insert("key2", Value::from("value2")); session.remove("key"); let res = req.into_response(HttpResponse::Ok().finish()); let state: Vec<_> = res.get_session().entries().clone().into_iter().collect(); assert_eq!( state.as_slice(), - [("key2".to_string(), "\"value2\"".to_string())] + [("key2".to_string(), Value::from("value2".to_string()))] ); } @@ -25,7 +26,7 @@ async fn get_session() { let req = test::TestRequest::default().to_srv_request(); let session = req.get_session(); - session.insert("key", true).unwrap(); + session.insert("key", Value::from(true)); let res = session.get("key").unwrap(); assert_eq!(res, Some(true)); } @@ -35,7 +36,7 @@ async fn get_session_from_request_head() { let req = test::TestRequest::default().to_srv_request(); let session = req.get_session(); - session.insert("key", 10).unwrap(); + session.insert("key", Value::from(10)); let res = session.get::("key").unwrap(); assert_eq!(res, Some(10)); } @@ -62,8 +63,8 @@ async fn renew_session() { async fn session_entries() { let req = test::TestRequest::default().to_srv_request(); let session = req.get_session(); - session.insert("test_str", "val").unwrap(); - session.insert("test_str", 1).unwrap(); + session.insert("test_str", Value::from("val")); + session.insert("test_str", Value::from(1)); let map = session.entries(); map.contains_key("test_str"); map.contains_key("test_num"); @@ -73,13 +74,13 @@ async fn session_entries() { async fn insert_session_after_renew() { let session = test::TestRequest::default().to_srv_request().get_session(); - session.insert("test_val", "val").unwrap(); + session.insert("test_val", Value::from("val")); assert_eq!(session.status(), SessionStatus::Changed); session.renew(); assert_eq!(session.status(), SessionStatus::Renewed); - session.insert("test_val1", "val1").unwrap(); + session.insert("test_val1", Value::from("val1")); assert_eq!(session.status(), SessionStatus::Renewed); } @@ -87,12 +88,12 @@ async fn insert_session_after_renew() { async fn remove_session_after_renew() { let session = test::TestRequest::default().to_srv_request().get_session(); - session.insert("test_val", "val").unwrap(); + session.insert("test_val", Value::from("val")); session.remove("test_val").unwrap(); assert_eq!(session.status(), SessionStatus::Changed); session.renew(); - session.insert("test_val", "val").unwrap(); + session.insert("test_val", Value::from("val")); session.remove("test_val").unwrap(); assert_eq!(session.status(), SessionStatus::Renewed); }