use super::{AccountSession, GarrisonSession, TokenSession};
use crate::error::{GarrisonError, GarrisonResult};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SearchSortType {
CreatedAsc,
CreatedDesc,
LastActiveAsc,
LastActiveDesc,
}
const TOKEN_SESSION_PREFIX: &str = "token:session:";
const ANON_SESSION_PREFIX: &str = "token:session:anon:";
const ACCOUNT_SESSION_PREFIX: &str = "account:session:";
const MAX_SCAN: usize = 10000;
const MAX_KEYWORD_LEN: usize = 256;
const MAX_SIZE: usize = 1000;
fn sort_entries(entries: &mut [(String, i64, i64)], sort_type: SearchSortType) {
use std::cmp::Reverse;
match sort_type {
SearchSortType::CreatedAsc => entries.sort_by_key(|a| a.1),
SearchSortType::CreatedDesc => entries.sort_by_key(|a| Reverse(a.1)),
SearchSortType::LastActiveAsc => entries.sort_by_key(|a| a.2),
SearchSortType::LastActiveDesc => entries.sort_by_key(|a| Reverse(a.2)),
}
}
fn mask_key(key: &str) -> String {
match key.rfind(':') {
Some(idx) => {
let (prefix, value) = key.split_at(idx + 1);
match value.get(..4) {
Some(v4) if value.len() > 4 => format!("{}{}***", prefix, v4),
_ => format!("{}***", prefix),
}
},
None => "***".to_string(),
}
}
pub async fn search_token_value(
session: &GarrisonSession,
keyword: &str,
start: usize,
size: usize,
sort_type: SearchSortType,
) -> GarrisonResult<(Vec<String>, bool)> {
if keyword.len() > MAX_KEYWORD_LEN {
return Err(GarrisonError::InvalidParam(format!(
"session-search-keyword-too-long::{}::{}",
keyword.len(),
MAX_KEYWORD_LEN
)));
}
if size > MAX_SIZE {
return Err(GarrisonError::InvalidParam(format!(
"session-search-size-exceeded::{}::{}",
size, MAX_SIZE
)));
}
let mut keys = session
.dao
.keys(&format!("{}*", TOKEN_SESSION_PREFIX))
.await?;
let mut truncated = false;
if keys.len() > MAX_SCAN {
truncated = true;
tracing::warn!(
actual = keys.len(),
max = MAX_SCAN,
"search scan exceeded the key count limit, truncated"
);
keys.truncate(MAX_SCAN);
}
let mut entries: Vec<(String, i64, i64)> = Vec::new();
let mut skipped = 0usize;
for key in keys {
if key.starts_with(ANON_SESSION_PREFIX) {
continue;
}
if !key.starts_with(TOKEN_SESSION_PREFIX) {
continue;
}
let json = match session.dao.get(&key).await? {
Some(j) => j,
None => continue,
};
let ts: TokenSession = match serde_json::from_str(&json) {
Ok(ts) => ts,
Err(e) => {
tracing::warn!(
key = %mask_key(&key),
error = %e,
"skipping corrupted TokenSession record"
);
skipped += 1;
continue;
},
};
if !keyword.is_empty() && !ts.token.contains(keyword) {
continue;
}
entries.push((ts.token, ts.created_at, ts.last_active_at));
}
if skipped > 0 {
tracing::warn!(
skipped,
total = entries.len() + skipped,
"search completed with skipped records"
);
}
sort_entries(&mut entries, sort_type);
Ok((
entries
.into_iter()
.skip(start)
.take(size)
.map(|(id, _, _)| id)
.collect(),
truncated,
))
}
pub async fn search_session_id(
session: &GarrisonSession,
keyword: &str,
start: usize,
size: usize,
sort_type: SearchSortType,
) -> GarrisonResult<(Vec<String>, bool)> {
if keyword.len() > MAX_KEYWORD_LEN {
return Err(GarrisonError::InvalidParam(format!(
"session-search-keyword-too-long::{}::{}",
keyword.len(),
MAX_KEYWORD_LEN
)));
}
if size > MAX_SIZE {
return Err(GarrisonError::InvalidParam(format!(
"session-search-size-exceeded::{}::{}",
size, MAX_SIZE
)));
}
let mut keys = session
.dao
.keys(&format!("{}*", ACCOUNT_SESSION_PREFIX))
.await?;
let mut truncated = false;
if keys.len() > MAX_SCAN {
truncated = true;
tracing::warn!(
actual = keys.len(),
max = MAX_SCAN,
"search scan exceeded the key count limit, truncated"
);
keys.truncate(MAX_SCAN);
}
let mut entries: Vec<(String, i64, i64)> = Vec::new();
let mut skipped = 0usize;
for key in keys {
let login_id = match key.strip_prefix(ACCOUNT_SESSION_PREFIX) {
Some(t) => t,
None => continue,
};
if !keyword.is_empty() && !login_id.contains(keyword) {
continue;
}
let json = match session.dao.get(&key).await? {
Some(j) => j,
None => continue,
};
let account_session: AccountSession = match serde_json::from_str(&json) {
Ok(as_v) => as_v,
Err(e) => {
tracing::warn!(
key = %mask_key(&key),
error = %e,
"skipping corrupted AccountSession record"
);
skipped += 1;
continue;
},
};
entries.push((
login_id.to_string(),
account_session.created_at,
account_session.last_active_at,
));
}
if skipped > 0 {
tracing::warn!(
skipped,
total = entries.len() + skipped,
"search completed with skipped records"
);
}
sort_entries(&mut entries, sort_type);
Ok((
entries
.into_iter()
.skip(start)
.take(size)
.map(|(id, _, _)| id)
.collect(),
truncated,
))
}
pub async fn search_token_session_id(
session: &GarrisonSession,
keyword: &str,
start: usize,
size: usize,
sort_type: SearchSortType,
) -> GarrisonResult<(Vec<String>, bool)> {
if keyword.len() > MAX_KEYWORD_LEN {
return Err(GarrisonError::InvalidParam(format!(
"session-search-keyword-too-long::{}::{}",
keyword.len(),
MAX_KEYWORD_LEN
)));
}
if size > MAX_SIZE {
return Err(GarrisonError::InvalidParam(format!(
"session-search-size-exceeded::{}::{}",
size, MAX_SIZE
)));
}
let mut keys = session
.dao
.keys(&format!("{}*", TOKEN_SESSION_PREFIX))
.await?;
let mut truncated = false;
if keys.len() > MAX_SCAN {
truncated = true;
tracing::warn!(
actual = keys.len(),
max = MAX_SCAN,
"search scan exceeded the key count limit, truncated"
);
keys.truncate(MAX_SCAN);
}
let mut entries: Vec<(String, i64, i64)> = Vec::new();
let mut skipped = 0usize;
for key in keys {
if key.starts_with(ANON_SESSION_PREFIX) {
continue;
}
if !key.starts_with(TOKEN_SESSION_PREFIX) {
continue;
}
let json = match session.dao.get(&key).await? {
Some(j) => j,
None => continue,
};
let ts: TokenSession = match serde_json::from_str(&json) {
Ok(ts) => ts,
Err(e) => {
tracing::warn!(
key = %mask_key(&key),
error = %e,
"skipping corrupted TokenSession record"
);
skipped += 1;
continue;
},
};
if !keyword.is_empty() && !ts.login_id.contains(keyword) {
continue;
}
entries.push((ts.token, ts.created_at, ts.last_active_at));
}
if skipped > 0 {
tracing::warn!(
skipped,
total = entries.len() + skipped,
"search completed with skipped records"
);
}
sort_entries(&mut entries, sort_type);
Ok((
entries
.into_iter()
.skip(start)
.take(size)
.map(|(id, _, _)| id)
.collect(),
truncated,
))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
use crate::dao::GarrisonDao;
use crate::session::{sha256_hex, token_key};
use std::collections::HashMap;
use std::sync::Arc;
fn make_session(timeout: u64, active_timeout: u64) -> (Arc<MockDao>, GarrisonSession) {
let dao = Arc::new(MockDao::new());
let session = GarrisonSession::new(dao.clone(), timeout, active_timeout, 0);
(dao, session)
}
async fn put_token_session(
dao: &Arc<MockDao>,
token: &str,
login_id: &str,
created_at: i64,
last_active_at: i64,
) {
let key = token_key(token);
let ts = TokenSession {
token: token.to_string(),
login_id: login_id.to_string(),
created_at,
last_active_at,
attrs: HashMap::new(),
device: None,
ip: None,
user_agent: None,
safe_services: HashMap::new(),
#[cfg(feature = "session-extra")]
dynamic_active_timeout: None,
#[cfg(feature = "session-extra")]
is_anon: false,
effective_timeout: None,
amr_ledger: Vec::new(),
auth_time: None,
};
let json = serde_json::to_string(&ts).unwrap();
dao.set(&key, &json, 3600).await.unwrap();
}
#[test]
fn search_sort_type_round_trip() {
for variant in [
SearchSortType::CreatedAsc,
SearchSortType::CreatedDesc,
SearchSortType::LastActiveAsc,
SearchSortType::LastActiveDesc,
] {
let json = serde_json::to_string(&variant).unwrap();
let back: SearchSortType = serde_json::from_str(&json).unwrap();
assert_eq!(variant, back, "round-trip 失败: {}", json);
}
assert_eq!(
serde_json::to_string(&SearchSortType::CreatedAsc).unwrap(),
"\"created_asc\""
);
assert_eq!(
serde_json::to_string(&SearchSortType::CreatedDesc).unwrap(),
"\"created_desc\""
);
assert_eq!(
serde_json::to_string(&SearchSortType::LastActiveAsc).unwrap(),
"\"last_active_asc\""
);
assert_eq!(
serde_json::to_string(&SearchSortType::LastActiveDesc).unwrap(),
"\"last_active_desc\""
);
}
#[tokio::test]
async fn search_token_value_keyword_match() {
let (_dao, session) = make_session(3600, 86400);
session.create("u1", "alpha-1").await.unwrap();
session.create("u2", "alpha-2").await.unwrap();
session.create("u3", "beta-1").await.unwrap();
let (result, _truncated) = session
.search_token_value("alpha", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(result.len(), 2);
assert!(result.contains(&"alpha-1".to_string()));
assert!(result.contains(&"alpha-2".to_string()));
}
#[tokio::test]
async fn search_token_value_pagination() {
let (dao, session) = make_session(3600, 86400);
put_token_session(&dao, "tok-1", "u1", 100, 100).await;
put_token_session(&dao, "tok-2", "u2", 200, 200).await;
put_token_session(&dao, "tok-3", "u3", 300, 300).await;
put_token_session(&dao, "tok-4", "u4", 400, 400).await;
put_token_session(&dao, "tok-5", "u5", 500, 500).await;
let (result, _truncated) = session
.search_token_value("", 1, 2, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(result.len(), 2);
assert_eq!(result[0], "tok-2");
assert_eq!(result[1], "tok-3");
}
#[tokio::test]
async fn search_token_value_sort_order() {
let (dao, session) = make_session(3600, 86400);
put_token_session(&dao, "tok-a", "u1", 100, 150).await;
put_token_session(&dao, "tok-b", "u2", 200, 100).await;
put_token_session(&dao, "tok-c", "u3", 300, 250).await;
let (asc, _truncated) = session
.search_token_value("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(asc, vec!["tok-a", "tok-b", "tok-c"]);
let (desc, _truncated) = session
.search_token_value("", 0, 100, SearchSortType::CreatedDesc)
.await
.unwrap();
assert_eq!(desc, vec!["tok-c", "tok-b", "tok-a"]);
let (last_asc, _truncated) = session
.search_token_value("", 0, 100, SearchSortType::LastActiveAsc)
.await
.unwrap();
assert_eq!(last_asc, vec!["tok-b", "tok-a", "tok-c"]);
let (last_desc, _truncated) = session
.search_token_value("", 0, 100, SearchSortType::LastActiveDesc)
.await
.unwrap();
assert_eq!(last_desc, vec!["tok-c", "tok-a", "tok-b"]);
}
#[tokio::test]
async fn search_session_id_keyword_match() {
let (_dao, session) = make_session(3600, 86400);
session.create("user1", "t1").await.unwrap();
session.create("user2", "t2").await.unwrap();
session.create("admin1", "t3").await.unwrap();
let (result, _truncated) = session
.search_session_id("user", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(result.len(), 2);
assert!(result.contains(&"user1".to_string()));
assert!(result.contains(&"user2".to_string()));
}
#[tokio::test]
async fn search_session_id_empty_result() {
let (_dao, session) = make_session(3600, 86400);
session.create("user1", "t1").await.unwrap();
let (result, _truncated) = session
.search_session_id("nonexistent", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert!(result.is_empty());
}
#[tokio::test]
async fn search_token_session_id_filters_by_login_id() {
let (dao, session) = make_session(3600, 86400);
put_token_session(&dao, "tok-1", "user-1", 100, 100).await;
put_token_session(&dao, "tok-2", "user-2", 200, 200).await;
put_token_session(&dao, "tok-3", "admin-1", 300, 300).await;
let (result, _truncated) = session
.search_token_session_id("user", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(result.len(), 2);
assert!(result.contains(&"tok-1".to_string()));
assert!(result.contains(&"tok-2".to_string()));
let (result2, _truncated) = session
.search_token_value("user", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert!(
result2.is_empty(),
"search_token_value('user') 应返回空,因为没有 token 包含 'user'"
);
put_token_session(&dao, "shared-1", "shared-a", 400, 400).await;
put_token_session(&dao, "shared-2", "shared-b", 500, 500).await;
let (by_token, _truncated) = session
.search_token_value("shared", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
let (by_login, _truncated) = session
.search_token_session_id("shared", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(
by_token, by_login,
"当 keyword 同时出现在 token 和 login_id 中时,两个方法应返回相同结果"
);
}
#[tokio::test]
async fn search_excludes_anon_sessions() {
let (dao, session) = make_session(3600, 86400);
put_token_session(&dao, "normal-1", "u1", 100, 100).await;
let anon_key = format!("{}anon:{}", TOKEN_SESSION_PREFIX, sha256_hex("anon-tok"));
let anon_ts = TokenSession {
token: "anon-tok".to_string(),
login_id: String::new(),
created_at: 50,
last_active_at: 50,
attrs: HashMap::new(),
device: None,
ip: None,
user_agent: None,
safe_services: HashMap::new(),
#[cfg(feature = "session-extra")]
dynamic_active_timeout: None,
#[cfg(feature = "session-extra")]
is_anon: true,
effective_timeout: None,
amr_ledger: Vec::new(),
auth_time: None,
};
let json = serde_json::to_string(&anon_ts).unwrap();
dao.set(&anon_key, &json, 3600).await.unwrap();
let (result, _truncated) = session
.search_token_value("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(result, vec!["normal-1"], "anon Session 不应出现在搜索结果");
assert!(!result.contains(&"anon-tok".to_string()));
let (result2, _truncated) = session
.search_token_session_id("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(
result2,
vec!["normal-1"],
"anon Session 不应出现在 login_id 搜索结果"
);
}
#[tokio::test]
async fn search_token_value_returns_original_token_not_digest() {
let (_dao, session) = make_session(3600, 86400);
session.create("u1", "T1-raw").await.unwrap();
let (result, _truncated) = session
.search_token_value("T1-raw", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(
result,
vec!["T1-raw".to_string()],
"搜索结果应返回 value 内嵌的原始 token"
);
let digest_suffix = &token_key("T1-raw")["token:session:".len()..];
assert_eq!(digest_suffix.len(), 64, "落库 key 余段应为 64 位摘要");
assert_ne!(result[0], digest_suffix, "返回值不应是 key 摘要余段");
}
#[tokio::test]
async fn search_token_value_keyword_too_long_returns_error() {
let (_dao, session) = make_session(3600, 86400);
let long_keyword = "a".repeat(MAX_KEYWORD_LEN + 1);
let result = session
.search_token_value(&long_keyword, 0, 10, SearchSortType::CreatedAsc)
.await;
assert!(result.is_err(), "超长 keyword 应返回错误");
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("session-search-keyword-too-long"),
"错误消息应包含 'session-search-keyword-too-long',实际: {}",
msg
);
},
Err(other) => panic!("期望 InvalidParam,实际: {:?}", other),
Ok(_) => panic!("期望错误,实际返回 Ok"),
}
}
#[tokio::test]
async fn search_token_value_size_too_large_returns_error() {
let (_dao, session) = make_session(3600, 86400);
let result = session
.search_token_value("", 0, MAX_SIZE + 1, SearchSortType::CreatedAsc)
.await;
assert!(result.is_err(), "超大 size 应返回错误");
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("session-search-size-exceeded"),
"错误消息应包含 'session-search-size-exceeded',实际: {}",
msg
);
},
Err(other) => panic!("期望 InvalidParam,实际: {:?}", other),
Ok(_) => panic!("期望错误,实际返回 Ok"),
}
}
#[tokio::test]
async fn search_session_id_keyword_too_long_returns_error() {
let (_dao, session) = make_session(3600, 86400);
let long_keyword = "x".repeat(MAX_KEYWORD_LEN + 1);
let result = session
.search_session_id(&long_keyword, 0, 10, SearchSortType::CreatedAsc)
.await;
assert!(result.is_err());
assert!(matches!(result, Err(GarrisonError::InvalidParam(_))));
}
#[tokio::test]
async fn search_session_id_size_too_large_returns_error() {
let (_dao, session) = make_session(3600, 86400);
let result = session
.search_session_id("", 0, MAX_SIZE + 1, SearchSortType::CreatedAsc)
.await;
assert!(result.is_err());
assert!(matches!(result, Err(GarrisonError::InvalidParam(_))));
}
#[tokio::test]
async fn search_token_session_id_keyword_too_long_returns_error() {
let (_dao, session) = make_session(3600, 86400);
let long_keyword = "y".repeat(MAX_KEYWORD_LEN + 1);
let result = session
.search_token_session_id(&long_keyword, 0, 10, SearchSortType::CreatedAsc)
.await;
assert!(result.is_err());
assert!(matches!(result, Err(GarrisonError::InvalidParam(_))));
}
#[tokio::test]
async fn search_token_session_id_size_too_large_returns_error() {
let (_dao, session) = make_session(3600, 86400);
let result = session
.search_token_session_id("", 0, MAX_SIZE + 1, SearchSortType::CreatedAsc)
.await;
assert!(result.is_err());
assert!(matches!(result, Err(GarrisonError::InvalidParam(_))));
}
#[tokio::test]
async fn search_token_value_start_beyond_range_returns_empty() {
let (dao, session) = make_session(3600, 86400);
put_token_session(&dao, "tok-1", "u1", 100, 100).await;
put_token_session(&dao, "tok-2", "u2", 200, 200).await;
let (result, _truncated) = session
.search_token_value("", 10, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert!(result.is_empty(), "start 超出范围应返回空 Vec");
}
#[tokio::test]
async fn search_token_value_size_zero_returns_empty() {
let (dao, session) = make_session(3600, 86400);
put_token_session(&dao, "tok-1", "u1", 100, 100).await;
let (result, _truncated) = session
.search_token_value("", 0, 0, SearchSortType::CreatedAsc)
.await
.unwrap();
assert!(result.is_empty(), "size=0 应返回空 Vec");
}
#[tokio::test]
async fn search_empty_db_empty_keyword_returns_empty() {
let (_dao, session) = make_session(3600, 86400);
let (result, _truncated) = session
.search_token_value("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert!(result.is_empty());
let (result2, _truncated) = session
.search_session_id("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert!(result2.is_empty());
}
#[tokio::test]
async fn search_token_value_skips_corrupted_json() {
let (dao, session) = make_session(3600, 86400);
put_token_session(&dao, "valid-tok", "u1", 100, 100).await;
let corrupt_key = format!("{}{}", TOKEN_SESSION_PREFIX, "corrupt-tok");
dao.set(&corrupt_key, "{invalid json}", 3600).await.unwrap();
let (result, _truncated) = session
.search_token_value("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(result.len(), 1);
assert_eq!(result[0], "valid-tok");
}
#[tokio::test]
async fn search_session_id_skips_corrupted_json() {
let (dao, session) = make_session(3600, 86400);
session.create("valid-user", "tok-1").await.unwrap();
let corrupt_key = format!("{}corrupt-user", ACCOUNT_SESSION_PREFIX);
dao.set(&corrupt_key, "not valid json{{{", 3600)
.await
.unwrap();
let (result, _truncated) = session
.search_session_id("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(result.len(), 1);
assert!(result.contains(&"valid-user".to_string()));
}
#[tokio::test]
async fn search_token_session_id_skips_corrupted_json() {
let (dao, session) = make_session(3600, 86400);
put_token_session(&dao, "valid-tok", "user-1", 100, 100).await;
let corrupt_key = format!("{}{}", TOKEN_SESSION_PREFIX, "corrupt-tok");
dao.set(&corrupt_key, "broken json", 3600).await.unwrap();
let (result, _truncated) = session
.search_token_session_id("user", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(result.len(), 1);
assert_eq!(result[0], "valid-tok");
}
#[tokio::test]
async fn search_skips_keys_with_none_get() {
let (dao, session) = make_session(3600, 86400);
put_token_session(&dao, "exists-tok", "u1", 100, 100).await;
let expired_key = format!("{}{}", TOKEN_SESSION_PREFIX, "expired-tok");
dao.set(&expired_key, "will_be_deleted", 3600)
.await
.unwrap();
dao.delete(&expired_key).await.unwrap();
let (result, _truncated) = session
.search_token_value("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert_eq!(result.len(), 1);
assert_eq!(result[0], "exists-tok");
}
struct LargeKeyDao {
key_count: usize,
}
impl LargeKeyDao {
fn new(key_count: usize) -> Self {
Self { key_count }
}
}
#[async_trait::async_trait]
impl crate::dao::GarrisonDao for LargeKeyDao {
async fn get(&self, _key: &str) -> GarrisonResult<Option<String>> {
Ok(None) }
async fn set(&self, _key: &str, _value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn update(&self, _key: &str, _value: &str) -> GarrisonResult<()> {
Ok(())
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, _key: &str) -> GarrisonResult<()> {
Ok(())
}
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
let prefix = pattern.trim_end_matches('*');
let keys: Vec<String> = (0..self.key_count)
.map(|i| format!("{}key_{}", prefix, i))
.collect();
Ok(keys)
}
crate::atomic_test_fallback!();
}
#[tokio::test]
async fn search_truncates_keys_exceeding_max_scan() {
let dao = Arc::new(LargeKeyDao::new(MAX_SCAN + 100));
let session = GarrisonSession::new(dao, 3600, 86400, 0);
let (result, truncated) = session
.search_token_value("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert!(result.is_empty(), "所有 key 的 get() 返回 None,结果应为空");
assert!(truncated, "超过 MAX_SCAN 截断后应返回 truncated=true");
}
#[tokio::test]
async fn search_max_scan_boundary_not_truncated() {
let dao = Arc::new(LargeKeyDao::new(MAX_SCAN));
let session = GarrisonSession::new(dao, 3600, 86400, 0);
let (result, truncated) = session
.search_token_value("", 0, 100, SearchSortType::CreatedAsc)
.await
.unwrap();
assert!(result.is_empty());
assert!(!truncated, "恰好 MAX_SCAN 条不应截断");
}
#[test]
fn sort_entries_created_desc_correct() {
let mut entries = vec![
("a".to_string(), 100i64, 50i64),
("b".to_string(), 300, 200),
("c".to_string(), 200, 100),
];
sort_entries(&mut entries, SearchSortType::CreatedDesc);
assert_eq!(entries[0].0, "b"); assert_eq!(entries[1].0, "c"); assert_eq!(entries[2].0, "a"); }
#[test]
fn sort_entries_last_active_desc_correct() {
let mut entries = vec![
("a".to_string(), 100, 50),
("b".to_string(), 300, 200),
("c".to_string(), 200, 100),
];
sort_entries(&mut entries, SearchSortType::LastActiveDesc);
assert_eq!(entries[0].0, "b"); assert_eq!(entries[1].0, "c"); assert_eq!(entries[2].0, "a"); }
#[test]
fn sort_entries_empty_list_no_panic() {
let mut entries: Vec<(String, i64, i64)> = vec![];
sort_entries(&mut entries, SearchSortType::CreatedAsc);
assert!(entries.is_empty());
}
#[test]
fn sort_entries_single_element_no_panic() {
let mut entries = vec![("only".to_string(), 42, 99)];
sort_entries(&mut entries, SearchSortType::LastActiveAsc);
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].0, "only");
}
}