mirror of
https://github.com/storytold/artcraft-services.git
synced 2026-11-19 08:53:03 +01:00
address review: one query per file with Args, order every session insert against a reset, re-purge session cache after commit
This commit is contained in:
1 parent
a0626b5bbd
commit
ed360d5dc0
14 files changed
+177
-119
No files matched your search
-12
@@ -1,12 +0,0 @@
|
||||
{
|
||||
"db_name": "MySQL",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"nullable": [],
|
||||
"parameters": {
|
||||
"Right": 6
|
||||
}
|
||||
},
|
||||
"hash": "2ddd5589138c822385b39dde58fc0d44ffa003b09018f1799e243d8f09530981",
|
||||
"query": "\nINSERT INTO user_sessions (\n token,\n user_token,\n maybe_impersonation_user_token,\n ip_address_creation,\n maybe_creation_type,\n expires_at\n)\nVALUES (?, ?, ?, ?, ?, ?)\n "
|
||||
}
|
||||
-12
@@ -1,12 +0,0 @@
|
||||
{
|
||||
"db_name": "MySQL",
|
||||
"query": "\nINSERT INTO user_sessions (\n token,\n user_token,\n maybe_impersonation_user_token,\n ip_address_creation,\n expires_at\n)\nVALUES (?, ?, ?, ?, ?)\n ",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
"Right": 5
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "ba5b0a542d4b95b781077b8895529d222dd682eb28c9d00031a820ec6f37e095"
|
||||
}
|
||||
-12
@@ -1,12 +0,0 @@
|
||||
{
|
||||
"db_name": "MySQL",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"nullable": [],
|
||||
"parameters": {
|
||||
"Right": 4
|
||||
}
|
||||
},
|
||||
"hash": "eb5fdd0e93978edfbe97c58238ea81f0c21dba047975beb53a39224894e9d41c",
|
||||
"query": "\nINSERT INTO user_sessions (token, user_token, ip_address_creation, maybe_creation_type, expires_at)\nSELECT ?, token, ?, ?, NOW() + INTERVAL 1 YEAR FROM users\nWHERE token = ? AND is_banned = FALSE AND user_deleted_at IS NULL AND mod_deleted_at IS NULL\n"
|
||||
}
|
||||
+10
-3
@@ -2,7 +2,8 @@ use anyhow::anyhow;
|
||||
use sqlx::{MySql, Transaction};
|
||||
|
||||
use errors::AnyhowResult;
|
||||
use crate::queries::users::user_sessions::revoke_all_user_sessions::{list_live_session_tokens, revoke_all_user_sessions};
|
||||
use crate::queries::users::user_sessions::list_live_session_tokens::{list_live_session_tokens, ListLiveSessionTokensArgs};
|
||||
use crate::queries::users::user_sessions::revoke_all_user_sessions::{revoke_all_user_sessions, RevokeAllUserSessionsArgs};
|
||||
use tokens::tokens::password_reset::PasswordResetToken;
|
||||
use tokens::tokens::users::UserToken;
|
||||
|
||||
@@ -70,7 +71,10 @@ LIMIT 1
|
||||
|
||||
// NB: Recovery must lock out whoever held the account before it, so revoke every existing session
|
||||
// in the same transaction. The handler issues a fresh session after commit.
|
||||
let revoked_session_tokens = match list_live_session_tokens(args.user_token, &mut *args.mysql_transaction).await {
|
||||
let revoked_session_tokens = match list_live_session_tokens(ListLiveSessionTokensArgs {
|
||||
user_token: args.user_token,
|
||||
mysql_executor: &mut *args.mysql_transaction,
|
||||
}).await {
|
||||
Ok(tokens) => tokens,
|
||||
Err(err) => {
|
||||
let _r = args.mysql_transaction.rollback().await.ok();
|
||||
@@ -78,7 +82,10 @@ LIMIT 1
|
||||
}
|
||||
};
|
||||
|
||||
let query_result = revoke_all_user_sessions(args.user_token, &mut *args.mysql_transaction).await;
|
||||
let query_result = revoke_all_user_sessions(RevokeAllUserSessionsArgs {
|
||||
user_token: args.user_token,
|
||||
mysql_executor: &mut *args.mysql_transaction,
|
||||
}).await;
|
||||
|
||||
if let Err(err) = query_result {
|
||||
let _r = args.mysql_transaction.rollback().await.ok();
|
||||
|
||||
+8
-7
@@ -16,17 +16,18 @@ where
|
||||
T: Executor<'c, Database = MySql>,
|
||||
{
|
||||
let token = UserSessionToken::generate();
|
||||
let inserted = sqlx::query!(
|
||||
// NB: runtime query; FOR UPDATE takes the user's row lock so this insert is ordered against a password reset.
|
||||
let inserted = sqlx::query(
|
||||
r#"
|
||||
INSERT INTO user_sessions (token, user_token, ip_address_creation, maybe_creation_type, expires_at)
|
||||
SELECT ?, token, ?, ?, NOW() + INTERVAL 1 YEAR FROM users
|
||||
WHERE token = ? AND is_banned = FALSE AND user_deleted_at IS NULL AND mod_deleted_at IS NULL
|
||||
"#,
|
||||
token.as_str(),
|
||||
args.ip_address,
|
||||
UserWebSessionCreationType::DeviceApproval.to_str(),
|
||||
args.user_token
|
||||
)
|
||||
FOR UPDATE
|
||||
"#)
|
||||
.bind(token.as_str())
|
||||
.bind(args.ip_address)
|
||||
.bind(UserWebSessionCreationType::DeviceApproval.to_str())
|
||||
.bind(args.user_token)
|
||||
.execute(args.mysql_executor)
|
||||
.await?;
|
||||
if inserted.rows_affected() != 1 {
|
||||
|
||||
+17
-10
@@ -30,7 +30,8 @@ pub async fn create_impersonated_user_session<'a, 'c, E>(
|
||||
{
|
||||
let session_token = UserSessionToken::generate();
|
||||
|
||||
sqlx::query!(
|
||||
// NB: runtime query; FOR UPDATE takes the user's row lock so this insert is ordered against a password reset.
|
||||
let result = sqlx::query(
|
||||
r#"
|
||||
INSERT INTO user_sessions (
|
||||
token,
|
||||
@@ -40,17 +41,23 @@ INSERT INTO user_sessions (
|
||||
maybe_creation_type,
|
||||
expires_at
|
||||
)
|
||||
VALUES (?, ?, ?, ?, ?, ?)
|
||||
"#,
|
||||
session_token.as_str(),
|
||||
args.user_token.as_str(),
|
||||
args.impersonator_user_token.as_str(),
|
||||
args.ip_address,
|
||||
UserWebSessionCreationType::Impersonation.to_str(),
|
||||
args.expires_at,
|
||||
)
|
||||
SELECT ?, token, ?, ?, ?, ?
|
||||
FROM users
|
||||
WHERE token = ?
|
||||
FOR UPDATE
|
||||
"#)
|
||||
.bind(session_token.as_str())
|
||||
.bind(args.impersonator_user_token.as_str())
|
||||
.bind(args.ip_address)
|
||||
.bind(UserWebSessionCreationType::Impersonation.to_str())
|
||||
.bind(args.expires_at)
|
||||
.bind(args.user_token.as_str())
|
||||
.execute(args.mysql_executor)
|
||||
.await?;
|
||||
|
||||
if result.rows_affected() == 0 {
|
||||
return Err(sqlx::Error::RowNotFound);
|
||||
}
|
||||
|
||||
Ok(session_token)
|
||||
}
|
||||
+25
-17
@@ -4,19 +4,26 @@ use sqlx::{Executor, MySql};
|
||||
use tokens::tokens::user_sessions::UserSessionToken;
|
||||
use tokens::tokens::users::UserToken;
|
||||
|
||||
/// Creates a password-login session only if `users.password_version` still equals the version the
|
||||
/// caller verified the password against. The version check and the INSERT are one statement, and
|
||||
/// the `FOR UPDATE` row lock orders it against a password reset (which updates that row, then
|
||||
/// revokes sessions, in one transaction): either the session exists before the reset's revoke, or
|
||||
/// the version has moved and no session is created. Returns `Ok(None)` when the version moved.
|
||||
pub async fn create_user_session_if_password_version<'e, 'c: 'e, E>(
|
||||
user_token: &UserToken,
|
||||
expected_password_version: u32,
|
||||
ip_address: &str,
|
||||
mysql_executor: E,
|
||||
pub struct CreateUserSessionIfPasswordVersionArgs<'a, T> {
|
||||
pub user_token: &'a UserToken,
|
||||
/// The `password_version` the caller verified a password against. `None` for paths that verify no
|
||||
/// password (SSO): the version is then read inside the statement, under the same row lock.
|
||||
pub maybe_expected_password_version: Option<u32>,
|
||||
pub ip_address: &'a str,
|
||||
pub creation_type: UserWebSessionCreationType,
|
||||
pub mysql_executor: T,
|
||||
}
|
||||
|
||||
/// Creates a session only if `users.password_version` still equals the expected version (when one is
|
||||
/// given). The version check and the INSERT are one statement, and the `FOR UPDATE` row lock orders
|
||||
/// it against a password reset (which updates that row, then revokes sessions, in one transaction):
|
||||
/// either the session exists before the reset's revoke, or it is created after the reset committed.
|
||||
/// Returns `Ok(None)` when the user is missing or the version moved.
|
||||
pub async fn create_user_session_if_password_version<'c, T>(
|
||||
args: CreateUserSessionIfPasswordVersionArgs<'_, T>,
|
||||
) -> Result<Option<UserSessionToken>, sqlx::Error>
|
||||
where
|
||||
E: 'e + Executor<'c, Database = MySql>,
|
||||
T: Executor<'c, Database = MySql>,
|
||||
{
|
||||
let session_token = UserSessionToken::generate();
|
||||
|
||||
@@ -33,15 +40,16 @@ INSERT INTO user_sessions (
|
||||
SELECT ?, token, ?, ?, NOW() + interval 1 year
|
||||
FROM users
|
||||
WHERE token = ?
|
||||
AND password_version = ?
|
||||
AND (? IS NULL OR password_version = ?)
|
||||
FOR UPDATE
|
||||
"#)
|
||||
.bind(session_token.as_str())
|
||||
.bind(ip_address)
|
||||
.bind(UserWebSessionCreationType::DirectLogin.to_str())
|
||||
.bind(user_token.as_str())
|
||||
.bind(expected_password_version)
|
||||
.execute(mysql_executor)
|
||||
.bind(args.ip_address)
|
||||
.bind(args.creation_type.to_str())
|
||||
.bind(args.user_token.as_str())
|
||||
.bind(args.maybe_expected_password_version)
|
||||
.bind(args.maybe_expected_password_version)
|
||||
.execute(args.mysql_executor)
|
||||
.await?;
|
||||
|
||||
if result.rows_affected() == 0 {
|
||||
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
use sqlx::{Executor, MySql};
|
||||
use tokens::tokens::users::UserToken;
|
||||
|
||||
pub struct ListLiveSessionTokensArgs<'a, T> {
|
||||
pub user_token: &'a UserToken,
|
||||
pub mysql_executor: T,
|
||||
}
|
||||
|
||||
/// Returns the tokens of the user's live sessions, so callers can purge their cache entries after revoking.
|
||||
pub async fn list_live_session_tokens<'c, T>(args: ListLiveSessionTokensArgs<'_, T>) -> Result<Vec<String>, sqlx::Error>
|
||||
where
|
||||
T: Executor<'c, Database = MySql>,
|
||||
{
|
||||
// NB: runtime (non-macro) query so no offline sqlx metadata is needed.
|
||||
sqlx::query_scalar::<_, String>("SELECT token FROM user_sessions WHERE user_token = ? AND deleted_at IS NULL")
|
||||
.bind(args.user_token.as_str())
|
||||
.fetch_all(args.mysql_executor)
|
||||
.await
|
||||
}
|
||||
@@ -10,4 +10,5 @@ pub mod find_approving_session;
|
||||
pub mod find_redeemed_session;
|
||||
pub mod get_user_session_by_token;
|
||||
pub mod get_user_session_by_token_light;
|
||||
pub mod list_live_session_tokens;
|
||||
pub mod revoke_all_user_sessions;
|
||||
+7
-20
@@ -1,28 +1,15 @@
|
||||
use sqlx::{Executor, MySql};
|
||||
use tokens::tokens::users::UserToken;
|
||||
|
||||
/// Returns the tokens of the user's live sessions, so callers can purge their cache entries after revoking.
|
||||
pub async fn list_live_session_tokens<'e, 'c: 'e, E>(
|
||||
user_token: &UserToken,
|
||||
mysql_executor: E,
|
||||
) -> Result<Vec<String>, sqlx::Error>
|
||||
where
|
||||
E: 'e + Executor<'c, Database = MySql>,
|
||||
{
|
||||
// NB: runtime (non-macro) query so no offline sqlx metadata is needed.
|
||||
sqlx::query_scalar::<_, String>("SELECT token FROM user_sessions WHERE user_token = ? AND deleted_at IS NULL")
|
||||
.bind(user_token.as_str())
|
||||
.fetch_all(mysql_executor)
|
||||
.await
|
||||
pub struct RevokeAllUserSessionsArgs<'a, T> {
|
||||
pub user_token: &'a UserToken,
|
||||
pub mysql_executor: T,
|
||||
}
|
||||
|
||||
/// Soft-deletes every live session of the user. Takes any executor so callers can run it inside a transaction.
|
||||
pub async fn revoke_all_user_sessions<'e, 'c: 'e, E>(
|
||||
user_token: &UserToken,
|
||||
mysql_executor: E,
|
||||
) -> Result<(), sqlx::Error>
|
||||
pub async fn revoke_all_user_sessions<'c, T>(args: RevokeAllUserSessionsArgs<'_, T>) -> Result<(), sqlx::Error>
|
||||
where
|
||||
E: 'e + Executor<'c, Database = MySql>,
|
||||
T: Executor<'c, Database = MySql>,
|
||||
{
|
||||
sqlx::query!(
|
||||
r#"
|
||||
@@ -32,9 +19,9 @@ WHERE
|
||||
user_token = ?
|
||||
AND deleted_at IS NULL
|
||||
"#,
|
||||
user_token.as_str(),
|
||||
args.user_token.as_str(),
|
||||
)
|
||||
.execute(mysql_executor)
|
||||
.execute(args.mysql_executor)
|
||||
.await?;
|
||||
|
||||
Ok(())
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! A login that verified the password against an older `password_version` (a reset committed in
|
||||
//! between) must not get a session. Needs the disposable local MySQL, like the other tests here.
|
||||
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::create_user_session_if_password_version;
|
||||
use enums::by_table::user_sessions::user_web_session_creation_type::UserWebSessionCreationType;
|
||||
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::{create_user_session_if_password_version, CreateUserSessionIfPasswordVersionArgs};
|
||||
use mysql_testing::fixtures::users::create_test_user;
|
||||
use mysql_testing::isolated::IsolatedTestDatabase;
|
||||
|
||||
@@ -14,7 +15,13 @@ async fn session_is_created_only_while_password_version_matches() {
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let ok = create_user_session_if_password_version(&user.user_token, version, "127.0.0.1", &db.pool).await.unwrap();
|
||||
let ok = create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
|
||||
user_token: &user.user_token,
|
||||
maybe_expected_password_version: Some(version),
|
||||
ip_address: "127.0.0.1",
|
||||
creation_type: UserWebSessionCreationType::DirectLogin,
|
||||
mysql_executor: &db.pool,
|
||||
}).await.unwrap();
|
||||
assert!(ok.is_some());
|
||||
|
||||
// Simulates the reset committing after the login looked the user up.
|
||||
@@ -24,7 +31,13 @@ async fn session_is_created_only_while_password_version_matches() {
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let stale = create_user_session_if_password_version(&user.user_token, version, "127.0.0.1", &db.pool).await.unwrap();
|
||||
let stale = create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
|
||||
user_token: &user.user_token,
|
||||
maybe_expected_password_version: Some(version),
|
||||
ip_address: "127.0.0.1",
|
||||
creation_type: UserWebSessionCreationType::DirectLogin,
|
||||
mysql_executor: &db.pool,
|
||||
}).await.unwrap();
|
||||
assert!(stale.is_none());
|
||||
let live: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM user_sessions WHERE user_token = ? AND deleted_at IS NULL")
|
||||
.bind(user.user_token.as_str())
|
||||
@@ -32,4 +45,14 @@ async fn session_is_created_only_while_password_version_matches() {
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(live, 2); // fixture session + the first login only
|
||||
|
||||
// No expected version (SSO): the session is created against whatever the current version is.
|
||||
let sso = create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
|
||||
user_token: &user.user_token,
|
||||
maybe_expected_password_version: None,
|
||||
ip_address: "127.0.0.1",
|
||||
creation_type: UserWebSessionCreationType::DirectLogin,
|
||||
mysql_executor: &db.pool,
|
||||
}).await.unwrap();
|
||||
assert!(sso.is_some());
|
||||
}
|
||||
+13
-8
@@ -16,8 +16,8 @@ use http_server_common::request::get_request_ip::get_request_ip;
|
||||
use log::{info, warn};
|
||||
use mysql_queries::queries::google_sign_in_accounts::get_google_sign_in_account_by_subject::get_google_sign_in_account;
|
||||
use mysql_queries::queries::user_referrals::insert_user_referral::{insert_user_referral, InsertUserReferralArgs};
|
||||
use mysql_queries::queries::users::user_sessions::create_user_session_with_transactor::create_user_session_with_transactor;
|
||||
use mysql_queries::utils::transactor::Transactor;
|
||||
use enums::by_table::user_sessions::user_web_session_creation_type::UserWebSessionCreationType;
|
||||
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::{create_user_session_if_password_version, CreateUserSessionIfPasswordVersionArgs};
|
||||
use sqlx::{Acquire, MySqlPool};
|
||||
use tokens::tokens::user_sessions::UserSessionToken;
|
||||
use tokens::tokens::users::UserToken;
|
||||
@@ -244,15 +244,20 @@ pub async fn google_sso_handler(
|
||||
|
||||
let ip_address = get_request_ip(&http_request);
|
||||
|
||||
let session_token = create_user_session_with_transactor(
|
||||
&user_token,
|
||||
&ip_address,
|
||||
Transactor::for_connection(&mut mysql_connection))
|
||||
// NB: no password is verified here, so the version is read inside the insert, under the user's row lock.
|
||||
let session_token = create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
|
||||
user_token: &user_token,
|
||||
maybe_expected_password_version: None,
|
||||
ip_address: &ip_address,
|
||||
creation_type: UserWebSessionCreationType::DirectLogin,
|
||||
mysql_executor: &mut *mysql_connection,
|
||||
})
|
||||
.await
|
||||
.map_err(|e| {
|
||||
warn!("error creating user session: {:?}", e);
|
||||
CommonWebError::from_anyhow_error(e)
|
||||
})?;
|
||||
CommonWebError::from_error(e)
|
||||
})?
|
||||
.ok_or(CommonWebError::NotAuthorized)?;
|
||||
|
||||
info!("new user session created");
|
||||
|
||||
|
||||
@@ -24,7 +24,8 @@ use mysql_queries::queries::users::user::get::lookup_user_for_login_by_username:
|
||||
use mysql_queries::queries::users::user_sessions::create_impersonated_user_session::{
|
||||
create_impersonated_user_session, CreateImpersonatedUserSessionArgs,
|
||||
};
|
||||
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::create_user_session_if_password_version;
|
||||
use mysql_queries::queries::users::user_sessions::create_user_session_if_password_version::{create_user_session_if_password_version, CreateUserSessionIfPasswordVersionArgs};
|
||||
use enums::by_table::user_sessions::user_web_session_creation_type::UserWebSessionCreationType;
|
||||
use password::bcrypt_confirm_password::bcrypt_confirm_password;
|
||||
use sqlx::MySqlPool;
|
||||
use tokens::tokens::user_sessions::UserSessionToken;
|
||||
@@ -164,8 +165,13 @@ pub async fn login_handler(
|
||||
// Normal login path — password matched.
|
||||
// NB: bound to the password_version we verified against, so a password reset that committed
|
||||
// after the lookup cannot be followed by a session for the old password.
|
||||
let token = match create_user_session_if_password_version(
|
||||
&user.token, user.password_version, &ip_address, &**mysql_pool).await
|
||||
let token = match create_user_session_if_password_version(CreateUserSessionIfPasswordVersionArgs {
|
||||
user_token: &user.token,
|
||||
maybe_expected_password_version: Some(user.password_version),
|
||||
ip_address: &ip_address,
|
||||
creation_type: UserWebSessionCreationType::DirectLogin,
|
||||
mysql_executor: &**mysql_pool,
|
||||
}).await
|
||||
{
|
||||
Ok(Some(token)) => token.to_string(),
|
||||
Ok(None) => {
|
||||
|
||||
+42
-12
@@ -163,18 +163,15 @@ pub async fn password_reset_redeem_handler(
|
||||
};
|
||||
|
||||
// Revoked sessions would otherwise keep passing the Redis session cache until it expires.
|
||||
match redis_ttl_cache.get_connection() {
|
||||
Ok(mut redis) => {
|
||||
for session_token in &revoked_session_tokens {
|
||||
for key in [RedisCacheKeys::session_record_user(session_token), RedisCacheKeys::session_record_light(session_token)] {
|
||||
if let Err(err) = redis.delete_from_cache(&key) {
|
||||
warn!("failed to purge revoked session cache: {err}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(err) => warn!("failed to purge revoked session cache (no redis connection): {err}"),
|
||||
}
|
||||
// A session check that read its row before the commit can still fill the cache after this first
|
||||
// purge, so purge again after a delay longer than a cache fill takes; anything later than that
|
||||
// is bounded by the cache TTL.
|
||||
purge_session_cache(&redis_ttl_cache, &revoked_session_tokens);
|
||||
let delayed_cache = redis_ttl_cache.get_ref().clone();
|
||||
tokio::spawn(async move {
|
||||
tokio::time::sleep(SESSION_CACHE_RECHECK_DELAY).await;
|
||||
purge_session_cache(&delayed_cache, &revoked_session_tokens);
|
||||
});
|
||||
|
||||
let create_session_result =
|
||||
create_user_session(&transaction_and_state.reset_state.user_token.0, &ip_address, &mysql_pool).await;
|
||||
@@ -221,3 +218,36 @@ pub async fn password_reset_redeem_handler(
|
||||
.content_type("application/json")
|
||||
.body(body))
|
||||
}
|
||||
|
||||
/// Longer than a session check's DB read plus Redis write normally takes.
|
||||
const SESSION_CACHE_RECHECK_DELAY: std::time::Duration = std::time::Duration::from_secs(5);
|
||||
|
||||
fn session_cache_keys(session_tokens: &[String]) -> Vec<String> {
|
||||
session_tokens.iter()
|
||||
.flat_map(|t| [RedisCacheKeys::session_record_user(t), RedisCacheKeys::session_record_light(t)])
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn purge_session_cache(redis_ttl_cache: &RedisTtlCache, session_tokens: &[String]) {
|
||||
match redis_ttl_cache.get_connection() {
|
||||
Ok(mut redis) => {
|
||||
for key in session_cache_keys(session_tokens) {
|
||||
if let Err(err) = redis.delete_from_cache(&key) {
|
||||
warn!("failed to purge revoked session cache: {err}");
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(err) => warn!("failed to purge revoked session cache (no redis connection): {err}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::session_cache_keys;
|
||||
|
||||
#[test]
|
||||
fn purges_both_cache_entries_for_every_revoked_session() {
|
||||
let keys = session_cache_keys(&["a".to_string(), "b".to_string()]);
|
||||
assert_eq!(keys, vec!["ses_user:a", "ses_light:a", "ses_user:b", "ses_light:b"]);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user