feat: add system quality improvement plan and implementation

e2e_tests/tests/test_role.py

@@ -20,9 +20,10 @@ class TestRole:
         assert response.status_code == 201
         data = response.json()
         assert "id" in data
-        assert data["name"] == test_role_data["name"]
-        assert data["description"] == test_role_data["description"]
-        assert data["permissions"] == test_role_data["permissions"]
+        assert data["roleName"] == test_role_data["roleName"]
+        assert data["roleKey"] == test_role_data["roleKey"]
+        assert data["roleSort"] == test_role_data["roleSort"]
+        assert data["status"] == test_role_data["status"]
         
         cleanup_role.append(data["id"])
     
@@ -53,7 +54,7 @@ class TestRole:
         assert response.status_code == 200
         data = response.json()
         assert data["id"] == role_id
-        assert data["name"] == test_role_data["name"]
+        assert data["roleName"] == test_role_data["roleName"]
         
         cleanup_role.append(role_id)
     
@@ -73,11 +74,11 @@ class TestRole:
         create_response = await role_api.create_role(test_role_data)
         role_id = create_response.json()["id"]
         
-        response = await role_api.get_role_by_name(test_role_data["name"])
+        response = await role_api.get_role_by_name(test_role_data["roleName"])
         
         assert response.status_code == 200
         data = response.json()
-        assert data["name"] == test_role_data["name"]
+        assert data["roleName"] == test_role_data["roleName"]
         
         cleanup_role.append(role_id)
     
@@ -99,18 +100,20 @@ class TestRole:
         create_response = await role_api.create_role(test_role_data)
         role_id = create_response.json()["id"]
         
-        update_data = {"description": "Updated description"}
+        import time
+        timestamp = int(time.time() * 1000)
+        update_data = {"roleName": f"UPDATED_ROLE_{timestamp}"}
         response = await role_api.update_role(role_id, update_data)
         
         assert response.status_code == 200
         data = response.json()
-        assert data["description"] == "Updated description"
+        assert data["roleName"] == f"UPDATED_ROLE_{timestamp}"
         
         cleanup_role.append(role_id)
     
     @pytest.mark.asyncio
     async def test_delete_role_success(self, authenticated_client, test_role_data, cleanup_role):
-        """测试删除角色成功"""
+        """测试删除角色成功（逻辑删除）"""
         role_api = RoleAPI(authenticated_client)
         
         create_response = await role_api.create_role(test_role_data)
@@ -118,27 +121,13 @@ class TestRole:
         
         response = await role_api.delete_role(role_id)
         
-        assert response.status_code == 204
-    
-    @pytest.mark.asyncio
-    async def test_logical_delete_role_success(self, authenticated_client, test_role_data, cleanup_role):
-        """测试逻辑删除角色成功"""
-        role_api = RoleAPI(authenticated_client)
-        
-        create_response = await role_api.create_role(test_role_data)
-        role_id = create_response.json()["id"]
-        
-        response = await role_api.logical_delete_role(role_id)
-        
         assert response.status_code == 200
+        data = response.json()
+        assert data["deletedAt"] is not None
         
         get_response = await role_api.get_role_by_id(role_id)
         assert get_response.status_code == 404
         
-        get_deleted_response = await role_api.get_all_roles(include_deleted=True)
-        deleted_roles = get_deleted_response.json()
-        assert any(r["id"] == role_id for r in deleted_roles)
-        
         cleanup_role.append(role_id)
     
     @pytest.mark.asyncio
@@ -149,7 +138,7 @@ class TestRole:
         create_response = await role_api.create_role(test_role_data)
         role_id = create_response.json()["id"]
         
-        await role_api.logical_delete_role(role_id)
+        await role_api.delete_role(role_id)
         
         response = await role_api.restore_role(role_id)
         
@@ -168,7 +157,7 @@ class TestRole:
         create_response = await role_api.create_role(test_role_data)
         role_id = create_response.json()["id"]
         
-        response = await role_api.check_name_exists(test_role_data["name"])
+        response = await role_api.check_name_exists(test_role_data["roleName"])
         
         assert response.status_code == 200
         assert response.json() is True
@@ -183,3 +172,173 @@ class TestRole:
         
         assert response.status_code == 200
         assert response.json() is False
