#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct RefreshTokenRecord {
pub token_hash: String,
pub parent_token_hash: Option<String>,
pub login_id: i64,
pub tenant_id: i64,
pub key_version: u32,
pub expires_at: i64,
pub revoked: bool,
pub created_at: i64,
#[serde(default)]
pub client_id: Option<String>,
#[serde(default)]
pub scopes: Option<String>,
#[serde(default)]
pub username: Option<String>,
#[serde(default)]
pub user_id: Option<i64>,
}
#[cfg(feature = "db-sqlite")]
mod service {
use super::RefreshTokenRecord;
use crate::error::{GarrisonError, GarrisonResult};
use crate::protocol::jwt::JwtHandler;
use dbnexus::DbPool;
use sea_orm::{ConnectionTrait, DbBackend, Statement, Value};
use sha2::{Digest, Sha256};
use std::sync::{Arc, RwLock};
use uuid::Uuid;
pub struct RefreshTokenRotation {
pub pool: DbPool,
pub jwt_handler: Arc<JwtHandler>,
pub key_version: Arc<RwLock<u32>>,
}
impl RefreshTokenRotation {
pub fn new(
pool: DbPool,
jwt_handler: Arc<JwtHandler>,
key_version: Arc<RwLock<u32>>,
) -> Self {
Self {
pool,
jwt_handler,
key_version,
}
}
fn sha256_hex(s: &str) -> String {
let mut hasher = Sha256::new();
hasher.update(s.as_bytes());
let result = hasher.finalize();
result.iter().map(|b| format!("{:02x}", b)).collect()
}
fn now_unix() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.unwrap_or(0)
}
pub async fn rotate(&self, old_token: &str) -> GarrisonResult<(String, String)> {
let old_hash = Self::sha256_hex(old_token);
if self.detect_reuse(&old_hash).await? {
self.revoke_chain(&old_hash).await?;
return Err(GarrisonError::TokenRevoked(
"refresh token reuse detected, chain revoked".to_string(),
));
}
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-session::{}", e)))?;
let conn = session
.connection()
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-conn::{}", e)))?;
let select_stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT login_id, tenant_id, client_id, scopes, username, user_id \
FROM refresh_tokens WHERE token_hash = ? AND revoked = 0",
vec![Value::String(Some(old_hash.clone()))],
);
let row = conn
.query_one_raw(select_stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?
.ok_or_else(|| {
GarrisonError::InvalidToken(
"refresh token not found or already consumed".to_string(),
)
})?;
let login_id: String = row
.try_get("", "login_id")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
let tenant_id: i64 = row
.try_get("", "tenant_id")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
let client_id: Option<String> = row.try_get("", "client_id").ok().flatten();
let scopes: Option<String> = row.try_get("", "scopes").ok().flatten();
let username: Option<String> = row.try_get("", "username").ok().flatten();
let user_id: Option<i64> = row.try_get("", "user_id").ok().flatten();
let new_refresh = Uuid::new_v4().to_string();
let new_access = self.jwt_handler.sign(&login_id, 3600)?;
let new_hash = Self::sha256_hex(&new_refresh);
let now = Self::now_unix();
let kv = *self
.key_version
.read()
.expect("key_version RwLock 不应 poisoned");
let insert_stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"INSERT INTO refresh_tokens \
(token_hash, parent_token_hash, login_id, tenant_id, key_version, \
expires_at, revoked, created_at, client_id, scopes, username, user_id) \
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
vec![
Value::String(Some(new_hash.clone())),
Value::String(Some(old_hash.clone())),
Value::String(Some(login_id.clone())),
Value::BigInt(Some(tenant_id)),
Value::BigInt(Some(kv as i64)),
Value::BigInt(Some(now + 86400 * 7)),
Value::BigInt(Some(0)),
Value::BigInt(Some(now)),
client_id
.clone()
.map(|s| Value::String(Some(s)))
.unwrap_or(Value::String(None)),
scopes
.clone()
.map(|s| Value::String(Some(s)))
.unwrap_or(Value::String(None)),
username
.clone()
.map(|s| Value::String(Some(s)))
.unwrap_or(Value::String(None)),
user_id
.map(|i| Value::BigInt(Some(i)))
.unwrap_or(Value::BigInt(None)),
],
);
conn.execute_raw(insert_stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-insert::{}", e)))?;
let update_stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"UPDATE refresh_tokens SET revoked = 1 WHERE token_hash = ?",
vec![Value::String(Some(old_hash))],
);
conn.execute_raw(update_stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-update::{}", e)))?;
Ok((new_access, new_refresh))
}
pub async fn issue(
&self,
client_id: &str,
user_id: Option<i64>,
scopes: &[String],
username: Option<&str>,
login_id: i64,
tenant_id: i64,
ttl_seconds: i64,
) -> GarrisonResult<String> {
let refresh_token = Uuid::new_v4().to_string();
let token_hash = Self::sha256_hex(&refresh_token);
let now = Self::now_unix();
let kv = *self
.key_version
.read()
.expect("key_version RwLock 不应 poisoned");
let scopes_str = if scopes.is_empty() {
None
} else {
Some(scopes.join(" "))
};
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-session::{}", e)))?;
let conn = session
.connection()
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-conn::{}", e)))?;
let insert_stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"INSERT INTO refresh_tokens \
(token_hash, parent_token_hash, login_id, tenant_id, key_version, \
expires_at, revoked, created_at, client_id, scopes, username, user_id) \
VALUES (?, NULL, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?)",
vec![
Value::String(Some(token_hash)),
Value::BigInt(Some(login_id)),
Value::BigInt(Some(tenant_id)),
Value::BigInt(Some(kv as i64)),
Value::BigInt(Some(now + ttl_seconds)),
Value::BigInt(Some(now)),
Value::String(Some(client_id.to_string())),
scopes_str
.map(|s| Value::String(Some(s)))
.unwrap_or(Value::String(None)),
username
.map(|s| Value::String(Some(s.to_string())))
.unwrap_or(Value::String(None)),
user_id
.map(|i| Value::BigInt(Some(i)))
.unwrap_or(Value::BigInt(None)),
],
);
conn.execute_raw(insert_stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-insert::{}", e)))?;
Ok(refresh_token)
}
pub async fn validate(&self, token: &str) -> GarrisonResult<Option<RefreshTokenRecord>> {
let token_hash = Self::sha256_hex(token);
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-session::{}", e)))?;
let conn = session
.connection()
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-conn::{}", e)))?;
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT token_hash, parent_token_hash, login_id, tenant_id, \
key_version, expires_at, revoked, created_at, \
client_id, scopes, username, user_id \
FROM refresh_tokens WHERE token_hash = ? AND revoked = 0",
vec![Value::String(Some(token_hash.clone()))],
);
let row = conn
.query_one_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
match row {
Some(row) => {
let login_id: String = row
.try_get("", "login_id")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
let tenant_id: i64 = row
.try_get("", "tenant_id")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
let key_version: i64 = row
.try_get("", "key_version")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
let expires_at: i64 = row
.try_get("", "expires_at")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
let revoked: i64 = row
.try_get("", "revoked")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
let created_at: i64 = row
.try_get("", "created_at")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
let parent_token_hash: Option<String> =
row.try_get("", "parent_token_hash").ok().flatten();
let client_id: Option<String> = row.try_get("", "client_id").ok().flatten();
let scopes: Option<String> = row.try_get("", "scopes").ok().flatten();
let username: Option<String> = row.try_get("", "username").ok().flatten();
let user_id: Option<i64> = row.try_get("", "user_id").ok().flatten();
let login_id_i64: i64 = login_id.parse().unwrap_or(0);
Ok(Some(RefreshTokenRecord {
token_hash,
parent_token_hash,
login_id: login_id_i64,
tenant_id,
key_version: key_version as u32,
expires_at,
revoked: revoked == 1,
created_at,
client_id,
scopes,
username,
user_id,
}))
},
None => Ok(None),
}
}
pub async fn detect_reuse(&self, token_hash: &str) -> GarrisonResult<bool> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-session::{}", e)))?;
let conn = session
.connection()
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-conn::{}", e)))?;
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT revoked FROM refresh_tokens WHERE token_hash = ?",
vec![Value::String(Some(token_hash.to_string()))],
);
let row = conn
.query_one_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
let revoked = match row {
Some(row) => row
.try_get::<i64>("", "revoked")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?,
None => return Ok(false),
};
Ok(revoked == 1)
}
pub async fn revoke_chain(&self, token_hash: &str) -> GarrisonResult<()> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-session::{}", e)))?;
let conn = session
.connection()
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-get-conn::{}", e)))?;
let mut stack = vec![token_hash.to_string()];
while let Some(hash) = stack.pop() {
let update_stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"UPDATE refresh_tokens SET revoked = 1 WHERE token_hash = ?",
vec![Value::String(Some(hash.clone()))],
);
conn.execute_raw(update_stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-update::{}", e)))?;
let select_stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT token_hash FROM refresh_tokens WHERE parent_token_hash = ?",
vec![Value::String(Some(hash))],
);
let rows = conn
.query_all_raw(select_stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-select-child::{}", e)))?;
for row in rows {
let child_hash: String = row
.try_get("", "token_hash")
.map_err(|e| GarrisonError::Dao(format!("jwt-refresh-query::{}", e)))?;
stack.push(child_hash);
}
}
Ok(())
}
}
}
#[cfg(feature = "db-sqlite")]
pub use service::RefreshTokenRotation;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn refresh_token_record_constructs_with_hash_chain_fields() {
let record = RefreshTokenRecord {
token_hash: "abc".to_string(),
parent_token_hash: Some("def".to_string()),
login_id: 1,
tenant_id: 0,
key_version: 1,
expires_at: 9999,
revoked: false,
created_at: 0,
client_id: None,
scopes: None,
username: None,
user_id: None,
};
assert_eq!(record.token_hash, "abc");
assert_eq!(record.parent_token_hash, Some("def".to_string()));
assert_eq!(record.login_id, 1);
assert_eq!(record.tenant_id, 0);
assert_eq!(record.key_version, 1);
assert_eq!(record.expires_at, 9999);
assert!(!record.revoked);
assert_eq!(record.created_at, 0);
assert_eq!(record.client_id, None);
assert_eq!(record.scopes, None);
assert_eq!(record.username, None);
assert_eq!(record.user_id, None);
}
#[test]
fn refresh_token_record_old_json_deserializes_with_none_new_fields() {
let old_json = r#"{
"token_hash": "abc123",
"parent_token_hash": null,
"login_id": 42,
"tenant_id": 1,
"key_version": 2,
"expires_at": 1700000000,
"revoked": false,
"created_at": 1699000000
}"#;
let record: RefreshTokenRecord = serde_json::from_str(old_json)
.expect("旧 JSON 反序列化应成功(#[serde(default)] 保证向后兼容)");
assert_eq!(record.token_hash, "abc123");
assert_eq!(record.parent_token_hash, None);
assert_eq!(record.login_id, 42);
assert_eq!(record.tenant_id, 1);
assert_eq!(record.key_version, 2);
assert_eq!(record.expires_at, 1700000000);
assert!(!record.revoked);
assert_eq!(record.created_at, 1699000000);
assert_eq!(record.client_id, None);
assert_eq!(record.scopes, None);
assert_eq!(record.username, None);
assert_eq!(record.user_id, None);
}
#[test]
fn refresh_token_record_new_json_roundtrip() {
let record = RefreshTokenRecord {
token_hash: "new_hash".to_string(),
parent_token_hash: Some("old_hash".to_string()),
login_id: 100,
tenant_id: 5,
key_version: 3,
expires_at: 1800000000,
revoked: false,
created_at: 1700000000,
client_id: Some("client_123".to_string()),
scopes: Some("read write admin".to_string()),
username: Some("alice".to_string()),
user_id: Some(42),
};
let json = serde_json::to_string(&record).expect("序列化应成功");
let deserialized: RefreshTokenRecord = serde_json::from_str(&json).expect("反序列化应成功");
assert_eq!(record, deserialized);
}
}
#[cfg(all(test, feature = "protocol-jwt", feature = "db-sqlite"))]
mod db_sqlite_tests {
use super::RefreshTokenRotation;
use crate::dao::{init_dbnexus, GarrisonMigration};
use crate::error::GarrisonError;
use crate::protocol::jwt::JwtHandler;
use dbnexus::DbPool;
use sea_orm::{ConnectionTrait, DbBackend, Statement, Value};
use std::path::PathBuf;
use std::sync::{Arc, RwLock};
fn project_migrations_dir() -> PathBuf {
let manifest_dir = env!("CARGO_MANIFEST_DIR");
PathBuf::from(manifest_dir)
.join("migrations")
.join("sqlite")
}
async fn setup_db() -> DbPool {
let pool = init_dbnexus("sqlite::memory:")
.await
.expect("init_dbnexus 应成功");
let migration = GarrisonMigration::with_base_dir(pool.clone(), project_migrations_dir());
let applied = migration.migrate_core().await.expect("migrate_core 应成功");
assert!(applied >= 1, "migrate_core 应至少执行 1 个文件");
pool
}
#[tokio::test(flavor = "multi_thread")]
async fn refresh_tokens_table_exists_after_migration() {
let pool = setup_db().await;
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT name FROM sqlite_master WHERE type='table' AND name='refresh_tokens'",
vec![],
);
let rows = conn.query_all_raw(stmt).await.expect("query_all 应成功");
assert_eq!(
rows.len(),
1,
"refresh_tokens 表应存在(迁移后 sqlite_master 应有 1 行记录)"
);
}
fn sha256_hex(s: &str) -> String {
use sha2::{Digest, Sha256};
let mut hasher = Sha256::new();
hasher.update(s.as_bytes());
let result = hasher.finalize();
result.iter().map(|b| format!("{:02x}", b)).collect()
}
async fn insert_refresh_token(
pool: &DbPool,
token_hash: &str,
parent_token_hash: Option<&str>,
login_id: i64,
tenant_id: i64,
key_version: u32,
expires_at: i64,
revoked: i64,
) {
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"INSERT INTO refresh_tokens (token_hash, parent_token_hash, login_id, tenant_id, key_version, expires_at, revoked, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
vec![
Value::String(Some(token_hash.to_string())),
Value::String(parent_token_hash.map(|s| s.to_string())),
Value::BigInt(Some(login_id)),
Value::BigInt(Some(tenant_id)),
Value::BigInt(Some(key_version as i64)),
Value::BigInt(Some(expires_at)),
Value::BigInt(Some(revoked)),
Value::BigInt(Some(0)),
],
);
conn.execute_raw(stmt).await.expect("INSERT 应成功");
}
async fn query_revoked(pool: &DbPool, token_hash: &str) -> i64 {
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT revoked FROM refresh_tokens WHERE token_hash = ?",
vec![Value::String(Some(token_hash.to_string()))],
);
let row = conn
.query_one_raw(stmt)
.await
.unwrap()
.expect("record 应存在");
row.try_get::<i64>("", "revoked").unwrap()
}
async fn query_record(pool: &DbPool, token_hash: &str) -> (Option<String>, i64) {
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT parent_token_hash, revoked FROM refresh_tokens WHERE token_hash = ?",
vec![Value::String(Some(token_hash.to_string()))],
);
let row = conn
.query_one_raw(stmt)
.await
.unwrap()
.expect("record 应存在");
let parent: Option<String> = row.try_get("", "parent_token_hash").ok();
let revoked: i64 = row.try_get("", "revoked").unwrap();
(parent, revoked)
}
#[tokio::test(flavor = "multi_thread")]
async fn rotate_inserts_new_token_and_marks_old_consumed() {
let pool = setup_db().await;
let old_token = "old_token_value";
let old_hash = sha256_hex(old_token);
insert_refresh_token(&pool, &old_hash, None, 1, 0, 1, 9999, 0).await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
let (new_access, new_refresh) = rotation.rotate(old_token).await.expect("rotate 应成功");
assert!(!new_access.is_empty(), "new_access 应非空");
assert!(!new_refresh.is_empty(), "new_refresh 应非空");
let old_revoked = query_revoked(&pool, &old_hash).await;
assert_eq!(old_revoked, 1, "old_token 应标记为 revoked");
let new_hash = sha256_hex(&new_refresh);
let (parent, revoked) = query_record(&pool, &new_hash).await;
assert_eq!(
parent,
Some(old_hash),
"new record 的 parent_token_hash 应等于 old_hash"
);
assert_eq!(revoked, 0, "new record 应未 revoked");
}
#[tokio::test(flavor = "multi_thread")]
async fn detect_reuse_returns_true_when_token_already_consumed() {
let pool = setup_db().await;
let old_token = "old_token_value";
let old_hash = sha256_hex(old_token);
insert_refresh_token(&pool, &old_hash, None, 1, 0, 1, 9999, 0).await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
let (_, new_refresh) = rotation.rotate(old_token).await.expect("rotate 应成功");
let reused = rotation
.detect_reuse(&old_hash)
.await
.expect("detect_reuse 应成功");
assert!(reused, "已 revoked 的 token 应检测为 reuse");
let new_hash = sha256_hex(&new_refresh);
let new_reused = rotation
.detect_reuse(&new_hash)
.await
.expect("detect_reuse 应成功");
assert!(!new_reused, "未 revoked 的 token 不应检测为 reuse");
}
#[tokio::test(flavor = "multi_thread")]
async fn revoke_chain_revokes_all_parent_tokens() {
let pool = setup_db().await;
let t1_hash = sha256_hex("t1");
let t2_hash = sha256_hex("t2");
let t3_hash = sha256_hex("t3");
insert_refresh_token(&pool, &t1_hash, None, 1, 0, 1, 9999, 0).await;
insert_refresh_token(&pool, &t2_hash, Some(&t1_hash), 1, 0, 1, 9999, 0).await;
insert_refresh_token(&pool, &t3_hash, Some(&t2_hash), 1, 0, 1, 9999, 0).await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
rotation
.revoke_chain(&t1_hash)
.await
.expect("revoke_chain 应成功");
assert_eq!(query_revoked(&pool, &t1_hash).await, 1, "t1 应 revoked");
assert_eq!(
query_revoked(&pool, &t2_hash).await,
1,
"t2 应 revoked(子代)"
);
assert_eq!(
query_revoked(&pool, &t3_hash).await,
1,
"t3 应 revoked(孙代)"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn rotate_with_reuse_detection_revokes_chain() {
let pool = setup_db().await;
let t1_token = "t1_token_value";
let t1_hash = sha256_hex(t1_token);
insert_refresh_token(&pool, &t1_hash, None, 1, 0, 1, 9999, 0).await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
let (_, t2_refresh) = rotation
.rotate(t1_token)
.await
.expect("第一次 rotate 应成功");
let t2_hash = sha256_hex(&t2_refresh);
let result = rotation.rotate(t1_token).await;
assert!(
matches!(result, Err(GarrisonError::TokenRevoked(_))),
"重用已消费的 refresh token 应返回 TokenRevoked,实际: {:?}",
result
);
assert_eq!(
query_revoked(&pool, &t1_hash).await,
1,
"t1 应 revoked(重用检测后)"
);
assert_eq!(
query_revoked(&pool, &t2_hash).await,
1,
"t2 应 revoked(链被吊销)"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn issue_creates_record_with_correct_fields() {
let pool = setup_db().await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(2)));
let scopes = vec!["read".to_string(), "write".to_string()];
let refresh_token = rotation
.issue(
"client_abc",
Some(42),
&scopes,
Some("alice"),
42,
5,
86400 * 7,
)
.await
.expect("issue 应成功");
let record = rotation
.validate(&refresh_token)
.await
.expect("validate 应成功")
.expect("record 应存在");
assert_eq!(
record.parent_token_hash, None,
"首次签发 parent_token_hash 应为 None"
);
assert!(!record.revoked, "新签发的 token 应未 revoked");
assert_eq!(record.tenant_id, 5);
assert_eq!(record.key_version, 2);
assert_eq!(record.login_id, 42);
assert_eq!(record.client_id, Some("client_abc".to_string()));
assert_eq!(record.scopes, Some("read write".to_string()));
assert_eq!(record.username, Some("alice".to_string()));
assert_eq!(record.user_id, Some(42));
}
#[tokio::test(flavor = "multi_thread")]
async fn issue_with_empty_scopes_stores_none() {
let pool = setup_db().await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
let refresh_token = rotation
.issue(
"client_xyz",
None, &[], None,
0,
0,
3600,
)
.await
.expect("issue 应成功");
let record = rotation
.validate(&refresh_token)
.await
.expect("validate 应成功")
.expect("record 应存在");
assert_eq!(record.scopes, None, "空 scopes 列表应存储为 None");
assert_eq!(record.user_id, None, "client_credentials 无 user_id");
assert_eq!(record.username, None);
}
#[tokio::test(flavor = "multi_thread")]
async fn validate_returns_some_for_valid_token() {
let pool = setup_db().await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
let refresh_token = rotation
.issue("client_1", Some(1), &["read".to_string()], None, 1, 0, 3600)
.await
.expect("issue 应成功");
let result = rotation
.validate(&refresh_token)
.await
.expect("validate 应成功");
assert!(result.is_some(), "有效 token 应返回 Some");
}
#[tokio::test(flavor = "multi_thread")]
async fn validate_returns_none_for_revoked_token() {
let pool = setup_db().await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
let refresh_token = rotation
.issue("client_1", Some(1), &["read".to_string()], None, 1, 0, 3600)
.await
.expect("issue 应成功");
let _ = rotation
.rotate(&refresh_token)
.await
.expect("rotate 应成功");
let result = rotation
.validate(&refresh_token)
.await
.expect("validate 应成功");
assert!(result.is_none(), "已 revoked token 应返回 None");
}
#[tokio::test(flavor = "multi_thread")]
async fn validate_returns_none_for_nonexistent_token() {
let pool = setup_db().await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
let result = rotation
.validate("nonexistent_token_12345")
.await
.expect("validate 应成功");
assert!(result.is_none(), "不存在的 token 应返回 None");
}
#[tokio::test(flavor = "multi_thread")]
async fn rotate_inherits_oauth2_fields() {
let pool = setup_db().await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
let scopes = vec!["admin".to_string(), "read".to_string()];
let old_token = rotation
.issue(
"client_inherit",
Some(99),
&scopes,
Some("bob"),
99,
3,
86400,
)
.await
.expect("issue 应成功");
let old_hash = sha256_hex(&old_token);
let (_, new_refresh) = rotation.rotate(&old_token).await.expect("rotate 应成功");
let new_record = rotation
.validate(&new_refresh)
.await
.expect("validate 应成功")
.expect("新 token 应存在");
assert_eq!(new_record.client_id, Some("client_inherit".to_string()));
assert_eq!(new_record.scopes, Some("admin read".to_string()));
assert_eq!(new_record.username, Some("bob".to_string()));
assert_eq!(new_record.user_id, Some(99));
assert_eq!(
new_record.parent_token_hash,
Some(old_hash),
"新记录 parent_token_hash 应指向旧记录 token_hash"
);
let old_record = rotation
.validate(&old_token)
.await
.expect("validate 应成功");
assert!(old_record.is_none(), "旧 token 应已 revoked");
}
#[tokio::test(flavor = "multi_thread")]
async fn rotate_old_record_with_null_new_fields_inherits_none() {
let pool = setup_db().await;
let jwt_handler = Arc::new(JwtHandler::new("test_secret"));
let rotation =
RefreshTokenRotation::new(pool.clone(), jwt_handler, Arc::new(RwLock::new(1)));
let old_token = "legacy_token_value";
let old_hash = sha256_hex(old_token);
insert_refresh_token(&pool, &old_hash, None, 1, 0, 1, 9999, 0).await;
let (_, new_refresh) = rotation.rotate(old_token).await.expect("rotate 应成功");
let new_record = rotation
.validate(&new_refresh)
.await
.expect("validate 应成功")
.expect("新 token 应存在");
assert_eq!(
new_record.client_id, None,
"旧记录 client_id 为 NULL,新记录应继承 None"
);
assert_eq!(new_record.scopes, None);
assert_eq!(new_record.username, None);
assert_eq!(new_record.user_id, None);
}
}