use serde::Deserialize;
use serde_json::{Value, json};
use crate::{
error::{AppError, Result},
storage::Storage,
types::UserPoolId,
};
#[derive(Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
struct Request {
user_pool_id: UserPoolId,
group_name: String,
#[serde(default = "default_limit")]
limit: i32,
next_token: Option<String>,
}
fn default_limit() -> i32 {
60
}
pub async fn handler(storage: &Storage, body: Value) -> Result<Value> {
let req: Request = serde_json::from_value(body)
.map_err(|e| AppError::InvalidParameter(format!("Invalid request: {}", e)))?;
storage
.get_user_pool(&req.user_pool_id)
.await
.ok_or(AppError::UserPoolNotFound)?;
storage
.get_group(&req.user_pool_id, &req.group_name)
.await
.ok_or(AppError::GroupNotFound)?;
if req.limit <= 0 {
return Err(AppError::InvalidParameter(
"Limit must be greater than 0".to_string(),
));
}
let mut users = storage
.get_users_in_group(&req.user_pool_id, &req.group_name)
.await;
users.sort_by(|a, b| a.username.cmp(&b.username));
let start = req
.next_token
.as_deref()
.map(|token| {
token
.parse::<usize>()
.map_err(|_| AppError::InvalidParameter("Invalid NextToken".to_string()))
})
.transpose()?
.unwrap_or(0);
if start > users.len() {
return Err(AppError::InvalidParameter("Invalid NextToken".to_string()));
}
let end = (start + req.limit as usize).min(users.len());
let users_json: Vec<Value> = users[start..end]
.iter()
.map(|u| {
json!({
"Username": u.username,
"Enabled": u.enabled,
"UserStatus": u.user_status,
"UserCreateDate": u.creation_date.timestamp(),
"UserLastModifiedDate": u.last_modified_date.timestamp(),
"Attributes": u.attributes.iter().map(|a| {
json!({
"Name": a.name,
"Value": a.value
})
}).collect::<Vec<_>>()
})
})
.collect();
let mut response = json!({
"Users": users_json
});
if end < users.len() {
response["NextToken"] = json!(end.to_string());
}
Ok(response)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::action::group::{admin_add_user_to_group, create_group};
use crate::action::user::admin_create_user;
use crate::action::user_pool::create_user_pool;
use serde_json::json;
#[tokio::test]
async fn test_list_users_in_group_empty() {
let storage = Storage::new();
let pool = create_user_pool::handler(&storage, json!({"PoolName": "test-pool"}))
.await
.unwrap();
let pool_id = pool["UserPool"]["Id"].as_str().unwrap();
create_group::handler(
&storage,
json!({
"UserPoolId": pool_id,
"GroupName": "admins"
}),
)
.await
.unwrap();
let result = handler(
&storage,
json!({
"UserPoolId": pool_id,
"GroupName": "admins"
}),
)
.await;
assert!(result.is_ok());
let body = result.unwrap();
assert_eq!(body["Users"].as_array().unwrap().len(), 0);
}
#[tokio::test]
async fn test_list_users_in_group_with_users() {
let storage = Storage::new();
let pool = create_user_pool::handler(&storage, json!({"PoolName": "test-pool"}))
.await
.unwrap();
let pool_id = pool["UserPool"]["Id"].as_str().unwrap();
create_group::handler(
&storage,
json!({
"UserPoolId": pool_id,
"GroupName": "admins"
}),
)
.await
.unwrap();
admin_create_user::handler(
&storage,
json!({
"UserPoolId": pool_id,
"Username": "testuser",
"TemporaryPassword": "TempPass123!"
}),
)
.await
.unwrap();
admin_add_user_to_group::handler(
&storage,
json!({
"UserPoolId": pool_id,
"Username": "testuser",
"GroupName": "admins"
}),
)
.await
.unwrap();
let result = handler(
&storage,
json!({
"UserPoolId": pool_id,
"GroupName": "admins"
}),
)
.await;
assert!(result.is_ok());
let body = result.unwrap();
assert_eq!(body["Users"].as_array().unwrap().len(), 1);
assert_eq!(body["Users"][0]["Username"], "testuser");
}
#[tokio::test]
async fn test_list_users_in_group_not_found() {
let storage = Storage::new();
let pool = create_user_pool::handler(&storage, json!({"PoolName": "test-pool"}))
.await
.unwrap();
let pool_id = pool["UserPool"]["Id"].as_str().unwrap();
let result = handler(
&storage,
json!({
"UserPoolId": pool_id,
"GroupName": "nonexistent"
}),
)
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_list_users_in_group_with_pagination() {
let storage = Storage::new();
let pool = create_user_pool::handler(&storage, json!({"PoolName": "test-pool"}))
.await
.unwrap();
let pool_id = pool["UserPool"]["Id"].as_str().unwrap();
create_group::handler(
&storage,
json!({
"UserPoolId": pool_id,
"GroupName": "admins"
}),
)
.await
.unwrap();
for username in ["alice", "bob", "charlie"] {
admin_create_user::handler(
&storage,
json!({
"UserPoolId": pool_id,
"Username": username,
"TemporaryPassword": "TempPass123!"
}),
)
.await
.unwrap();
admin_add_user_to_group::handler(
&storage,
json!({
"UserPoolId": pool_id,
"Username": username,
"GroupName": "admins"
}),
)
.await
.unwrap();
}
let first = handler(
&storage,
json!({
"UserPoolId": pool_id,
"GroupName": "admins",
"Limit": 2
}),
)
.await
.unwrap();
assert_eq!(first["Users"].as_array().unwrap().len(), 2);
assert_eq!(first["NextToken"], "2");
let second = handler(
&storage,
json!({
"UserPoolId": pool_id,
"GroupName": "admins",
"Limit": 2,
"NextToken": "2"
}),
)
.await
.unwrap();
assert_eq!(second["Users"].as_array().unwrap().len(), 1);
assert!(second.get("NextToken").is_none());
}
}