MythEclipse/imphnen-backend-service
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: finishing gacha feature

Browse Source
This commit is contained in:
Maulana Sodiqin
2025-05-21 19:37:30 +07:00
parent 33a2ae86c6
commit 465cbee2c3
10 changed files with 80 additions and 715 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/src/iam/auth/auth_controller_test.rs
-667
View File
@@ -1,667 +0,0 @@
use crate::{
AuthOtpSchema, AuthRepository, OtpManager, ResourceEnum, RolesRepository,
UsersRepository, auth::auth_router, create_mock_app_state, create_test_user,
encode_refresh_token,
};
use axum::{Extension, http::StatusCode};
use axum_test::TestServer;
use serde_json::json;
use surrealdb::Uuid;
#[tokio::test]
async fn test_login_should_fail_with_invalid_user() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({
"email": "nonexistent@example.com",
"password": "wrongpassword"
});
let res = server.post("/v1/auth/login").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::UNAUTHORIZED);
let body = res.text();
println!("🧪 Response Body: {}", body);
}
#[tokio::test]
async fn test_login_should_fail_with_wrong_password() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone()));
let server = TestServer::new(app).unwrap();
let repo = UsersRepository::new(&state);
let role_repo = RolesRepository::new(&state);
let role_id = role_repo
.query_role_by_name("Student".to_string())
.await
.unwrap()
.id;
let mut user = create_test_user("user@example.com", "User Satu", true, &role_id);
user.password = crate::hash_password("correctpassword").unwrap();
repo.query_create_user(user).await.unwrap();
let payload = json!({
"email": "user@example.com",
"password": "wrongpassword"
});
let res = server.post("/v1/auth/login").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
println!("🧪 Wrong password: {}", body);
}
#[tokio::test]
async fn test_login_should_fail_if_user_not_active() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone()));
let server = TestServer::new(app).unwrap();
let repo = UsersRepository::new(&state);
let role_repo = RolesRepository::new(&state);
let role_id = role_repo
.query_role_by_name("Student".to_string())
.await
.unwrap()
.id;
let mut user = create_test_user(
"inactive-again@example.com",
"Inactive User",
false,
&role_id,
);
user.password = crate::hash_password("secret").unwrap();
repo.query_create_user(user).await.unwrap();
let payload = json!({
"email": "inactive-again@example.com",
"password": "secret"
});
let res = server.post("/v1/auth/login").json(&payload).await;
dbg!(res.text());
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
println!("🧪 Not active user: {}", body);
}
#[tokio::test]
async fn test_login_should_succeed() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone()));
let server = TestServer::new(app).unwrap();
let repo = UsersRepository::new(&state);
let role_repo = RolesRepository::new(&state);
let role_id = role_repo
.query_role_by_name("Student".to_string())
.await
.unwrap()
.id;
let mut user =
create_test_user("active@example.com", "Active User", true, &role_id);
user.password = crate::hash_password("secret").unwrap();
repo.query_create_user(user).await.unwrap();
let payload = json!({
"email": "active@example.com",
"password": "secret"
});
let res = server.post("/v1/auth/login").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::OK);
let json = res.json::<serde_json::Value>();
assert!(json["data"]["token"]["access_token"].is_string());
assert!(json["data"]["user"]["email"] == "active@example.com");
}
#[tokio::test]
async fn test_login_should_fail_if_payload_empty() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({});
let res = server.post("/v1/auth/login").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
}
#[tokio::test]
async fn test_login_should_fail_if_password_empty() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({
"email": "test@test.com",
"password": ""
});
let res = server.post("/v1/auth/login").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_login_should_fail_if_email_not_valid() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({
"email": "test",
"password": "test123"
});
let res = server.post("/v1/auth/login").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_register_should_succeed() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone()));
let server = TestServer::new(app).unwrap();
let random_email = format!("validuser+{}@example.com", Uuid::new_v4());
let payload = json!({
"email": random_email,
"password": "Validpass1!",
"fullname": "Valid User",
"student_type": "regular",
"phone_number": "0812345678",
"reffered_by": "Facebook",
"refferal_code": "KFNB"
});
let res = server.post("/v1/auth/register").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::CREATED);
}
#[tokio::test]
async fn test_register_should_fail_if_email_already_taken() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone()));
let server = TestServer::new(app).unwrap();
let repo = UsersRepository::new(&state);
let role_repo = RolesRepository::new(&state);
let role_id = role_repo
.query_role_by_name("Student".to_string())
.await
.unwrap()
.id;
let mut user =
create_test_user("duplicate@example.com", "User Exists", false, &role_id);
user.password = crate::hash_password("secret").unwrap();
repo.query_create_user(user).await.unwrap();
let payload = json!({
"fullname": "User Exists",
"email": "duplicate@example.com",
"password": "secret",
"student_type": "general",
"phone_number": "081234567890",
"referral_code": null,
"referred_by": null
});
let res = server.post("/v1/auth/register").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_register_should_fail_if_email_invalid() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({
"fullname": "Invalid Email",
"email": "invalid-email",
"password": "secret",
"student_type": "general",
"phone_number": "081234567890",
"referral_code": null,
"referred_by": null
});
let res = server.post("/v1/auth/register").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_register_should_fail_if_password_empty() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({
"fullname": "No Password",
"email": "nopass@example.com",
"password": "",
"student_type": "general",
"phone_number": "081234567890",
"referral_code": null,
"referred_by": null
});
let res = server.post("/v1/auth/register").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_register_should_fail_if_payload_empty() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({});
let res = server.post("/v1/auth/register").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
}
#[tokio::test]
async fn test_send_otp_should_succeed() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({
"email": "user@example.com"
});
let res = server.post("/v1/auth/send-otp").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::OK);
let json = res.json::<serde_json::Value>();
assert_eq!(json["message"], "OTP resent successfully");
}
#[tokio::test]
async fn test_send_otp_should_fail_if_email_empty() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({ "email": "" });
let res = server.post("/v1/auth/send-otp").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let json = res.json::<serde_json::Value>();
assert_eq!(json["message"], "Email cannot be empty, Email not valid");
}
#[tokio::test]
async fn test_send_otp_should_fail_with_invalid_email_format() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({ "email": "not-an-email" });
let res = server.post("/v1/auth/send-otp").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let json = res.json::<serde_json::Value>();
assert_eq!(json["message"], "Email not valid");
}
#[tokio::test]
async fn test_send_otp_should_fail_if_payload_empty() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({});
let res = server.post("/v1/auth/send-otp").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
}
#[tokio::test]
async fn test_send_otp_should_fail_if_otp_store_fails() {
let mut state = create_mock_app_state().await;
state.surrealdb_mem = surrealdb::Surreal::new::<surrealdb::engine::local::Mem>(())
.await
.expect("failed to create mock surrealdb_mem");
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = serde_json::json!({ "email": "fail-store@example.com" });
let res = server.post("/v1/auth/send-otp").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
assert!(
body.contains("Specify a namespace to use") || body.contains("Failed store otp"),
"Expected namespace setup error or store failure, got: {body}"
);
}
#[tokio::test]
async fn test_forgot_password_should_succeed() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone()));
let server = TestServer::new(app).unwrap();
let role_repo = RolesRepository::new(&state);
let role_id = role_repo
.query_role_by_name("Student".to_string())
.await
.unwrap()
.id;
let mut user =
create_test_user("forgot@example.com", "Forgot User", true, &role_id);
user.password = crate::hash_password("secret").unwrap();
let user_repo = UsersRepository::new(&state);
user_repo.query_create_user(user).await.unwrap();
let payload = json!({ "email": "forgot@example.com" });
let res = server.post("/v1/auth/forgot").json(&payload).await;
dbg!(res.text());
assert_eq!(res.status_code(), StatusCode::OK);
let body = res.text();
assert!(
body.contains("Reset Password request send"),
"Unexpected response: {body}"
);
}
#[tokio::test]
async fn test_forgot_password_should_fail_if_user_not_found() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({ "email": "notfound@example.com" });
let res = server.post("/v1/auth/forgot").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
assert!(
body.contains("User not found"),
"Expected 'User not found', got: {body}"
);
}
#[tokio::test]
async fn test_forgot_password_should_fail_if_email_invalid() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({ "email": "" });
let res = server.post("/v1/auth/forgot").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
assert!(
body.contains("Email not valid") || body.contains("User not found"),
"Expected email error, got: {body}"
);
}
#[tokio::test]
async fn test_refresh_should_succeed() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let valid_token = encode_refresh_token("refreshme@example.com".into()).unwrap();
let payload = json!({
"refresh_token": valid_token
});
let res = server.post("/v1/auth/refresh").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::OK);
let body = res.json::<serde_json::Value>();
assert!(body["data"]["access_token"].is_string());
assert!(body["data"]["refresh_token"].is_string());
}
#[tokio::test]
async fn test_refresh_should_fail_with_invalid_token() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({
"refresh_token": "invalid.token.value"
});
let res = server.post("/v1/auth/refresh").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::UNAUTHORIZED);
let body = res.text();
assert!(body.contains("Invalid refresh token"));
}
#[tokio::test]
async fn test_refresh_should_fail_with_empty_payload() {
let state = create_mock_app_state().await;
let app = axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state));
let server = TestServer::new(app).unwrap();
let payload = json!({});
let res = server.post("/v1/auth/refresh").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
}
#[tokio::test]
async fn test_verify_email_should_succeed() {
let state = create_mock_app_state().await;
let server = TestServer::new(
axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone())),
)
.unwrap();
let role_repo = RolesRepository::new(&state);
let role_id = role_repo
.query_role_by_name("Student".to_string())
.await
.unwrap()
.id;
let user = create_test_user("verify@example.com", "Verify User", false, &role_id);
let otp = OtpManager::generate_otp();
let user_repo = UsersRepository::new(&state);
let auth_repo = AuthRepository::new(&state);
user_repo.query_create_user(user.clone()).await.unwrap();
auth_repo
.query_store_otp(user.email.clone(), otp)
.await
.unwrap();
let payload = json!({
"email": user.email,
"otp": otp
});
let res = server.post("/v1/auth/verify-email").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::OK);
let body = res.text();
assert!(body.contains("Email verified successfully"));
}
#[tokio::test]
async fn test_verify_email_should_fail_with_wrong_otp() {
let state = create_mock_app_state().await;
let server = TestServer::new(
axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone())),
)
.unwrap();
let role_repo = RolesRepository::new(&state);
let role_id = role_repo
.query_role_by_name("Student".to_string())
.await
.unwrap()
.id;
let user = create_test_user("wrongotp@example.com", "Wrong OTP", false, &role_id);
let otp = OtpManager::generate_otp();
let user_repo = UsersRepository::new(&state);
let auth_repo = AuthRepository::new(&state);
user_repo.query_create_user(user.clone()).await.unwrap();
auth_repo
.query_store_otp(user.email.clone(), otp)
.await
.unwrap();
let payload = json!({
"email": user.email,
"otp": 999_999
});
let res = server.post("/v1/auth/verify-email").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
assert!(body.contains("Failed to verify OTP"));
}
#[tokio::test]
async fn test_verify_email_should_fail_if_otp_expired() {
let state = create_mock_app_state().await;
let server = TestServer::new(
axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone())),
)
.unwrap();
let role_repo = RolesRepository::new(&state);
let role_id = role_repo
.query_role_by_name("Student".to_string())
.await
.unwrap()
.id;
let user = create_test_user("expired@example.com", "Expired OTP", false, &role_id);
let user_repo = UsersRepository::new(&state);
user_repo.query_create_user(user.clone()).await.unwrap();
use chrono::{Duration, Utc};
let expired_otp = AuthOtpSchema {
otp: 123456,
expires_at: Utc::now() - Duration::minutes(1),
};
let _: Option<AuthOtpSchema> = state
.surrealdb_mem
.create((ResourceEnum::OtpCache.to_string(), user.email.clone()))
.content(expired_otp)
.await
.unwrap();
let payload = json!({
"email": user.email,
"otp": 123456
});
let res = server.post("/v1/auth/verify-email").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
assert!(body.contains("OTP expired"));
}
#[tokio::test]
async fn test_verify_email_should_fail_with_empty_payload() {
let state = create_mock_app_state().await;
let server = TestServer::new(
axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state)),
)
.unwrap();
let res = server.post("/v1/auth/verify-email").json(&json!({})).await;
assert_eq!(res.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
}
#[tokio::test]
async fn test_new_password_should_succeed() {
let state = create_mock_app_state().await;
let server = TestServer::new(
axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state.clone())),
)
.unwrap();
let email = "resetme@example.com";
let repo = UsersRepository::new(&state);
let role_repo = RolesRepository::new(&state);
let role_id = role_repo
.query_role_by_name("Student".to_string())
.await
.unwrap()
.id;
let mut user = create_test_user(email, "Reset User", true, &role_id);
user.password = crate::hash_password("oldpass123!").unwrap();
repo.query_create_user(user).await.unwrap();
let token = crate::encode_reset_password_token(email.to_string()).unwrap();
let payload = json!({
"token": token,
"password": "Newpass123!"
});
let res = server.post("/v1/auth/new-password").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::OK);
let body = res.text();
assert!(body.contains("Success update password user"));
}
#[tokio::test]
async fn test_new_password_should_fail_if_token_is_empty() {
let state = create_mock_app_state().await;
let server = TestServer::new(
axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state)),
)
.unwrap();
let payload = json!({
"token": "",
"password": "Newpass123!"
});
let res = server.post("/v1/auth/new-password").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
assert!(
body.contains("Invalid or missing token"),
"Gagal deteksi token kosong: {body}"
);
}
#[tokio::test]
async fn test_new_password_should_fail_if_password_is_weak() {
let state = create_mock_app_state().await;
let server = TestServer::new(
axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state)),
)
.unwrap();
let email = "weakpass@example.com";
let token = crate::encode_reset_password_token(email.to_string()).unwrap();
let payload = json!({
"token": token,
"password": "123"
});
let res = server.post("/v1/auth/new-password").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
assert!(
body.contains("Password must have at least")
|| body.contains("Password must include"),
"Pesan error nggak sesuai: {body}"
);
}
#[tokio::test]
async fn test_new_password_should_fail_if_user_not_found() {
let state = create_mock_app_state().await;
let server = TestServer::new(
axum::Router::new()
.nest("/v1/auth", auth_router())
.layer(Extension(state)),
)
.unwrap();
let token =
crate::encode_reset_password_token("ghost@example.com".into()).unwrap();
let payload = json!({
"token": token,
"password": "Validpass123!"
});
let res = server.post("/v1/auth/new-password").json(&payload).await;
assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
let body = res.text();
assert!(body.contains("User not found"));
}
tests/src/iam/auth/mod.rs
-2
View File
@@ -1,4 +1,2 @@
#[cfg(test)]
pub mod auth_controller_test;
#[cfg(test)]
pub mod auth_repository_test;
tests/src/iam/roles/roles_repository_test.rs
+7 -5
View File
@@ -74,7 +74,7 @@ async fn test_query_update_role_should_update_name_and_permissions() {
let original_perm_id = Uuid::new_v4().to_string();
let original_perm = PermissionsSchema {
id: make_thing(&ResourceEnum::Permissions.to_string(), &original_perm_id),
name: "Original Permission".into(),
name: generate_unique_name("original_permission"),
is_deleted: false,
created_at: Some(crate::get_iso_date()),
updated_at: None,
@@ -83,13 +83,14 @@ async fn test_query_update_role_should_update_name_and_permissions() {
.query_create_permission(original_perm)
.await
.unwrap();
let role_upadate_name = generate_unique_name("role_for_update");
let create_payload = RolesRequestCreateDto {
name: "Role For Update".into(),
name: role_upadate_name.clone(),
permissions: vec![original_perm_id.clone()],
};
repo.query_create_role(create_payload).await.unwrap();
let existing_role = repo
.query_role_by_name("Role For Update".into())
.query_role_by_name(role_upadate_name.clone())
.await
.unwrap();
let existing_role_id = existing_role.id.clone();
@@ -101,9 +102,10 @@ async fn test_query_update_role_should_update_name_and_permissions() {
created_at: Some(crate::get_iso_date()),
updated_at: None,
};
let new_role_name = generate_unique_name("updated_role_name");
perm_repo.query_create_permission(new_perm).await.unwrap();
let update_payload = RolesRequestUpdateDto {
name: Some("Updated Role Name".into()),
name: Some(new_role_name.clone()),
permissions: Some(vec![new_perm_id.clone()]),
overwrite: None,
};
@@ -115,7 +117,7 @@ async fn test_query_update_role_should_update_name_and_permissions() {
.query_role_by_id(existing_role_id.clone())
.await
.unwrap();
assert_eq!(updated.name, "Updated Role Name");
assert_eq!(updated.name, new_role_name.clone());
}
#[tokio::test]
tests/src/iam/users/users_repository_test.rs
+13 -2
View File
@@ -1,13 +1,24 @@
use imphnen_iam::RolesRequestCreateDto;
use surrealdb::Uuid;
use crate::{MetaRequestDto, UsersRepository};
use crate::{RolesRepository, create_mock_app_state, create_test_user};
async fn get_role_id(state: &crate::AppState) -> String {
RolesRepository::new(state)
let repo = RolesRepository::new(state);
if let Ok(existing) = repo.query_role_by_name("User".into()).await {
return existing.id;
}
let _ = repo
.query_create_role(RolesRequestCreateDto {
name: "User".into(),
permissions: vec![],
})
.await;
repo
.query_role_by_name("User".into())
.await
.expect("Role not found")
.expect("Role not found after creation")
.id
}