chore: normalize code

2025-05-17 02:08:59 +07:00
parent 874f25aa80
commit a43ef8ec04
104 changed files with 691 additions and 655 deletions
@@ -0,0 +1,4 @@
+#[cfg(test)]
+pub mod permissions_controller_test;
+#[cfg(test)]
+pub mod permissions_repository_test;
@@ -0,0 +1,171 @@
+use crate::{
+	create_mock_app_state, permissions_router,
+	v1::{
+		permissions_dto::PermissionsRequestDto,
+		permissions_repository::PermissionsRepository,
+	},
+	AppState,
+};
+use axum::{http::StatusCode, Extension, Router};
+use axum_test::TestServer;
+
+pub fn create_test_app(state: AppState) -> TestServer {
+	let app = Router::new()
+		.nest("/v1/permissions", permissions_router())
+		.layer(Extension(state));
+	TestServer::new(app).unwrap()
+}
+
+async fn create_dummy_permission(
+	repo: &PermissionsRepository<'_>,
+	name: &str,
+) -> String {
+	let dto = crate::v1::permissions_schema::PermissionsSchema {
+		name: name.into(),
+		..Default::default()
+	};
+	let _ = repo.query_create_permission(dto.clone()).await.unwrap();
+	let found = repo.query_permission_by_name(name.into()).await.unwrap();
+	found.id.id.to_raw()
+}
+
+async fn delete_dummy_permission(repo: &PermissionsRepository<'_>, id: String) {
+	let _ = repo.query_delete_permission(id).await;
+}
+
+#[tokio::test]
+async fn test_create_permission_should_return_201() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let server = create_test_app(state.clone());
+	let payload = PermissionsRequestDto {
+		name: "Create Permission".into(),
+	};
+	let res = server.post("/v1/permissions/create").json(&payload).await;
+	dbg!(res.text());
+	assert_eq!(res.status_code(), StatusCode::CREATED);
+	let id = repo
+		.query_permission_by_name(payload.name.clone())
+		.await
+		.unwrap()
+		.id
+		.id
+		.to_raw();
+	delete_dummy_permission(&repo, id).await;
+}
+
+#[tokio::test]
+async fn test_get_permission_list_should_return_200() {
+	let state = create_mock_app_state().await;
+	let server = create_test_app(state);
+	let res = server.get("/v1/permissions?page=1&per_page=10").await;
+	dbg!(res.text());
+	assert_eq!(res.status_code(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn test_get_permission_by_id_should_return_200() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let id = create_dummy_permission(&repo, "Get Permission").await;
+	let server = create_test_app(state.clone());
+	let res = server.get(&format!("/v1/permissions/detail/{}", id)).await;
+	dbg!(res.text());
+	assert_eq!(res.status_code(), StatusCode::OK);
+	delete_dummy_permission(&repo, id).await;
+}
+
+#[tokio::test]
+async fn test_update_permission_should_return_200() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let id = create_dummy_permission(&repo, "To Update").await;
+	let server = create_test_app(state.clone());
+	let payload = PermissionsRequestDto {
+		name: "Updated Permission".into(),
+	};
+	let res = server
+		.put(&format!("/v1/permissions/update/{}", id.clone()))
+		.json(&payload)
+		.await;
+	dbg!(res.text());
+	assert_eq!(res.status_code(), StatusCode::OK);
+	delete_dummy_permission(&repo, id).await;
+}
+
+#[tokio::test]
+async fn test_delete_permission_should_return_200() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let id = create_dummy_permission(&repo, "To Delete").await;
+	let server = create_test_app(state);
+	let res = server
+		.delete(&format!("/v1/permissions/delete/{}", id))
+		.await;
+	dbg!(res.text());
+	assert_eq!(res.status_code(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn test_create_duplicate_permission_should_return_409() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let name = "Duplicate Permission";
+	let id = create_dummy_permission(&repo, name).await;
+	let server = create_test_app(state.clone());
+	let payload = PermissionsRequestDto { name: name.into() };
+	let res = server.post("/v1/permissions/create").json(&payload).await;
+	assert_eq!(res.status_code(), StatusCode::CONFLICT);
+	delete_dummy_permission(&repo, id).await;
+}
+
+#[tokio::test]
+async fn test_delete_nonexistent_permission_should_return_404() {
+	let state = create_mock_app_state().await;
+	let server = create_test_app(state);
+	let res = server.delete("/v1/permissions/delete/nonexistent-id").await;
+	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
+}
+
+#[tokio::test]
+async fn test_create_permission_with_empty_name_should_return_400() {
+	let state = create_mock_app_state().await;
+	let server = create_test_app(state);
+	let payload = PermissionsRequestDto { name: "".into() };
+	let res = server.post("/v1/permissions/create").json(&payload).await;
+	dbg!(res.text());
+	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
+}
+
+#[tokio::test]
+async fn test_update_nonexistent_permission_should_return_404() {
+	let state = create_mock_app_state().await;
+	let server = create_test_app(state);
+	let payload = PermissionsRequestDto {
+		name: "Nonexistent".into(),
+	};
+	let res = server
+		.put("/v1/permissions/update/non-exist")
+		.json(&payload)
+		.await;
+	dbg!(res.text());
+	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
+}
+
+#[tokio::test]
+async fn test_get_permission_by_invalid_id_should_return_404() {
+	let state = create_mock_app_state().await;
+	let server = create_test_app(state);
+	let res = server.get("/v1/permissions/detail/invalid-id").await;
+	dbg!(res.text());
+	assert_eq!(res.status_code(), StatusCode::NOT_FOUND);
+}
+
+#[tokio::test]
+async fn test_get_permission_list_with_invalid_pagination_should_return_400() {
+	let state = create_mock_app_state().await;
+	let server = create_test_app(state);
+	let res = server.get("/v1/permissions?page=abc&per_page=xyz").await;
+	dbg!(res.text());
+	assert_eq!(res.status_code(), StatusCode::BAD_REQUEST);
+}
@@ -0,0 +1,111 @@
+use crate::{
+	create_mock_app_state,
+	permissions::{PermissionsRepository, PermissionsSchema},
+};
+use chrono::Utc;
+
+fn create_dummy_permission(name: &str) -> PermissionsSchema {
+	PermissionsSchema {
+		name: name.to_string(),
+		..Default::default()
+	}
+}
+
+#[tokio::test]
+async fn test_create_permission_should_succeed() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let permission = create_dummy_permission("Test Permission");
+	let result = repo.query_create_permission(permission).await;
+	assert!(result.is_ok(), "Create failed: {:?}", result.err());
+}
+
+#[tokio::test]
+async fn test_query_permission_list_should_return_data() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+
+	let _ = repo
+		.query_create_permission(create_dummy_permission("View"))
+		.await;
+	let meta = crate::MetaRequestDto {
+		page: Some(1),
+		per_page: Some(10),
+		search: None,
+		sort_by: None,
+		order: None,
+		filter: None,
+		filter_by: None,
+	};
+
+	let result = repo.query_permission_list(meta).await;
+	assert!(result.is_ok(), "List failed: {:?}", result.err());
+	assert!(!result.unwrap().data.is_empty(), "Data should not be empty");
+}
+
+#[tokio::test]
+async fn test_query_permission_by_id_should_succeed() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let permission = create_dummy_permission("Detail");
+	let _ = repo.query_create_permission(permission.clone()).await;
+	let id = permission.id.id.to_raw();
+	let result = repo.query_permission_by_id(id).await;
+	assert!(result.is_ok(), "Get by id failed: {:?}", result.err());
+}
+
+#[tokio::test]
+async fn test_update_permission_should_succeed() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let mut permission = create_dummy_permission("Update This");
+	let _ = repo.query_create_permission(permission.clone()).await;
+	permission.name = "Updated Name".into();
+	permission.updated_at = Some(Utc::now().to_rfc3339());
+	let result = repo.query_update_permission(permission).await;
+	assert!(result.is_ok(), "Update failed: {:?}", result.err());
+}
+
+#[tokio::test]
+async fn test_delete_permission_should_succeed() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let permission = create_dummy_permission("To Be Deleted");
+	let _ = repo.query_create_permission(permission.clone()).await;
+	let id = permission.id.id.to_raw();
+	let result = repo.query_delete_permission(id).await;
+	assert!(result.is_ok(), "Delete failed: {:?}", result.err());
+}
+
+#[tokio::test]
+async fn test_delete_permission_should_fail_if_already_deleted() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let permission = create_dummy_permission("Delete Twice");
+	let _ = repo.query_create_permission(permission.clone()).await;
+	let id = permission.id.id.to_raw();
+	let _ = repo.query_delete_permission(id.clone()).await;
+	let second = repo.query_delete_permission(id).await;
+	assert!(second.is_err(), "Should fail on second delete");
+}
+
+#[tokio::test]
+async fn test_update_permission_should_fail_if_deleted() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let mut permission = create_dummy_permission("To Be Updated Then Deleted");
+	let _ = repo.query_create_permission(permission.clone()).await;
+	let id = permission.id.id.to_raw();
+	let _ = repo.query_delete_permission(id.clone()).await;
+	permission.name = "Try Update".into();
+	let result = repo.query_update_permission(permission).await;
+	assert!(result.is_err(), "Update on deleted should fail");
+}
+
+#[tokio::test]
+async fn test_query_permission_by_id_should_fail_if_not_found() {
+	let state = create_mock_app_state().await;
+	let repo = PermissionsRepository::new(&state);
+	let result = repo.query_permission_by_id("non-existent-id".into()).await;
+	assert!(result.is_err(), "Expected error for not found id");
+}