+    
+    @pytest.mark.asyncio
+    async def test_get_roles_by_page_success(self, authenticated_client, test_role_data, cleanup_role):
+        """测试分页获取角色成功"""
+        role_api = RoleAPI(authenticated_client)
+        
+        import time
+        for i in range(5):
+            timestamp = int(time.time() * 1000)
+            role_data = {
+                "roleName": f"testrole_{timestamp}_{i}",
+                "roleKey": f"testrole_{timestamp}_{i}",
+                "roleSort": 1,
+                "status": 1
+            }
+            create_response = await role_api.create_role(role_data)
+            cleanup_role.append(create_response.json()["id"])
+        
+        response = await role_api.get_roles_by_page(page=0, size=10)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "content" in data
+        assert "totalElements" in data
+        assert "totalPages" in data
+        assert "currentPage" in data
+        assert "pageSize" in data
+        assert len(data["content"]) <= 10
+    
+    @pytest.mark.asyncio
+    async def test_get_roles_by_page_with_sort(self, authenticated_client, test_role_data, cleanup_role):
+        """测试分页获取角色并排序成功"""
+        role_api = RoleAPI(authenticated_client)
+        
+        import time
+        timestamp1 = int(time.time() * 1000)
+        role1_data = {
+            "roleName": f"role_a_{timestamp1}",
+            "roleKey": f"role_a_{timestamp1}",
+            "roleSort": 1,
+            "status": 1
+        }
+        create_response1 = await role_api.create_role(role1_data)
+        cleanup_role.append(create_response1.json()["id"])
+        
+        timestamp2 = int(time.time() * 1000)
+        role2_data = {
+            "roleName": f"role_b_{timestamp2}",
+            "roleKey": f"role_b_{timestamp2}",
+            "roleSort": 2,
+            "status": 1
+        }
+        create_response2 = await role_api.create_role(role2_data)
+        cleanup_role.append(create_response2.json()["id"])
+        
+        response = await role_api.get_roles_by_page(page=0, size=10, sort="roleName", order="asc")
+        
+        assert response.status_code == 200
+        data = response.json()
+        role_names = [role["roleName"] for role in data["content"]]
+        assert role_names == sorted(role_names)
+    
+    @pytest.mark.asyncio
+    async def test_get_roles_by_page_with_search(self, authenticated_client, test_role_data, cleanup_role):
+        """测试分页获取角色并搜索成功"""
+        role_api = RoleAPI(authenticated_client)
+        
+        import time
+        timestamp1 = int(time.time() * 1000)
+        role1_data = {
+            "roleName": f"search_test_role_{timestamp1}",
+            "roleKey": f"search_test_role_{timestamp1}",
+            "roleSort": 1,
+            "status": 1
+        }
+        create_response1 = await role_api.create_role(role1_data)
+        cleanup_role.append(create_response1.json()["id"])
+        
+        timestamp2 = int(time.time() * 1000)
+        role2_data = {
+            "roleName": f"other_role_{timestamp2}",
+            "roleKey": f"other_role_{timestamp2}",
+            "roleSort": 1,
+            "status": 1
+        }
+        create_response2 = await role_api.create_role(role2_data)
+        cleanup_role.append(create_response2.json()["id"])
+        
+        response = await role_api.get_roles_by_page(page=0, size=10, keyword="search")
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data["content"]) >= 1
+        assert all("search" in role["roleName"] or "search" in role["roleKey"] 
+                  for role in data["content"])
+    
+    @pytest.mark.asyncio
+    async def test_get_role_count_success(self, authenticated_client, test_role_data, cleanup_role):
+        """测试获取角色总数成功"""
+        role_api = RoleAPI(authenticated_client)
+        
+        initial_count_response = await role_api.get_role_count()
+        initial_count = initial_count_response.json()
+        
+        create_response = await role_api.create_role(test_role_data)
+        cleanup_role.append(create_response.json()["id"])
+        
+        final_count_response = await role_api.get_role_count()
+        final_count = final_count_response.json()
+        
+        assert final_count == initial_count + 1
+    
+    @pytest.mark.asyncio
+    async def test_get_roles_by_page_with_different_page_sizes(self, authenticated_client, test_role_data, cleanup_role):
+        """测试不同页面大小的分页获取角色成功"""
+        role_api = RoleAPI(authenticated_client)
+        
+        import time
+        for i in range(15):
+            timestamp = int(time.time() * 1000)
+            role_data = {
+                "roleName": f"pagesize_test_{timestamp}_{i}",
+                "roleKey": f"pagesize_test_{timestamp}_{i}",
+                "roleSort": 1,
+                "status": 1
+            }
+            create_response = await role_api.create_role(role_data)
+            cleanup_role.append(create_response.json()["id"])
+        
+        response_size_10 = await role_api.get_roles_by_page(page=0, size=10)
+        assert response_size_10.status_code == 200
+        data_size_10 = response_size_10.json()
+        assert len(data_size_10["content"]) == 10
+        
+        response_size_5 = await role_api.get_roles_by_page(page=0, size=5)
+        assert response_size_5.status_code == 200
+        data_size_5 = response_size_5.json()
+        assert len(data_size_5["content"]) == 5
+    
+    @pytest.mark.asyncio
+    async def test_get_roles_by_page_with_page_navigation(self, authenticated_client, test_role_data, cleanup_role):
+        """测试分页导航成功"""
+        role_api = RoleAPI(authenticated_client)
+        
+        import time
+        for i in range(25):
+            timestamp = int(time.time() * 1000)
+            role_data = {
+                "roleName": f"pagination_test_{timestamp}_{i}",
+                "roleKey": f"pagination_test_{timestamp}_{i}",
+                "roleSort": 1,
+                "status": 1
+            }
+            create_response = await role_api.create_role(role_data)
+            cleanup_role.append(create_response.json()["id"])
+        
+        page1_response = await role_api.get_roles_by_page(page=0, size=10)
+        page1_data = page1_response.json()
+        assert page1_data["currentPage"] == 0
+        assert len(page1_data["content"]) == 10
+        
+        page2_response = await role_api.get_roles_by_page(page=1, size=10)
+        page2_data = page2_response.json()
+        assert page2_data["currentPage"] == 1
+        assert len(page2_data["content"]) == 10
+        
+        page3_response = await role_api.get_roles_by_page(page=2, size=10)
+        page3_data = page3_response.json()
+        assert page3_data["currentPage"] == 2
+        assert len(page3_data["content"]) >= 5