feat: 重构测试框架并优化代码结构

refactor(tests): 将e2e_tests迁移到tests_suite和api_integration_tests
style: 为Java类添加文档注释
docs: 更新.gitignore和配置文件
test: 添加性能测试和Playwright测试脚本
chore: 清理旧测试文件和配置

api_integration_tests/tests/__init__.py

@@ -0,0 +1 @@
+"""测试模块"""

api_integration_tests/tests/test_audit.py

@@ -0,0 +1,218 @@
+"""
+审计日志测试用例
+"""
+
+import pytest
+import time
+from api.audit_api import SysLogAPI
+
+
+@pytest.mark.audit
+@pytest.mark.regression
+class TestLoginLog:
+    """登录日志测试类"""
+
+    @pytest.mark.asyncio
+    async def test_create_login_log(self, authenticated_client):
+        """测试创建登录日志"""
+        api = SysLogAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "username": f"testuser_{timestamp}",
+            "ip": "127.0.0.1",
+            "loginLocation": "本地",
+            "browser": "Chrome",
+            "os": "Mac OS",
+            "status": "0",
+            "msg": "登录成功"
+        }
+
+        response = await api.create_login_log(data)
+
+        assert response.status_code == 201
+        result = response.json()
+        assert result["username"] == data["username"]
+
+    @pytest.mark.asyncio
+    async def test_get_all_login_logs(self, authenticated_client):
+        """测试获取所有登录日志"""
+        api = SysLogAPI(authenticated_client)
+
+        response = await api.get_login_logs()
+
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+
+    @pytest.mark.asyncio
+    async def test_get_login_log_by_id(self, authenticated_client):
+        """测试根据ID获取登录日志"""
+        api = SysLogAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "username": f"testuser_{timestamp}",
+            "ip": "127.0.0.1",
+            "status": "0",
+            "msg": "登录成功"
+        }
+        create_response = await api.create_login_log(data)
+        log_id = create_response.json()["id"]
+
+        response = await api.get_login_log_by_id(log_id)
+
+        assert response.status_code == 200
+        assert response.json()["id"] == log_id
+
+
+@pytest.mark.audit
+@pytest.mark.regression
+class TestExceptionLog:
+    """异常日志测试类"""
+
+    @pytest.mark.asyncio
+    async def test_create_exception_log(self, authenticated_client):
+        """测试创建异常日志"""
+        api = SysLogAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "title": f"测试异常_{timestamp}",
+            "exceptionName": "NullPointerException",
+            "exceptionMsg": "Null pointer at line 100",
+            "methodName": "cn.novalon.manage.sys.service.UserService.getUser",
+            "ip": "127.0.0.1",
+            "exceptionStack": "java.lang.NullPointerException\\n    at..."
+        }
+
+        response = await api.create_exception_log(data)
+
+        assert response.status_code == 201
+        result = response.json()
+        assert result["title"] == data["title"]
+
+    @pytest.mark.asyncio
+    async def test_get_all_exception_logs(self, authenticated_client):
+        """测试获取所有异常日志"""
+        api = SysLogAPI(authenticated_client)
+
+        response = await api.get_exception_logs()
+
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+
+    @pytest.mark.asyncio
+    async def test_get_exception_log_by_id(self, authenticated_client):
+        """测试根据ID获取异常日志"""
+        api = SysLogAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "title": f"测试异常_{timestamp}",
+            "exceptionName": "NullPointerException",
+            "exceptionMsg": "Null pointer"
+        }
+        create_response = await api.create_exception_log(data)
+        log_id = create_response.json()["id"]
+
+        response = await api.get_exception_log_by_id(log_id)
+
+        assert response.status_code == 200
+        assert response.json()["id"] == log_id
+    
+    @pytest.mark.asyncio
+    async def test_get_login_logs_by_page_success(self, authenticated_client):
+        """测试分页获取登录日志成功"""
+        api = SysLogAPI(authenticated_client)
+        
+        for i in range(5):
+            timestamp = int(time.time() * 1000) + i
+            data = {
+                "username": f"testuser_{i}",
+                "ip": f"127.0.0.{i}",
+                "status": "0",
+                "msg": "登录成功"
+            }
+            await api.create_login_log(data)
+        
+        response = await api.get_login_logs_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_login_logs_by_page_with_sort(self, authenticated_client):
+        """测试分页获取登录日志并排序成功"""
+        api = SysLogAPI(authenticated_client)
+        
+        for i in range(3):
+            timestamp = int(time.time() * 1000) + i
+            data = {
+                "username": f"sortuser_{i}",
+                "ip": "127.0.0.1",
+                "status": "0",
+                "msg": "登录成功"
+            }
+            await api.create_login_log(data)
+        
+        response = await api.get_login_logs_by_page(page=0, size=10, sort="username", order="asc")
+        
+        assert response.status_code == 200
+        data = response.json()
+        usernames = [log["username"] for log in data["content"]]
+        assert usernames == sorted(usernames)
+    
+    @pytest.mark.asyncio
+    async def test_get_login_logs_by_page_with_search(self, authenticated_client):
+        """测试分页获取登录日志并搜索成功"""
+        api = SysLogAPI(authenticated_client)
+        
+        timestamp1 = int(time.time() * 1000)
+        data1 = {
+            "username": "search_test_user",
+            "ip": "127.0.0.1",
+            "status": "0",
+            "msg": "登录成功"
+        }
+        await api.create_login_log(data1)
+        
+        timestamp2 = int(time.time() * 1000) + 1
+        data2 = {
+            "username": "other_user",
+            "ip": "127.0.0.2",
+            "status": "0",
+            "msg": "登录成功"
+        }
+        await api.create_login_log(data2)
+        
+        response = await api.get_login_logs_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 log["username"] or "search" in log.get("ip", "") 
+                  for log in data["content"])
+    
+    @pytest.mark.asyncio
+    async def test_get_login_log_count_success(self, authenticated_client):
+        """测试获取登录日志总数成功"""
+        api = SysLogAPI(authenticated_client)
+        
+        initial_count_response = await api.get_login_log_count()
+        initial_count = initial_count_response.json()
+        
+        timestamp = int(time.time() * 1000)
+        data = {
+            "username": f"count_test_user",
+            "ip": "127.0.0.1",
+            "status": "0",
+            "msg": "登录成功"
+        }
+        await api.create_login_log(data)
+        
+        final_count_response = await api.get_login_log_count()
+        final_count = final_count_response.json()
+        
+        assert final_count == initial_count + 1

api_integration_tests/tests/test_auth.py

@@ -0,0 +1,78 @@
+"""
+认证测试用例
+"""
+
+import pytest
+from api.auth_api import AuthAPI
+from config.settings import settings
+
+
+@pytest.mark.auth
+@pytest.mark.smoke
+class TestAuth:
+    """认证测试类"""
+    
+    @pytest.mark.asyncio
+    async def test_login_success(self, http_client):
+        """测试成功登录"""
+        auth_api = AuthAPI(http_client)
+        response = await auth_api.login(settings.TEST_USERNAME, settings.TEST_PASSWORD)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "token" in data
+        assert isinstance(data["token"], str)
+        assert "userId" in data
+        assert "username" in data
+    
+    @pytest.mark.asyncio
+    async def test_login_invalid_credentials(self, http_client):
+        """测试无效凭证登录"""
+        auth_api = AuthAPI(http_client)
+        response = await auth_api.login("invalid_user", "invalid_password")
+        
+        assert response.status_code == 401
+    
+    @pytest.mark.asyncio
+    async def test_login_missing_fields(self, http_client):
+        """测试缺少必填字段"""
+        auth_api = AuthAPI(http_client)
+        response = await http_client.post("/api/auth/login", json={
+            "username": "test"
+        })
+        
+        assert response.status_code == 400
+    
+    @pytest.mark.asyncio
+    async def test_register_success(self, http_client):
+        """测试注册成功"""
+        import time
+        timestamp = int(time.time() * 1000)
+        response = await http_client.post("/api/auth/register", json={
+            "username": f"testuser_{timestamp}",
+            "password": "password123",
+            "email": f"test_{timestamp}@example.com"
+        })
+        
+        assert response.status_code == 201
+        data = response.json()
+        assert "id" in data
+        assert data["username"] == f"testuser_{timestamp}"
+    
+    @pytest.mark.asyncio
+    async def test_register_duplicate_username(self, http_client):
+        """测试注册重复用户名"""
+        response = await http_client.post("/api/auth/register", json={
+            "username": "admin",
+            "password": "password123",
+            "email": "admin@example.com"
+        })
+        
+        assert response.status_code == 500
+    
+    @pytest.mark.asyncio
+    async def test_logout_success(self, http_client):
+        """测试登出成功"""
+        response = await http_client.post("/api/auth/logout")
+        
+        assert response.status_code == 200

api_integration_tests/tests/test_config.py

@@ -0,0 +1,105 @@
+"""
+系统配置测试用例
+"""
+
+import pytest
+import time
+from api.config_api import SysConfigAPI
+
+
+@pytest.mark.config
+@pytest.mark.regression
+class TestSysConfig:
+    """系统参数配置测试类"""
+
+    @pytest.mark.asyncio
+    async def test_create_config_success(self, authenticated_client):
+        """测试创建系统配置成功"""
+        api = SysConfigAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "configName": f"测试配置_{timestamp}",
+            "configKey": f"test.config.key.{timestamp}",
+            "configValue": "test_value",
+            "configType": "N"
+        }
+
+        response = await api.create(data)
+
+        assert response.status_code == 201
+        result = response.json()
+        assert result["configName"] == data["configName"]
+        assert result["configKey"] == data["configKey"]
+
+    @pytest.mark.asyncio
+    async def test_get_all_configs(self, authenticated_client):
+        """测试获取所有配置"""
+        api = SysConfigAPI(authenticated_client)
+
+        response = await api.get_all()
+
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+
+    @pytest.mark.asyncio
+    async def test_get_config_by_key(self, authenticated_client):
+        """测试根据key获取配置"""
+        api = SysConfigAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "configName": f"测试配置_{timestamp}",
+            "configKey": f"test.config.key.{timestamp}",
+            "configValue": "test_value",
+            "configType": "N"
+        }
+        create_response = await api.create(data)
+        config_key = data["configKey"]
+
+        response = await api.get_by_key(config_key)
+
+        assert response.status_code == 200
+        result = response.json()
+        assert result["configKey"] == config_key
+
+    @pytest.mark.asyncio
+    async def test_update_config(self, authenticated_client):
+        """测试更新配置"""
+        api = SysConfigAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "configName": f"测试配置_{timestamp}",
+            "configKey": f"test.config.key.{timestamp}",
+            "configValue": "old_value",
+            "configType": "N"
+        }
+        create_response = await api.create(data)
+        config_id = create_response.json()["id"]
+
+        update_data = {
+            "configName": f"更新后_{timestamp}",
+            "configKey": f"test.config.key.{timestamp}",
+            "configValue": "new_value",
+            "configType": "N"
+        }
+        response = await api.update(config_id, update_data)
+
+        assert response.status_code == 200
+        assert response.json()["configValue"] == "new_value"
+
+    @pytest.mark.asyncio
+    async def test_delete_config(self, authenticated_client):
+        """测试删除配置"""
+        api = SysConfigAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "configName": f"测试配置_{timestamp}",
+            "configKey": f"test.config.key.{timestamp}",
+            "configValue": "test_value",
+            "configType": "N"
+        }
+        create_response = await api.create(data)
+        config_id = create_response.json()["id"]
+
+        response = await api.delete(config_id)
+
+        assert response.status_code == 204

api_integration_tests/tests/test_data_manager_example.py

@@ -0,0 +1,91 @@
+"""
+测试数据管理器使用示例
+"""
+
+import pytest
+import time
+from api.user_api import UserAPI
+from api.role_api import RoleAPI
+
+
+@pytest.mark.example
+@pytest.mark.regression
+class TestDataManagerExample:
+    """测试数据管理器使用示例"""
+    
+    @pytest.mark.asyncio
+    async def test_create_and_cleanup_users(self, authenticated_client, test_data_manager):
+        """演示测试数据管理器的使用"""
+        user_api = UserAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        
+        for i in range(3):
+            user_data = {
+                "username": f"managed_user_{timestamp}_{i}",
+                "password": "Test123!@#",
+                "email": f"managed_{timestamp}_{i}@example.com",
+                "status": 1
+            }
+            
+            response = await user_api.create_user(user_data)
+            assert response.status_code == 201
+            user_id = response.json()["id"]
+            
+            test_data_manager.add_user(user_id)
+        
+        cleanup_count = test_data_manager.get_stats()
+        assert cleanup_count["users"] == 3
+        
+        all_users = await user_api.get_all_users()
+        assert all_users.status_code == 200
+        
+        await test_data_manager.cleanup_all()
+        
+        final_count = test_data_manager.get_stats()
+        assert final_count["users"] == 0
+    
+    @pytest.mark.asyncio
+    async def test_multiple_resources_cleanup(self, authenticated_client, test_data_manager):
+        """演示多资源清理"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        
+        role_data = {
+            "roleName": f"Managed_Role_{timestamp}",
+            "roleKey": f"managed_role_{timestamp}",
+            "roleSort": 1,
+            "status": 1
+        }
+        
+        role_response = await role_api.create_role(role_data)
+        assert role_response.status_code == 201
+        role_id = role_response.json()["id"]
+        test_data_manager.add_role(role_id)
+        
+        for i in range(2):
+            user_data = {
+                "username": f"role_user_{timestamp}_{i}",
+                "password": "Test123!@#",
+                "email": f"role_user_{timestamp}_{i}@example.com",
+                "status": 1
+            }
+            
+            user_response = await user_api.create_user(user_data)
+            assert user_response.status_code == 201
+            user_id = user_response.json()["id"]
+            test_data_manager.add_user(user_id)
+            
+            await user_api.update_user(user_id, {"roleId": role_id})
+        
+        cleanup_count = test_data_manager.get_stats()
+        assert cleanup_count["roles"] == 1
+        assert cleanup_count["users"] == 2
+        
+        await test_data_manager.cleanup_all()
+        
+        final_count = test_data_manager.get_stats()
+        assert final_count["roles"] == 0
+        assert final_count["users"] == 0

api_integration_tests/tests/test_dict.py

@@ -0,0 +1,164 @@
+"""
+字典管理测试用例
+"""
+
+import pytest
+import time
+from api.dict_api import DictTypeAPI, DictDataAPI
+
+
+@pytest.mark.dict
+@pytest.mark.regression
+class TestDictType:
+    """字典类型测试类"""
+
+    @pytest.mark.asyncio
+    async def test_create_dict_type_success(self, authenticated_client):
+        """测试创建字典类型成功"""
+        api = DictTypeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "dictName": f"测试字典_{timestamp}",
+            "dictType": f"test_{timestamp}",
+            "status": "0"
+        }
+
+        response = await api.create(data)
+
+        assert response.status_code == 201
+        result = response.json()
+        assert result["dictName"] == data["dictName"]
+        assert result["dictType"] == data["dictType"]
+
+    @pytest.mark.asyncio
+    async def test_get_all_dict_types(self, authenticated_client):
+        """测试获取所有字典类型"""
+        api = DictTypeAPI(authenticated_client)
+
+        response = await api.get_all()
+
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+
+    @pytest.mark.asyncio
+    async def test_get_dict_type_by_id(self, authenticated_client):
+        """测试根据ID获取字典类型"""
+        api = DictTypeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        create_data = {
+            "dictName": f"测试字典_{timestamp}",
+            "dictType": f"test_{timestamp}",
+            "status": "0"
+        }
+        create_response = await api.create(create_data)
+        dict_id = create_response.json()["id"]
+
+        response = await api.get_by_id(dict_id)
+
+        assert response.status_code == 200
+        assert response.json()["id"] == dict_id
+
+    @pytest.mark.asyncio
+    async def test_update_dict_type(self, authenticated_client):
+        """测试更新字典类型"""
+        api = DictTypeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        create_data = {
+            "dictName": f"测试字典_{timestamp}",
+            "dictType": f"test_{timestamp}",
+            "status": "0"
+        }
+        create_response = await api.create(create_data)
+        dict_id = create_response.json()["id"]
+
+        update_data = {
+            "dictName": f"更新后_{timestamp}",
+            "dictType": f"test_{timestamp}",
+            "status": "0"
+        }
+        response = await api.update(dict_id, update_data)
+
+        assert response.status_code == 200
+        assert response.json()["dictName"] == f"更新后_{timestamp}"
+
+    @pytest.mark.asyncio
+    async def test_delete_dict_type(self, authenticated_client):
+        """测试删除字典类型"""
+        api = DictTypeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        create_data = {
+            "dictName": f"测试字典_{timestamp}",
+            "dictType": f"test_{timestamp}",
+            "status": "0"
+        }
+        create_response = await api.create(create_data)
+        dict_id = create_response.json()["id"]
+
+        response = await api.delete(dict_id)
+
+        assert response.status_code == 204
+
+
+@pytest.mark.dict
+@pytest.mark.regression
+class TestDictData:
+    """字典数据测试类"""
+
+    @pytest.mark.asyncio
+    async def test_create_dict_data_success(self, authenticated_client):
+        """测试创建字典数据成功"""
+        dict_type_api = DictTypeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        dict_type_data = {
+            "dictName": f"测试字典类型_{timestamp}",
+            "dictType": f"test_type_{timestamp}",
+            "status": "0"
+        }
+        dict_type_response = await dict_type_api.create(dict_type_data)
+        dict_type_id = dict_type_response.json()["id"]
+
+        dict_data_api = DictDataAPI(authenticated_client)
+        data = {
+            "dictSort": 1,
+            "dictLabel": f"测试标签_{timestamp}",
+            "dictValue": f"test_value_{timestamp}",
+            "dictType": f"test_type_{timestamp}",
+            "status": "0"
+        }
+
+        response = await dict_data_api.create(data)
+
+        assert response.status_code == 201
+        result = response.json()
+        assert result["dictLabel"] == data["dictLabel"]
+        assert result["dictValue"] == data["dictValue"]
+
+    @pytest.mark.asyncio
+    async def test_get_dict_data_by_type(self, authenticated_client):
+        """测试根据类型获取字典数据"""
+        dict_type_api = DictTypeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        dict_type = f"test_type_{timestamp}"
+        dict_type_data = {
+            "dictName": f"测试字典类型_{timestamp}",
+            "dictType": dict_type,
+            "status": "0"
+        }
+        await dict_type_api.create(dict_type_data)
+
+        dict_data_api = DictDataAPI(authenticated_client)
+        data = {
+            "dictSort": 1,
+            "dictLabel": f"测试标签_{timestamp}",
+            "dictValue": f"test_value_{timestamp}",
+            "dictType": dict_type,
+            "status": "0"
+        }
+        await dict_data_api.create(data)
+
+        response = await dict_data_api.get_by_type(dict_type)
+
+        assert response.status_code == 200
+        result = response.json()
+        assert len(result) > 0
+        assert result[0]["dictType"] == dict_type

api_integration_tests/tests/test_dictionary.py

@@ -0,0 +1,149 @@
+"""
+字典管理测试用例
+"""
+
+import pytest
+from api.dictionary_api import DictionaryAPI
+
+
+@pytest.mark.dictionary
+@pytest.mark.regression
+class TestDictionary:
+    """字典管理测试类"""
+    
+    @pytest.mark.asyncio
+    async def test_create_dictionary_success(self, authenticated_client, test_dictionary_data, cleanup_dictionary):
+        """测试创建字典成功"""
+        dict_api = DictionaryAPI(authenticated_client)
+        response = await dict_api.create_dictionary(test_dictionary_data)
+        
+        assert response.status_code == 201
+        data = response.json()
+        assert "id" in data
+        assert data["type"] == test_dictionary_data["type"]
+        assert data["code"] == test_dictionary_data["code"]
+        assert data["name"] == test_dictionary_data["name"]
+        
+        cleanup_dictionary.append(data["id"])
+    
+    @pytest.mark.asyncio
+    async def test_create_dictionary_duplicate_type_code(self, authenticated_client, test_dictionary_data, cleanup_dictionary):
+        """测试创建重复类型和编码"""
+        dict_api = DictionaryAPI(authenticated_client)
+        
+        create_response = await dict_api.create_dictionary(test_dictionary_data)
+        dict_id = create_response.json()["id"]
+        
+        response = await dict_api.create_dictionary(test_dictionary_data)
+        
+        assert response.status_code in [400, 409]
+        
+        cleanup_dictionary.append(dict_id)
+    
+    @pytest.mark.asyncio
+    async def test_get_dictionary_by_id_success(self, authenticated_client, test_dictionary_data, cleanup_dictionary):
+        """测试根据ID获取字典成功"""
+        dict_api = DictionaryAPI(authenticated_client)
+        
+        create_response = await dict_api.create_dictionary(test_dictionary_data)
+        dict_id = create_response.json()["id"]
+        
+        response = await dict_api.get_dictionary_by_id(dict_id)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == dict_id
+        assert data["type"] == test_dictionary_data["type"]
+        
+        cleanup_dictionary.append(dict_id)
+    
+    @pytest.mark.asyncio
+    async def test_get_dictionary_by_id_not_found(self, authenticated_client):
+        """测试获取不存在的字典"""
+        dict_api = DictionaryAPI(authenticated_client)
+        response = await dict_api.get_dictionary_by_id(999999)
+        
+        assert response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_get_dictionaries_by_type_success(self, authenticated_client, test_dictionary_data, cleanup_dictionary):
+        """测试根据类型获取字典成功"""
+        dict_api = DictionaryAPI(authenticated_client)
+        
+        create_response = await dict_api.create_dictionary(test_dictionary_data)
+        dict_id = create_response.json()["id"]
+        
+        response = await dict_api.get_dictionaries_by_type(test_dictionary_data["type"])
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+        assert any(d["id"] == dict_id for d in data)
+        
+        cleanup_dictionary.append(dict_id)
+    
+    @pytest.mark.asyncio
+    async def test_get_all_dictionaries_success(self, authenticated_client):
+        """测试获取所有字典成功"""
+        dict_api = DictionaryAPI(authenticated_client)
+        response = await dict_api.get_all_dictionaries()
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+    
+    @pytest.mark.asyncio
+    async def test_update_dictionary_success(self, authenticated_client, test_dictionary_data, cleanup_dictionary):
+        """测试更新字典成功"""
+        dict_api = DictionaryAPI(authenticated_client)
+        
+        create_response = await dict_api.create_dictionary(test_dictionary_data)
+        dict_id = create_response.json()["id"]
+        
+        update_data = {"name": "Updated name"}
+        response = await dict_api.update_dictionary(dict_id, update_data)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["name"] == "Updated name"
+        
+        cleanup_dictionary.append(dict_id)
+    
+    @pytest.mark.asyncio
+    async def test_delete_dictionary_success(self, authenticated_client, test_dictionary_data, cleanup_dictionary):
+        """测试删除字典成功"""
+        dict_api = DictionaryAPI(authenticated_client)
+        
+        create_response = await dict_api.create_dictionary(test_dictionary_data)
+        dict_id = create_response.json()["id"]
+        
+        response = await dict_api.delete_dictionary(dict_id)
+        
+        assert response.status_code == 204
+    
+    @pytest.mark.asyncio
+    async def test_check_type_and_code_exists_true(self, authenticated_client, test_dictionary_data, cleanup_dictionary):
+        """测试检查类型和编码存在-返回true"""
+        dict_api = DictionaryAPI(authenticated_client)
+        
+        create_response = await dict_api.create_dictionary(test_dictionary_data)
+        dict_id = create_response.json()["id"]
+        
+        response = await dict_api.check_type_and_code_exists(
+            test_dictionary_data["type"],
+            test_dictionary_data["code"]
+        )
+        
+        assert response.status_code == 200
+        assert response.json() is True
+        
+        cleanup_dictionary.append(dict_id)
+    
+    @pytest.mark.asyncio
+    async def test_check_type_and_code_exists_false(self, authenticated_client):
+        """测试检查类型和编码存在-返回false"""
+        dict_api = DictionaryAPI(authenticated_client)
+        response = await dict_api.check_type_and_code_exists("NONEXISTENT_TYPE", "NONEXISTENT_CODE")
+        
+        assert response.status_code == 200
+        assert response.json() is False

api_integration_tests/tests/test_e2e.py

@@ -0,0 +1,311 @@
+"""
+端到端业务流程测试用例
+"""
+
+import pytest
+import time
+from api.auth_api import AuthAPI
+from api.user_api import UserAPI
+from api.role_api import RoleAPI
+from api.notice_api import SysNoticeAPI
+
+
+@pytest.mark.e2e
+@pytest.mark.regression
+class TestBusinessFlow:
+    """端到端业务流程测试类"""
+    
+    @pytest.mark.asyncio
+    async def test_complete_user_lifecycle(self, authenticated_client):
+        """测试完整用户生命周期"""
+        auth_api = AuthAPI(authenticated_client)
+        user_api = UserAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        
+        new_user_data = {
+            "username": f"e2e_user_{timestamp}",
+            "password": "Test123!@#",
+            "email": f"e2e_{timestamp}@example.com",
+            "phone": "13800138000",
+            "status": 1
+        }
+        
+        create_response = await user_api.create_user(new_user_data)
+        assert create_response.status_code == 201
+        user_id = create_response.json()["id"]
+        
+        get_response = await user_api.get_user_by_id(user_id)
+        assert get_response.status_code == 200
+        user_data = get_response.json()
+        assert user_data["username"] == new_user_data["username"]
+        
+        update_data = {"email": f"updated_{timestamp}@example.com"}
+        update_response = await user_api.update_user(user_id, update_data)
+        assert update_response.status_code == 200
+        
+        delete_response = await user_api.delete_user(user_id)
+        assert delete_response.status_code in [200, 204]
+        
+        final_get_response = await user_api.get_user_by_id(user_id)
+        assert final_get_response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_role_assignment_workflow(self, authenticated_client):
+        """测试角色分配工作流"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        
+        role_data = {
+            "roleName": f"E2E_Role_{timestamp}",
+            "roleKey": f"e2e_role_{timestamp}",
+            "roleSort": 1,
+            "status": 1
+        }
+        
+        role_response = await role_api.create_role(role_data)
+        assert role_response.status_code == 201
+        role_id = role_response.json()["id"]
+        
+        user_data = {
+            "username": f"e2e_user_{timestamp}",
+            "password": "Test123!@#",
+            "email": f"e2e_{timestamp}@example.com",
+            "status": 1
+        }
+        
+        user_response = await user_api.create_user(user_data)
+        assert user_response.status_code == 201
+        user_id = user_response.json()["id"]
+        
+        assign_response = await user_api.update_user(user_id, {"roleId": role_id})
+        assert assign_response.status_code == 200
+        
+        verify_response = await user_api.get_user_by_id(user_id)
+        assert verify_response.json()["roleId"] == role_id
+        
+        await user_api.delete_user(user_id)
+        await role_api.delete_role(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_notification_workflow(self, authenticated_client):
+        """测试通知工作流"""
+        notice_api = SysNoticeAPI(authenticated_client)
+        user_api = UserAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        
+        notice_data = {
+            "noticeTitle": f"E2E_Notice_{timestamp}",
+            "noticeType": "1",
+            "noticeContent": "This is an E2E test notice",
+            "status": "0"
+        }
+        
+        create_response = await notice_api.create(notice_data)
+        assert create_response.status_code == 201
+        notice_data_response = create_response.json()
+        
+        notice_id = notice_data_response.get("id")
+        if not notice_id:
+            notice_title = notice_data_response.get("noticeTitle")
+            all_notices = await notice_api.get_all()
+            notices = all_notices.json()
+            notice = next((n for n in notices if n["noticeTitle"] == notice_title), None)
+            notice_id = notice["id"] if notice else None
+        
+        assert notice_id is not None
+        
+        get_response = await notice_api.get_by_id(notice_id)
+        assert get_response.status_code == 200
+        
+        all_notices = await notice_api.get_all()
+        assert all_notices.status_code == 200
+        notices = all_notices.json()
+        assert any(notice["id"] == notice_id for notice in notices)
+        
+        update_data = {"noticeTitle": f"Updated_Notice_{timestamp}"}
+        update_response = await notice_api.update(notice_id, update_data)
+        assert update_response.status_code == 200
+        
+        await notice_api.delete(notice_id)
+        
+        final_get = await notice_api.get_by_id(notice_id)
+        assert final_get.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_multi_role_user_management(self, authenticated_client):
+        """测试多角色用户管理"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        
+        admin_role_data = {
+            "roleName": f"Admin_{timestamp}",
+            "roleKey": f"admin_{timestamp}",
+            "roleSort": 1,
+            "status": 1
+        }
+        admin_role = await role_api.create_role(admin_role_data)
+        admin_role_id = admin_role.json()["id"]
+        
+        user_role_data = {
+            "roleName": f"User_{timestamp}",
+            "roleKey": f"user_{timestamp}",
+            "roleSort": 2,
+            "status": 1
+        }
+        user_role = await role_api.create_role(user_role_data)
+        user_role_id = user_role.json()["id"]
+        
+        admin_user_data = {
+            "username": f"admin_{timestamp}",
+            "password": "Admin123!@#",
+            "email": f"admin_{timestamp}@example.com",
+            "status": 1
+        }
+        admin_user = await user_api.create_user(admin_user_data)
+        admin_user_id = admin_user.json()["id"]
+        
+        regular_user_data = {
+            "username": f"regular_{timestamp}",
+            "password": "User123!@#",
+            "email": f"regular_{timestamp}@example.com",
+            "status": 1
+        }
+        regular_user = await user_api.create_user(regular_user_data)
+        regular_user_id = regular_user.json()["id"]
+        
+        await user_api.update_user(admin_user_id, {"roleId": admin_role_id})
+        await user_api.update_user(regular_user_id, {"roleId": user_role_id})
+        
+        admin_verify = await user_api.get_user_by_id(admin_user_id)
+        assert admin_verify.json()["roleId"] == admin_role_id
+        
+        regular_verify = await user_api.get_user_by_id(regular_user_id)
+        assert regular_verify.json()["roleId"] == user_role_id
+        
+        all_users = await user_api.get_all_users()
+        users = all_users.json()
+        assert len(users) >= 2
+        
+        await user_api.delete_user(admin_user_id)
+        await user_api.delete_user(regular_user_id)
+        await role_api.delete_role(admin_role_id)
+        await role_api.delete_role(user_role_id)
+    
+    @pytest.mark.asyncio
+    async def test_user_role_cascade_operations(self, authenticated_client):
+        """测试用户角色级联操作"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        
+        role_data = {
+            "roleName": f"Cascade_Role_{timestamp}",
+            "roleKey": f"cascade_role_{timestamp}",
+            "roleSort": 1,
+            "status": 1
+        }
+        role_response = await role_api.create_role(role_data)
+        role_id = role_response.json()["id"]
+        
+        user_ids = []
+        for i in range(3):
+            user_data = {
+                "username": f"cascade_user_{timestamp}_{i}",
+                "password": "Test123!@#",
+                "email": f"cascade_{timestamp}_{i}@example.com",
+                "status": 1
+            }
+            user_response = await user_api.create_user(user_data)
+            user_id = user_response.json()["id"]
+            user_ids.append(user_id)
+            await user_api.update_user(user_id, {"roleId": role_id})
+        
+        await role_api.update_role(role_id, {"status": 0})
+        
+        for user_id in user_ids:
+            user_data = await user_api.get_user_by_id(user_id)
+            assert user_data.json()["roleId"] == role_id
+        
+        for user_id in user_ids:
+            await user_api.delete_user(user_id)
+        await role_api.delete_role(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_search_and_filter_workflow(self, authenticated_client):
+        """测试搜索和过滤工作流"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        
+        role_data = {
+            "roleName": f"Search_Role_{timestamp}",
+            "roleKey": f"search_role_{timestamp}",
+            "roleSort": 1,
+            "status": 1
+        }
+        role_response = await role_api.create_role(role_data)
+        role_id = role_response.json()["id"]
+        
+        user_ids = []
+        for i in range(5):
+            user_data = {
+                "username": f"search_{timestamp}_{i}",
+                "password": "Test123!@#",
+                "email": f"search_{timestamp}_{i}@example.com",
+                "status": 1
+            }
+            user_response = await user_api.create_user(user_data)
+            user_id = user_response.json()["id"]
+            user_ids.append(user_id)
+        
+        search_response = await user_api.get_users_by_page(keyword=f"search_{timestamp}")
+        assert search_response.status_code == 200
+        search_data = search_response.json()
+        assert len(search_data["content"]) >= 5
+        
+        all_users = await user_api.get_all_users()
+        assert all_users.status_code == 200
+        
+        for user_id in user_ids:
+            await user_api.delete_user(user_id)
+        await role_api.delete_role(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_error_recovery_workflow(self, authenticated_client):
+        """测试错误恢复工作流"""
+        user_api = UserAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        
+        invalid_user_data = {
+            "username": "",
+            "password": "123",
+            "email": "invalid-email"
+        }
+        
+        invalid_response = await user_api.create_user(invalid_user_data)
+        assert invalid_response.status_code in [400, 409, 422]
+        
+        valid_user_data = {
+            "username": f"recovery_{timestamp}",
+            "password": "Valid123!@#",
+            "email": f"recovery_{timestamp}@example.com",
+            "status": 1
+        }
+        
+        valid_response = await user_api.create_user(valid_user_data)
+        assert valid_response.status_code == 201
+        user_id = valid_response.json()["id"]
+        
+        get_response = await user_api.get_user_by_id(user_id)
+        assert get_response.status_code == 200
+        
+        await user_api.delete_user(user_id)

api_integration_tests/tests/test_exception_scenarios.py

@@ -0,0 +1,331 @@
+"""
+异常场景测试用例
+"""
+
+import pytest
+import time
+from api.user_api import UserAPI
+from api.role_api import RoleAPI
+from api.notice_api import SysNoticeAPI
+
+
+@pytest.mark.exception
+@pytest.mark.regression
+class TestExceptionScenarios:
+    """异常场景测试类"""
+    
+    @pytest.mark.asyncio
+    async def test_create_user_with_duplicate_username(self, authenticated_client, test_user_data, cleanup_user):
+        """测试创建重复用户名的用户"""
+        user_api = UserAPI(authenticated_client)
+        
+        create_response = await user_api.create_user(test_user_data)
+        assert create_response.status_code == 201
+        user_id = create_response.json()["id"]
+        cleanup_user.append(user_id)
+        
+        duplicate_response = await user_api.create_user(test_user_data)
+        assert duplicate_response.status_code in [400, 409]
+    
+    @pytest.mark.asyncio
+    async def test_create_user_with_invalid_email(self, authenticated_client):
+        """测试创建邮箱格式无效的用户"""
+        user_api = UserAPI(authenticated_client)
+        
+        invalid_emails = [
+            "invalid-email",
+            "@example.com",
+            "user@",
+            "user@domain",
+            "user name@example.com"
+        ]
+        
+        for invalid_email in invalid_emails:
+            timestamp = int(time.time() * 1000)
+            user_data = {
+                "username": f"test_{timestamp}",
+                "password": "Test123!@#",
+                "email": invalid_email,
+                "status": 1
+            }
+            
+            response = await user_api.create_user(user_data)
+            assert response.status_code in [400, 422]
+    
+    @pytest.mark.asyncio
+    async def test_create_user_with_weak_password(self, authenticated_client):
+        """测试创建弱密码用户"""
+        user_api = UserAPI(authenticated_client)
+        
+        weak_passwords = [
+            "123456",
+            "password",
+            "qwerty",
+            "111111",
+            "abc123"
+        ]
+        
+        for weak_password in weak_passwords:
+            timestamp = int(time.time() * 1000)
+            user_data = {
+                "username": f"test_{timestamp}",
+                "password": weak_password,
+                "email": f"test_{timestamp}@example.com",
+                "status": 1
+            }
+            
+            response = await user_api.create_user(user_data)
+            assert response.status_code in [400, 422]
+    
+    @pytest.mark.asyncio
+    async def test_create_user_with_missing_fields(self, authenticated_client):
+        """测试创建缺少必填字段的用户"""
+        user_api = UserAPI(authenticated_client)
+        
+        missing_field_scenarios = [
+            {"password": "Test123!@#", "email": "test@example.com"},
+            {"username": "testuser", "email": "test@example.com"},
+            {"username": "testuser", "password": "Test123!@#"}
+        ]
+        
+        for scenario in missing_field_scenarios:
+            response = await user_api.create_user(scenario)
+            assert response.status_code in [400, 422]
+    
+    @pytest.mark.asyncio
+    async def test_update_nonexistent_user(self, authenticated_client):
+        """测试更新不存在的用户"""
+        user_api = UserAPI(authenticated_client)
+        
+        update_data = {"email": "updated@example.com"}
+        response = await user_api.update_user(999999, update_data)
+        assert response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_delete_nonexistent_user(self, authenticated_client):
+        """测试删除不存在的用户"""
+        user_api = UserAPI(authenticated_client)
+        
+        response = await user_api.delete_user(999999)
+        assert response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_create_role_with_duplicate_key(self, authenticated_client, test_role_data, cleanup_role):
+        """测试创建重复角色键的角色"""
+        role_api = RoleAPI(authenticated_client)
+        
+        create_response = await role_api.create_role(test_role_data)
+        assert create_response.status_code == 201
+        role_id = create_response.json()["id"]
+        cleanup_role.append(role_id)
+        
+        duplicate_response = await role_api.create_role(test_role_data)
+        assert duplicate_response.status_code in [400, 409]
+    
+    @pytest.mark.asyncio
+    async def test_create_role_with_invalid_status(self, authenticated_client):
+        """测试创建状态无效的角色"""
+        role_api = RoleAPI(authenticated_client)
+        
+        invalid_statuses = ["2", "3", "invalid", "true", "false"]
+        
+        for invalid_status in invalid_statuses:
+            timestamp = int(time.time() * 1000)
+            role_data = {
+                "roleName": f"TestRole_{timestamp}",
+                "roleKey": f"test_role_{timestamp}",
+                "roleSort": 1,
+                "status": invalid_status
+            }
+            
+            response = await role_api.create_role(role_data)
+            assert response.status_code in [400, 422]
+    
+    @pytest.mark.asyncio
+    async def test_update_nonexistent_role(self, authenticated_client):
+        """测试更新不存在的角色"""
+        role_api = RoleAPI(authenticated_client)
+        
+        update_data = {"roleName": "Updated Role"}
+        response = await role_api.update_role(999999, update_data)
+        assert response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_create_notice_with_invalid_type(self, authenticated_client):
+        """测试创建类型无效的公告"""
+        notice_api = SysNoticeAPI(authenticated_client)
+        
+        invalid_types = ["3", "4", "invalid", "true", "false"]
+        
+        for invalid_type in invalid_types:
+            timestamp = int(time.time() * 1000)
+            notice_data = {
+                "noticeTitle": f"TestNotice_{timestamp}",
+                "noticeType": invalid_type,
+                "noticeContent": "Test content",
+                "status": "0"
+            }
+            
+            response = await notice_api.create(notice_data)
+            assert response.status_code in [400, 422]
+    
+    @pytest.mark.asyncio
+    async def test_create_notice_with_empty_content(self, authenticated_client):
+        """测试创建内容为空的公告"""
+        notice_api = SysNoticeAPI(authenticated_client)
+        
+        empty_content_scenarios = [
+            {"noticeTitle": "Test", "noticeType": "1", "noticeContent": "", "status": "0"},
+            {"noticeTitle": "", "noticeType": "1", "noticeContent": "Test", "status": "0"},
+            {"noticeTitle": "Test", "noticeType": "1", "noticeContent": "   ", "status": "0"}
+        ]
+        
+        for scenario in empty_content_scenarios:
+            response = await notice_api.create(scenario)
+            assert response.status_code in [400, 422]
+    
+    @pytest.mark.asyncio
+    async def test_update_nonexistent_notice(self, authenticated_client):
+        """测试更新不存在的公告"""
+        notice_api = SysNoticeAPI(authenticated_client)
+        
+        update_data = {"noticeTitle": "Updated Notice"}
+        response = await notice_api.update(999999, update_data)
+        assert response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_delete_nonexistent_notice(self, authenticated_client):
+        """测试删除不存在的公告"""
+        notice_api = SysNoticeAPI(authenticated_client)
+        
+        response = await notice_api.delete(999999)
+        assert response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_get_user_with_invalid_id(self, authenticated_client):
+        """测试获取ID无效的用户"""
+        user_api = UserAPI(authenticated_client)
+        
+        invalid_ids = [-1, 0, "abc", "1.5", "999999999999"]
+        
+        for invalid_id in invalid_ids:
+            try:
+                response = await user_api.get_user_by_id(int(invalid_id) if isinstance(invalid_id, (int, str)) else invalid_id)
+                assert response.status_code in [400, 404]
+            except (ValueError, TypeError):
+                pass
+    
+    @pytest.mark.asyncio
+    async def test_pagination_with_invalid_params(self, authenticated_client):
+        """测试分页参数无效的查询"""
+        user_api = UserAPI(authenticated_client)
+        
+        invalid_params = [
+            {"page": -1, "size": 10},
+            {"page": 0, "size": -1},
+            {"page": 0, "size": 0},
+            {"page": 0, "size": 10000},
+            {"page": "abc", "size": 10},
+            {"page": 0, "size": "abc"}
+        ]
+        
+        for params in invalid_params:
+            try:
+                response = await user_api.get_users_by_page(**params)
+                assert response.status_code in [400, 422]
+            except Exception:
+                pass
+    
+    @pytest.mark.asyncio
+    async def test_search_with_special_characters(self, authenticated_client):
+        """测试搜索特殊字符"""
+        user_api = UserAPI(authenticated_client)
+        
+        special_chars = [
+            "<script>alert('xss')</script>",
+            "'; DROP TABLE users; --",
+            "../../../etc/passwd",
+            "{{7*7}}",
+            "%00%00%00%00"
+        ]
+        
+        for search_term in special_chars:
+            response = await user_api.get_users_by_page(keyword=search_term)
+            assert response.status_code in [200, 400]
+            
+            if response.status_code == 200:
+                data = response.json()
+                assert "content" in data
+                for user in data["content"]:
+                    assert search_term.lower() not in str(user).lower()
+    
+    @pytest.mark.asyncio
+    async def test_concurrent_same_resource_update(self, authenticated_client, test_user_data, cleanup_user):
+        """测试并发更新同一资源"""
+        user_api = UserAPI(authenticated_client)
+        
+        create_response = await user_api.create_user(test_user_data)
+        assert create_response.status_code == 201
+        user_id = create_response.json()["id"]
+        cleanup_user.append(user_id)
+        
+        import asyncio
+        update_tasks = [
+            user_api.update_user(user_id, {"email": f"concurrent1_{time.time()}@example.com"}),
+            user_api.update_user(user_id, {"email": f"concurrent2_{time.time()}@example.com"}),
+            user_api.update_user(user_id, {"email": f"concurrent3_{time.time()}@example.com"})
+        ]
+        
+        results = await asyncio.gather(*update_tasks, return_exceptions=True)
+        
+        successful_updates = sum(1 for r in results if r.status_code == 200)
+        assert successful_updates >= 1, "至少应该有一个更新成功"
+    
+    @pytest.mark.asyncio
+    async def test_large_payload_handling(self, authenticated_client):
+        """测试大数据负载处理"""
+        user_api = UserAPI(authenticated_client)
+        
+        large_content = "x" * 10000
+        user_data = {
+            "username": f"large_payload_{int(time.time() * 1000)}",
+            "password": "Test123!@#",
+            "email": f"large_{int(time.time() * 1000)}@example.com",
+            "phone": large_content
+        }
+        
+        response = await user_api.create_user(user_data)
+        assert response.status_code in [201, 400, 413]
+        
+        if response.status_code in [400, 413]:
+            logger.info("系统正确拒绝了过大的负载")
+    
+    @pytest.mark.asyncio
+    async def test_unauthorized_access(self, http_client):
+        """测试未授权访问"""
+        user_api = UserAPI(http_client)
+        
+        response = await user_api.get_all_users()
+        assert response.status_code == 401
+    
+    @pytest.mark.asyncio
+    async def test_rate_limiting(self, authenticated_client):
+        """测试速率限制"""
+        user_api = UserAPI(authenticated_client)
+        
+        requests_made = 0
+        rate_limit_hit = False
+        
+        for i in range(100):
+            response = await user_api.get_all_users()
+            requests_made += 1
+            
+            if response.status_code == 429:
+                rate_limit_hit = True
+                logger.info(f"速率限制在第 {requests_made} 个请求时触发")
+                break
+        
+        if rate_limit_hit:
+            logger.info("系统正确实施了速率限制")
+        else:
+            logger.info("未触发速率限制（可能未配置或阈值较高）")

api_integration_tests/tests/test_file.py

@@ -0,0 +1,114 @@
+"""
+文件管理测试用例
+"""
+
+import pytest
+import os
+import time
+from api.file_api import SysFileAPI
+
+
+@pytest.mark.file
+@pytest.mark.regression
+class TestSysFile:
+    """文件管理测试类"""
+
+    @pytest.mark.asyncio
+    async def test_upload_file(self, authenticated_client):
+        """测试文件上传"""
+        api = SysFileAPI(authenticated_client)
+        test_file_path = "/tmp/test_file.txt"
+
+        with open(test_file_path, "w") as f:
+            f.write("This is a test file content")
+
+        response = await api.upload(test_file_path, "test_user")
+
+        os.remove(test_file_path)
+
+        assert response.status_code == 201
+        result = response.json()
+        assert "id" in result
+
+    @pytest.mark.asyncio
+    async def test_get_all_files(self, authenticated_client):
+        """测试获取所有文件"""
+        api = SysFileAPI(authenticated_client)
+
+        response = await api.get_all()
+
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+
+    @pytest.mark.asyncio
+    async def test_get_file_by_id(self, authenticated_client):
+        """测试根据ID获取文件"""
+        api = SysFileAPI(authenticated_client)
+        test_file_path = "/tmp/test_file.txt"
+
+        with open(test_file_path, "w") as f:
+            f.write("Test content")
+
+        upload_response = await api.upload(test_file_path, "test_user")
+        file_id = upload_response.json()["id"]
+
+        os.remove(test_file_path)
+
+        response = await api.get_by_id(file_id)
+
+        assert response.status_code == 200
+        assert response.json()["id"] == file_id
+
+    @pytest.mark.asyncio
+    async def test_download_file(self, authenticated_client):
+        """测试文件下载"""
+        api = SysFileAPI(authenticated_client)
+        test_file_path = "/tmp/test_file.txt"
+
+        with open(test_file_path, "w") as f:
+            f.write("Download test content")
+
+        upload_response = await api.upload(test_file_path, "test_user")
+        file_name = upload_response.json()["filePath"].split("/")[-1]
+
+        os.remove(test_file_path)
+
+        response = await api.download(file_name)
+
+        assert response.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_preview_file(self, authenticated_client):
+        """测试文件预览"""
+        api = SysFileAPI(authenticated_client)
+        test_file_path = "/tmp/test_file.txt"
+
+        with open(test_file_path, "w") as f:
+            f.write("Preview test content")
+
+        upload_response = await api.upload(test_file_path, "test_user")
+        file_name = upload_response.json()["filePath"].split("/")[-1]
+
+        os.remove(test_file_path)
+
+        response = await api.preview(file_name)
+
+        assert response.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_delete_file(self, authenticated_client):
+        """测试删除文件"""
+        api = SysFileAPI(authenticated_client)
+        test_file_path = "/tmp/test_file.txt"
+
+        with open(test_file_path, "w") as f:
+            f.write("Delete test content")
+
+        upload_response = await api.upload(test_file_path, "test_user")
+        file_id = upload_response.json()["id"]
+
+        os.remove(test_file_path)
+
+        response = await api.delete(file_id)
+
+        assert response.status_code == 204

api_integration_tests/tests/test_menu.py

@@ -0,0 +1,242 @@
+"""
+菜单管理测试用例
+"""
+
+import pytest
+import time
+from api.menu_api import MenuAPI
+
+
+@pytest.mark.menu
+@pytest.mark.regression
+class TestMenu:
+    """菜单管理测试类"""
+    
+    @pytest.fixture
+    def test_menu_data(self):
+        """测试菜单数据"""
+        timestamp = int(time.time() * 1000)
+        return {
+            "menuName": f"测试菜单_{timestamp}",
+            "parentId": 0,
+            "orderNum": 1,
+            "menuType": "C",
+            "perms": f"system:menu:{timestamp}",
+            "component": f"menu/component/{timestamp}",
+            "status": "0"
+        }
+    
+    @pytest.fixture
+    async def cleanup_menu(self, authenticated_client):
+        """清理测试菜单"""
+        menu_ids = []
+        
+        yield menu_ids
+        
+        for menu_id in menu_ids:
+            try:
+                await authenticated_client.delete(f"/api/menus/{menu_id}")
+            except Exception:
+                pass
+    
+    @pytest.mark.asyncio
+    async def test_create_menu_success(self, authenticated_client, test_menu_data, cleanup_menu):
+        """测试创建菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        response = await menu_api.create_menu(test_menu_data)
+        
+        assert response.status_code == 201
+        data = response.json()
+        assert "id" in data
+        assert data["menuName"] == test_menu_data["menuName"]
+        assert data["parentId"] == test_menu_data["parentId"]
+        assert data["menuType"] == test_menu_data["menuType"]
+        
+        cleanup_menu.append(data["id"])
+    
+    @pytest.mark.asyncio
+    async def test_get_menu_by_id_success(self, authenticated_client, test_menu_data, cleanup_menu):
+        """测试根据ID获取菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        
+        create_response = await menu_api.create_menu(test_menu_data)
+        menu_id = create_response.json()["id"]
+        
+        response = await menu_api.get_menu_by_id(menu_id)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == menu_id
+        assert data["menuName"] == test_menu_data["menuName"]
+        
+        cleanup_menu.append(menu_id)
+    
+    @pytest.mark.asyncio
+    async def test_get_menu_by_id_not_found(self, authenticated_client):
+        """测试获取不存在的菜单"""
+        menu_api = MenuAPI(authenticated_client)
+        response = await menu_api.get_menu_by_id(999999)
+        
+        assert response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_get_all_menus_success(self, authenticated_client):
+        """测试获取所有菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        response = await menu_api.get_all_menus()
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+    
+    @pytest.mark.asyncio
+    async def test_get_menu_tree_success(self, authenticated_client):
+        """测试获取菜单树成功"""
+        menu_api = MenuAPI(authenticated_client)
+        response = await menu_api.get_menu_tree()
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+    
+    @pytest.mark.asyncio
+    async def test_update_menu_success(self, authenticated_client, test_menu_data, cleanup_menu):
+        """测试更新菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        
+        create_response = await menu_api.create_menu(test_menu_data)
+        menu_id = create_response.json()["id"]
+        
+        timestamp = int(time.time() * 1000)
+        update_data = {
+            "menuName": f"更新后菜单_{timestamp}",
+            "orderNum": 2
+        }
+        response = await menu_api.update_menu(menu_id, update_data)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["menuName"] == f"更新后菜单_{timestamp}"
+        assert data["orderNum"] == 2
+        
+        cleanup_menu.append(menu_id)
+    
+    @pytest.mark.asyncio
+    async def test_delete_menu_success(self, authenticated_client, test_menu_data, cleanup_menu):
+        """测试删除菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        
+        create_response = await menu_api.create_menu(test_menu_data)
+        menu_id = create_response.json()["id"]
+        
+        response = await menu_api.delete_menu(menu_id)
+        
+        assert response.status_code == 204
+    
+    @pytest.mark.asyncio
+    async def test_get_menus_by_parent_success(self, authenticated_client, test_menu_data, cleanup_menu):
+        """测试根据父菜单ID获取子菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        
+        parent_response = await menu_api.create_menu(test_menu_data)
+        parent_id = parent_response.json()["id"]
+        
+        timestamp = int(time.time() * 1000)
+        child_menu_data = test_menu_data.copy()
+        child_menu_data["menuName"] = f"子菜单_{timestamp}"
+        child_menu_data["parentId"] = parent_id
+        
+        child_response = await menu_api.create_menu(child_menu_data)
+        child_id = child_response.json()["id"]
+        
+        response = await menu_api.get_menus_by_parent(parent_id)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+        assert any(menu["id"] == child_id for menu in data)
+        
+        cleanup_menu.extend([parent_id, child_id])
+    
+    @pytest.mark.asyncio
+    async def test_get_menus_by_type_success(self, authenticated_client, test_menu_data, cleanup_menu):
+        """测试根据菜单类型获取菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        
+        create_response = await menu_api.create_menu(test_menu_data)
+        menu_id = create_response.json()["id"]
+        
+        response = await menu_api.get_menus_by_type("C")
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+        assert any(menu["id"] == menu_id for menu in data)
+        
+        cleanup_menu.append(menu_id)
+    
+    @pytest.mark.asyncio
+    async def test_create_menu_with_parent_success(self, authenticated_client, test_menu_data, cleanup_menu):
+        """测试创建带父菜单的子菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        
+        parent_response = await menu_api.create_menu(test_menu_data)
+        parent_id = parent_response.json()["id"]
+        
+        timestamp = int(time.time() * 1000)
+        child_menu_data = test_menu_data.copy()
+        child_menu_data["menuName"] = f"子菜单_{timestamp}"
+        child_menu_data["parentId"] = parent_id
+        
+        response = await menu_api.create_menu(child_menu_data)
+        
+        assert response.status_code == 201
+        data = response.json()
+        assert data["parentId"] == parent_id
+        
+        cleanup_menu.extend([parent_id, data["id"]])
+    
+    @pytest.mark.asyncio
+    async def test_create_menu_directory_type_success(self, authenticated_client, cleanup_menu):
+        """测试创建目录类型菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        
+        menu_data = {
+            "menuName": f"目录_{timestamp}",
+            "parentId": 0,
+            "orderNum": 1,
+            "menuType": "M",
+            "status": "0"
+        }
+        
+        response = await menu_api.create_menu(menu_data)
+        
+        assert response.status_code == 201
+        data = response.json()
+        assert data["menuType"] == "M"
+        
+        cleanup_menu.append(data["id"])
+    
+    @pytest.mark.asyncio
+    async def test_create_menu_button_type_success(self, authenticated_client, cleanup_menu):
+        """测试创建按钮类型菜单成功"""
+        menu_api = MenuAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        
+        menu_data = {
+            "menuName": f"按钮_{timestamp}",
+            "parentId": 1,
+            "orderNum": 1,
+            "menuType": "F",
+            "perms": f"system:button:{timestamp}",
+            "status": "0"
+        }
+        
+        response = await menu_api.create_menu(menu_data)
+        
+        assert response.status_code == 201
+        data = response.json()
+        assert data["menuType"] == "F"
+        
+        cleanup_menu.append(data["id"])

api_integration_tests/tests/test_notice.py

@@ -0,0 +1,184 @@
+"""
+通知公告测试用例
+"""
+
+import pytest
+import time
+from api.notice_api import SysNoticeAPI, SysMessageAPI
+
+
+@pytest.mark.notice
+@pytest.mark.regression
+class TestSysNotice:
+    """系统公告测试类"""
+
+    @pytest.mark.asyncio
+    async def test_create_notice_success(self, authenticated_client):
+        """测试创建公告成功"""
+        api = SysNoticeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "noticeTitle": f"测试公告_{timestamp}",
+            "noticeType": "1",
+            "noticeContent": "这是测试公告内容",
+            "status": "0"
+        }
+
+        response = await api.create(data)
+
+        assert response.status_code == 201
+        result = response.json()
+        assert result["noticeTitle"] == data["noticeTitle"]
+
+    @pytest.mark.asyncio
+    async def test_get_all_notices(self, authenticated_client):
+        """测试获取所有公告"""
+        api = SysNoticeAPI(authenticated_client)
+
+        response = await api.get_all()
+
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+
+    @pytest.mark.asyncio
+    async def test_get_notice_by_id(self, authenticated_client):
+        """测试根据ID获取公告"""
+        api = SysNoticeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "noticeTitle": f"测试公告_{timestamp}",
+            "noticeType": "1",
+            "noticeContent": "测试内容",
+            "status": "0"
+        }
+        create_response = await api.create(data)
+        notice_id = create_response.json()["id"]
+
+        response = await api.get_by_id(notice_id)
+
+        assert response.status_code == 200
+        assert response.json()["id"] == notice_id
+
+    @pytest.mark.asyncio
+    async def test_get_notice_by_status(self, authenticated_client):
+        """测试根据状态获取公告"""
+        api = SysNoticeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "noticeTitle": f"测试公告_{timestamp}",
+            "noticeType": "1",
+            "noticeContent": "测试内容",
+            "status": "0"
+        }
+        await api.create(data)
+
+        response = await api.get_by_status("0")
+
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+
+    @pytest.mark.asyncio
+    async def test_update_notice(self, authenticated_client):
+        """测试更新公告"""
+        api = SysNoticeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "noticeTitle": f"测试公告_{timestamp}",
+            "noticeType": "1",
+            "noticeContent": "原始内容",
+            "status": "0"
+        }
+        create_response = await api.create(data)
+        notice_id = create_response.json()["id"]
+
+        update_data = {
+            "noticeTitle": f"更新后_{timestamp}",
+            "noticeType": "1",
+            "noticeContent": "更新后内容",
+            "status": "0"
+        }
+        response = await api.update(notice_id, update_data)
+
+        assert response.status_code == 200
+        assert response.json()["noticeTitle"] == f"更新后_{timestamp}"
+
+    @pytest.mark.asyncio
+    async def test_delete_notice(self, authenticated_client):
+        """测试删除公告"""
+        api = SysNoticeAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "noticeTitle": f"测试公告_{timestamp}",
+            "noticeType": "1",
+            "noticeContent": "测试内容",
+            "status": "0"
+        }
+        create_response = await api.create(data)
+        notice_id = create_response.json()["id"]
+
+        response = await api.delete(notice_id)
+
+        assert response.status_code == 204
+
+
+@pytest.mark.notice
+@pytest.mark.regression
+class TestSysMessage:
+    """用户消息测试类"""
+
+    @pytest.mark.asyncio
+    async def test_create_message(self, authenticated_client):
+        """测试创建消息"""
+        api = SysMessageAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "userId": 1,
+            "title": f"测试消息_{timestamp}",
+            "content": "这是测试消息内容",
+            "type": "1"
+        }
+
+        response = await api.create(data)
+
+        assert response.status_code == 201
+        result = response.json()
+        assert result["title"] == data["title"]
+
+    @pytest.mark.asyncio
+    async def test_get_messages_by_user(self, authenticated_client):
+        """测试获取用户消息"""
+        api = SysMessageAPI(authenticated_client)
+        user_id = 1
+
+        response = await api.get_by_user(user_id)
+
+        assert response.status_code == 200
+        assert isinstance(response.json(), list)
+
+    @pytest.mark.asyncio
+    async def test_get_unread_count(self, authenticated_client):
+        """测试获取未读消息数量"""
+        api = SysMessageAPI(authenticated_client)
+        user_id = 1
+
+        response = await api.get_unread_count(user_id)
+
+        assert response.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_mark_message_as_read(self, authenticated_client):
+        """测试标记消息为已读"""
+        api = SysMessageAPI(authenticated_client)
+        timestamp = int(time.time() * 1000)
+        data = {
+            "userId": 1,
+            "title": f"测试消息_{timestamp}",
+            "content": "测试内容",
+            "type": "1"
+        }
+        create_response = await api.create(data)
+        message_id = create_response.json()["id"]
+
+        response = await api.mark_as_read(message_id)
+
+        assert response.status_code == 200

api_integration_tests/tests/test_performance.py

@@ -0,0 +1,200 @@
+"""
+性能测试基础框架
+"""
+
+import pytest
+import time
+import asyncio
+import statistics
+from typing import List, Dict, Any
+from httpx import AsyncClient
+from loguru import logger
+
+
+@pytest.mark.performance
+@pytest.mark.slow
+class PerformanceTest:
+    """性能测试基类"""
+    
+    @pytest.fixture
+    async def perf_client(self, authenticated_client: AsyncClient) -> AsyncClient:
+        """性能测试客户端"""
+        return authenticated_client
+    
+    @pytest.fixture
+    def performance_thresholds(self):
+        """性能阈值配置"""
+        return {
+            "response_time_p95": 2000,  # 95%的请求响应时间应小于2秒
+            "response_time_p99": 5000,  # 99%的请求响应时间应小于5秒
+            "error_rate": 0.05,  # 错误率应小于5%
+            "throughput_min": 10,  # 最小吞吐量（请求/秒）
+        }
+    
+    async def measure_request_time(self, client: AsyncClient, method: str, 
+                              url: str, **kwargs) -> float:
+        """测量单个请求时间"""
+        start_time = time.time()
+        
+        if method.upper() == "GET":
+            response = await client.get(url, **kwargs)
+        elif method.upper() == "POST":
+            response = await client.post(url, **kwargs)
+        elif method.upper() == "PUT":
+            response = await client.put(url, **kwargs)
+        elif method.upper() == "DELETE":
+            response = await client.delete(url, **kwargs)
+        else:
+            raise ValueError(f"Unsupported method: {method}")
+        
+        end_time = time.time()
+        response_time = (end_time - start_time) * 1000  # 转换为毫秒
+        
+        return response_time
+    
+    async def measure_concurrent_requests(self, client: AsyncClient, method: str,
+                                      url: str, concurrency: int = 10,
+                                      **kwargs) -> Dict[str, Any]:
+        """测量并发请求性能"""
+        async def make_request():
+            return await self.measure_request_time(client, method, url, **kwargs)
+        
+        start_time = time.time()
+        results = await asyncio.gather(*[make_request() for _ in range(concurrency)])
+        end_time = time.time()
+        
+        total_time = (end_time - start_time) * 1000  # 毫秒
+        response_times = results
+        
+        return {
+            "concurrency": concurrency,
+            "total_time_ms": total_time,
+            "response_times_ms": response_times,
+            "min_time_ms": min(response_times),
+            "max_time_ms": max(response_times),
+            "avg_time_ms": statistics.mean(response_times),
+            "median_time_ms": statistics.median(response_times),
+            "p95_time_ms": self._percentile(response_times, 95),
+            "p99_time_ms": self._percentile(response_times, 99),
+            "throughput_rps": concurrency / (total_time / 1000),
+            "success_count": len(response_times),
+        }
+    
+    def _percentile(self, data: List[float], percentile: float) -> float:
+        """计算百分位数"""
+        sorted_data = sorted(data)
+        index = int(len(sorted_data) * percentile / 100)
+        return sorted_data[min(index, len(sorted_data) - 1)]
+    
+    def assert_performance(self, results: Dict[str, Any], thresholds: Dict[str, Any]):
+        """断言性能指标"""
+        p95_time = results["p95_time_ms"]
+        p99_time = results["p99_time_ms"]
+        throughput = results["throughput_rps"]
+        
+        if p95_time > thresholds["response_time_p95"]:
+            pytest.fail(f"P95响应时间 {p95_time:.2f}ms 超过阈值 {thresholds['response_time_p95']}ms")
+        
+        if p99_time > thresholds["response_time_p99"]:
+            pytest.fail(f"P99响应时间 {p99_time:.2f}ms 超过阈值 {thresholds['response_time_p99']}ms")
+        
+        if throughput < thresholds["throughput_min"]:
+            pytest.fail(f"吞吐量 {throughput:.2f} rps 低于最小值 {thresholds['throughput_min']} rps")
+        
+        logger.info(f"性能测试通过: P95={p95_time:.2f}ms, P99={p99_time:.2f}ms, 吞吐量={throughput:.2f} rps")
+
+
+@pytest.mark.performance
+@pytest.mark.slow
+class TestAPIPerformance(PerformanceTest):
+    """API性能测试"""
+    
+    @pytest.mark.asyncio
+    async def test_user_list_performance(self, perf_client: AsyncClient, performance_thresholds):
+        """测试用户列表API性能"""
+        results = await self.measure_concurrent_requests(
+            perf_client, "GET", "/api/users", concurrency=20
+        )
+        
+        self.assert_performance(results, performance_thresholds)
+        logger.info(f"用户列表API性能: {results}")
+    
+    @pytest.mark.asyncio
+    async def test_role_list_performance(self, perf_client: AsyncClient, performance_thresholds):
+        """测试角色列表API性能"""
+        results = await self.measure_concurrent_requests(
+            perf_client, "GET", "/api/roles", concurrency=20
+        )
+        
+        self.assert_performance(results, performance_thresholds)
+        logger.info(f"角色列表API性能: {results}")
+    
+    @pytest.mark.asyncio
+    async def test_notice_list_performance(self, perf_client: AsyncClient, performance_thresholds):
+        """测试通知列表API性能"""
+        results = await self.measure_concurrent_requests(
+            perf_client, "GET", "/api/notices", concurrency=20
+        )
+        
+        self.assert_performance(results, performance_thresholds)
+        logger.info(f"通知列表API性能: {results}")
+    
+    @pytest.mark.asyncio
+    async def test_search_performance(self, perf_client: AsyncClient, performance_thresholds):
+        """测试搜索API性能"""
+        results = await self.measure_concurrent_requests(
+            perf_client, "GET", "/api/users/page?keyword=test", concurrency=15
+        )
+        
+        self.assert_performance(results, performance_thresholds)
+        logger.info(f"搜索API性能: {results}")
+
+
+@pytest.mark.performance
+@pytest.mark.slow
+class TestLoadTesting(PerformanceTest):
+    """负载测试"""
+    
+    @pytest.mark.asyncio
+    async def test_sustained_load(self, perf_client: AsyncClient):
+        """测试持续负载"""
+        duration_seconds = 30
+        requests_per_second = 5
+        total_requests = duration_seconds * requests_per_second
+        
+        response_times = []
+        start_time = time.time()
+        
+        for i in range(total_requests):
+            response_time = await self.measure_request_time(
+                perf_client, "GET", "/api/users"
+            )
+            response_times.append(response_time)
+            
+            elapsed = time.time() - start_time
+            if elapsed < duration_seconds:
+                sleep_time = max(0, (i + 1) / requests_per_second - elapsed)
+                await asyncio.sleep(max(0, sleep_time))
+        
+        avg_time = statistics.mean(response_times)
+        p95_time = self._percentile(response_times, 95)
+        
+        logger.info(f"持续负载测试 - 平均响应时间: {avg_time:.2f}ms, P95: {p95_time:.2f}ms")
+        
+        assert avg_time < 3000, f"平均响应时间 {avg_time:.2f}ms 超过阈值 3000ms"
+        assert p95_time < 5000, f"P95响应时间 {p95_time:.2f}ms 超过阈值 5000ms"
+    
+    @pytest.mark.asyncio
+    async def test_spike_load(self, perf_client: AsyncClient):
+        """测试突发负载"""
+        spike_sizes = [10, 50, 100, 50, 10]
+        
+        for spike_size in spike_sizes:
+            results = await self.measure_concurrent_requests(
+                perf_client, "GET", "/api/users", concurrency=spike_size
+            )
+            
+            logger.info(f"突发负载测试 (并发={spike_size}): P95={results['p95_time_ms']:.2f}ms")
+            
+            assert results["p95_time_ms"] < 10000, \
+                f"突发负载 {spike_size} 并发时 P95响应时间超时"

api_integration_tests/tests/test_permission.py

@@ -0,0 +1,274 @@
+"""
+权限管理增强测试用例
+"""
+
+import pytest
+from api.role_api import RoleAPI
+from api.user_api import UserAPI
+
+
+@pytest.mark.permission
+@pytest.mark.regression
+class TestPermission:
+    """权限管理测试类"""
+    
+    @pytest.mark.asyncio
+    async def test_user_role_assignment(self, authenticated_client, test_user_data, test_role_data, cleanup_user, cleanup_role):
+        """测试用户角色分配"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        user_response = await user_api.create_user(test_user_data)
+        user_id = user_response.json()["id"]
+        
+        role_response = await role_api.create_role(test_role_data)
+        role_id = role_response.json()["id"]
+        
+        update_data = {"roleId": role_id}
+        response = await user_api.update_user(user_id, update_data)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["roleId"] == role_id
+        
+        cleanup_user.append(user_id)
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_user_role_removal(self, authenticated_client, test_user_data, test_role_data, cleanup_user, cleanup_role):
+        """测试用户角色移除"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        user_response = await user_api.create_user(test_user_data)
+        user_id = user_response.json()["id"]
+        
+        role_response = await role_api.create_role(test_role_data)
+        role_id = role_response.json()["id"]
+        
+        await user_api.update_user(user_id, {"roleId": role_id})
+        
+        response = await user_api.update_user(user_id, {"roleId": None})
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["roleId"] is None
+        
+        cleanup_user.append(user_id)
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_role_status_permission(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.update_role(role_id, {"status": 0})
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == 0
+        
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_multiple_users_same_role(self, authenticated_client, test_user_data, test_role_data, cleanup_user, cleanup_role):
+        """测试多个用户分配相同角色"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        role_response = await role_api.create_role(test_role_data)
+        role_id = role_response.json()["id"]
+        
+        user_ids = []
+        for i in range(3):
+            import time
+            timestamp = int(time.time() * 1000)
+            user_data = test_user_data.copy()
+            user_data["username"] = f"testuser_{timestamp}_{i}"
+            user_data["email"] = f"test_{timestamp}_{i}@example.com"
+            
+            user_response = await user_api.create_user(user_data)
+            user_id = user_response.json()["id"]
+            user_ids.append(user_id)
+            
+            await user_api.update_user(user_id, {"roleId": role_id})
+        
+        for user_id in user_ids:
+            user_response = await user_api.get_user_by_id(user_id)
+            assert user_response.json()["roleId"] == role_id
+        
+        cleanup_user.extend(user_ids)
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_role_hierarchy(self, authenticated_client, cleanup_role):
+        """测试角色层级"""
+        role_api = RoleAPI(authenticated_client)
+        
+        import time
+        timestamp = int(time.time() * 1000)
+        
+        admin_role_data = {
+            "roleName": f"Admin_{timestamp}",
+            "roleKey": f"admin_{timestamp}",
+            "roleSort": 1,
+            "status": 1
+        }
+        admin_response = await role_api.create_role(admin_role_data)
+        admin_id = admin_response.json()["id"]
+        
+        user_role_data = {
+            "roleName": f"User_{timestamp}",
+            "roleKey": f"user_{timestamp}",
+            "roleSort": 2,
+            "status": 1
+        }
+        user_response = await role_api.create_role(user_role_data)
+        user_id = user_response.json()["id"]
+        
+        all_roles = await role_api.get_all_roles()
+        roles_data = all_roles.json()
+        role_sorts = [role["roleSort"] for role in roles_data]
+        
+        assert 1 in role_sorts
+        assert 2 in role_sorts
+        
+        cleanup_role.extend([admin_id, user_id])
+    
+    @pytest.mark.asyncio
+    async def test_permission_inheritance(self, authenticated_client, test_user_data, test_role_data, cleanup_user, cleanup_role):
+        """测试权限继承"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        role_response = await role_api.create_role(test_role_data)
+        role_id = role_response.json()["id"]
+        
+        user_response = await user_api.create_user(test_user_data)
+        user_id = user_response.json()["id"]
+        
+        await user_api.update_user(user_id, {"roleId": role_id})
+        
+        user_data = await user_api.get_user_by_id(user_id)
+        assert user_data.json()["roleId"] == role_id
+        
+        role_data = await role_api.get_role_by_id(role_id)
+        assert role_data.json()["id"] == role_id
+        
+        cleanup_user.append(user_id)
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_role_sort_order(self, authenticated_client, cleanup_role):
+        """测试角色排序"""
+        role_api = RoleAPI(authenticated_client)
+        
+        import time
+        timestamp = int(time.time() * 1000)
+        
+        role1_data = {
+            "roleName": f"Role1_{timestamp}",
+            "roleKey": f"role1_{timestamp}",
+            "roleSort": 3,
+            "status": 1
+        }
+        role1_response = await role_api.create_role(role1_data)
+        role1_id = role1_response.json()["id"]
+        
+        role2_data = {
+            "roleName": f"Role2_{timestamp}",
+            "roleKey": f"role2_{timestamp}",
+            "roleSort": 1,
+            "status": 1
+        }
+        role2_response = await role_api.create_role(role2_data)
+        role2_id = role2_response.json()["id"]
+        
+        role3_data = {
+            "roleName": f"Role3_{timestamp}",
+            "roleKey": f"role3_{timestamp}",
+            "roleSort": 2,
+            "status": 1
+        }
+        role3_response = await role_api.create_role(role3_data)
+        role3_id = role3_response.json()["id"]
+        
+        response = await role_api.get_roles_by_page(page=0, size=10, sort="roleSort", order="asc")
+        roles = response.json()["content"]
+        
+        role_sorts = [role["roleSort"] for role in roles]
+        assert role_sorts == sorted(role_sorts)
+        
+        cleanup_role.extend([role1_id, role2_id, role3_id])
+    
+    @pytest.mark.asyncio
+    async def test_disabled_role_access(self, authenticated_client, test_user_data, test_role_data, cleanup_user, cleanup_role):
+        """测试禁用角色的访问控制"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        role_response = await role_api.create_role(test_role_data)
+        role_id = role_response.json()["id"]
+        
+        user_response = await user_api.create_user(test_user_data)
+        user_id = user_response.json()["id"]
+        
+        await user_api.update_user(user_id, {"roleId": role_id})
+        
+        await role_api.update_role(role_id, {"status": 0})
+        
+        role_data = await role_api.get_role_by_id(role_id)
+        assert role_data.json()["status"] == 0
+        
+        cleanup_user.append(user_id)
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_role_uniqueness(self, authenticated_client, cleanup_role):
+        """测试角色唯一性约束"""
+        role_api = RoleAPI(authenticated_client)
+        
+        import time
+        timestamp = int(time.time() * 1000)
+        
+        role_data = {
+            "roleName": f"UniqueRole_{timestamp}",
+            "roleKey": f"unique_role_{timestamp}",
+            "roleSort": 1,
+            "status": 1
+        }
+        
+        response1 = await role_api.create_role(role_data)
+        assert response1.status_code == 201
+        role_id = response1.json()["id"]
+        
+        response2 = await role_api.create_role(role_data)
+        assert response2.status_code in [400, 409]
+        
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_role_deletion_with_users(self, authenticated_client, test_user_data, test_role_data, cleanup_user, cleanup_role):
+        """测试删除有用户的角色"""
+        user_api = UserAPI(authenticated_client)
+        role_api = RoleAPI(authenticated_client)
+        
+        role_response = await role_api.create_role(test_role_data)
+        role_id = role_response.json()["id"]
+        
+        user_response = await user_api.create_user(test_user_data)
+        user_id = user_response.json()["id"]
+        
+        await user_api.update_user(user_id, {"roleId": role_id})
+        
+        delete_response = await role_api.delete_role(role_id)
+        assert delete_response.status_code == 200
+        
+        user_data = await user_api.get_user_by_id(user_id)
+        assert user_data.json()["roleId"] is None
+        
+        cleanup_user.append(user_id)
+        cleanup_role.append(role_id)

api_integration_tests/tests/test_real_e2e.py

@@ -0,0 +1,292 @@
+"""
+真实的端到端（E2E）测试 - 使用Playwright测试前后端联通
+"""
+
+import pytest
+import time
+from playwright.async_api import async_playwright, Page, Browser, BrowserContext
+from httpx import AsyncClient
+
+from config.settings import settings
+
+
+@pytest.mark.e2e
+@pytest.mark.playwright
+class TestRealE2E:
+    """真实的端到端测试类"""
+    
+    @pytest.fixture
+    async def browser(self):
+        """浏览器fixture - headless模式"""
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=True)
+            yield browser
+            await browser.close()
+    
+    @pytest.fixture
+    async def context(self, browser):
+        """浏览器上下文fixture"""
+        context = await browser.new_context()
+        yield context
+        await context.close()
+    
+    @pytest.fixture
+    async def page(self, context):
+        """页面fixture"""
+        page = await context.new_page()
+        page.set_default_timeout(30000)
+        yield page
+        await page.close()
+    
+    @pytest.fixture
+    async def authenticated_client(self):
+        """已认证的HTTP客户端"""
+        async with AsyncClient(base_url=settings.API_BASE_URL) as client:
+            response = await client.post(
+                "/api/auth/login",
+                json={
+                    "username": settings.TEST_USERNAME,
+                    "password": settings.TEST_PASSWORD
+                }
+            )
+            assert response.status_code == 200
+            token = response.json().get("token")
+            client.headers.update({"Authorization": f"Bearer {token}"})
+            yield client
+    
+    @pytest.mark.asyncio
+    async def test_complete_user_lifecycle_e2e(self, page, authenticated_client):
+        """测试完整的用户生命周期 - 前后端联通"""
+        timestamp = int(time.time() * 1000)
+        username = f"e2e_user_{timestamp}"
+        email = f"e2e_{timestamp}@example.com"
+        
+        # 1. 通过前端登录
+        await page.goto("http://localhost:3002/login")
+        await page.wait_for_load_state("networkidle")
+        
+        await page.fill('input[name="username"]', settings.TEST_USERNAME)
+        await page.fill('input[name="password"]', settings.TEST_PASSWORD)
+        await page.click('button[type="submit"]')
+        
+        await page.wait_for_url("**/")
+        assert await page.title() != ""
+        
+        # 2. 通过前端创建用户
+        await page.click('text=用户管理')
+        await page.wait_for_url("**/users")
+        
+        await page.click('text=创建用户')
+        
+        await page.fill('input[name="username"]', username)
+        await page.fill('input[name="email"]', email)
+        await page.fill('input[name="phone"]', '13800138000')
+        await page.fill('input[name="password"]', 'Test123!@#')
+        await page.fill('input[name="confirmPassword"]', 'Test123!@#')
+        
+        await page.click('button[type="submit"]')
+        
+        await page.wait_for_selector('.success-message', timeout=10000)
+        success_message = await page.text_content('.success-message')
+        assert '成功' in success_message or 'success' in success_message.lower()
+        
+        # 3. 通过API验证用户已创建
+        response = await authenticated_client.get("/api/users")
+        assert response.status_code == 200
+        users = response.json()
+        user_exists = any(user['username'] == username for user in users)
+        assert user_exists, f"User {username} not found in API response"
+        
+        # 4. 通过前端验证用户显示
+        await page.reload()
+        await page.wait_for_load_state("networkidle")
+        
+        page_content = await page.content()
+        assert username in page_content, f"Username {username} not found in page content"
+    
+    @pytest.mark.asyncio
+    async def test_role_assignment_e2e(self, page, authenticated_client):
+        """测试角色分配 - 前后端联通"""
+        timestamp = int(time.time() * 1000)
+        role_name = f"E2E_Role_{timestamp}"
+        role_key = f"e2e_role_{timestamp}"
+        
+        # 1. 通过API创建角色
+        role_response = await authenticated_client.post(
+            "/api/roles",
+            json={
+                "roleName": role_name,
+                "roleKey": role_key,
+                "roleSort": 1,
+                "status": 1
+            }
+        )
+        assert role_response.status_code == 201
+        role_id = role_response.json()["id"]
+        
+        # 2. 通过前端登录
+        await page.goto("http://localhost:3002/login")
+        await page.fill('input[name="username"]', settings.TEST_USERNAME)
+        await page.fill('input[name="password"]', settings.TEST_PASSWORD)
+        await page.click('button[type="submit"]')
+        await page.wait_for_url("**/")
+        
+        # 3. 通过前端创建用户
+        await page.click('text=用户管理')
+        await page.wait_for_url("**/users")
+        
+        await page.click('text=创建用户')
+        
+        username = f"e2e_user_{timestamp}"
+        await page.fill('input[name="username"]', username)
+        await page.fill('input[name="email"]', f"e2e_{timestamp}@example.com")
+        await page.fill('input[name="password"]', 'Test123!@#')
+        await page.fill('input[name="confirmPassword"]', 'Test123!@#')
+        
+        await page.click('button[type="submit"]')
+        await page.wait_for_selector('.success-message', timeout=10000)
+        
+        # 4. 通过API获取用户ID并分配角色
+        users_response = await authenticated_client.get("/api/users")
+        users = users_response.json()
+        user = next((u for u in users if u['username'] == username), None)
+        assert user is not None
+        
+        await authenticated_client.put(
+            f"/api/users/{user['id']}",
+            json={"roleId": role_id}
+        )
+        
+        # 5. 通过API验证角色分配
+        user_response = await authenticated_client.get(f"/api/users/{user['id']}")
+        assert user_response.status_code == 200
+        user_data = user_response.json()
+        assert user_data["roleId"] == role_id
+        
+        # 6. 清理测试数据
+        await authenticated_client.delete(f"/api/users/{user['id']}")
+        await authenticated_client.delete(f"/api/roles/{role_id}")
+    
+    @pytest.mark.asyncio
+    async def test_login_and_navigation_e2e(self, page):
+        """测试登录和导航 - 前后端联通"""
+        # 1. 访问登录页面
+        await page.goto("http://localhost:3002/login")
+        await page.wait_for_load_state("networkidle")
+        
+        title = await page.title()
+        assert "登录" in title or "Login" in title.lower()
+        
+        # 2. 填写登录表单
+        await page.fill('input[name="username"]', settings.TEST_USERNAME)
+        await page.fill('input[name="password"]', settings.TEST_PASSWORD)
+        
+        # 3. 点击登录按钮
+        await page.click('button[type="submit"]')
+        
+        # 4. 等待跳转到首页
+        await page.wait_for_url("**/", timeout=10000)
+        
+        # 5. 验证用户信息显示
+        user_info = await page.query_selector('.user-info')
+        assert user_info is not None, "User info element not found"
+        
+        user_text = await user_info.text_content()
+        assert settings.TEST_USERNAME in user_text
+        
+        # 6. 测试导航到不同页面
+        await page.click('text=用户管理')
+        await page.wait_for_url("**/users")
+        
+        await page.click('text=角色管理')
+        await page.wait_for_url("**/roles")
+        
+        await page.click('text=系统配置')
+        await page.wait_for_url("**/config")
+    
+    @pytest.mark.asyncio
+    async def test_system_config_e2e(self, page, authenticated_client):
+        """测试系统配置 - 前后端联通"""
+        # 1. 通过前端登录
+        await page.goto("http://localhost:3002/login")
+        await page.fill('input[name="username"]', settings.TEST_USERNAME)
+        await page.fill('input[name="password"]', settings.TEST_PASSWORD)
+        await page.click('button[type="submit"]')
+        await page.wait_for_url("**/")
+        
+        # 2. 通过前端访问系统配置
+        await page.click('text=系统配置')
+        await page.wait_for_url("**/config")
+        
+        # 3. 验证配置列表显示
+        table = await page.query_selector('table')
+        assert table is not None, "Config table not found"
+        
+        # 4. 通过API获取配置
+        config_response = await authenticated_client.get("/api/config")
+        assert config_response.status_code == 200
+        configs = config_response.json()
+        
+        # 5. 验证前后端数据一致
+        page_content = await page.content()
+        for config in configs[:3]:
+            assert config['configKey'] in page_content or config['configName'] in page_content
+    
+    @pytest.mark.asyncio
+    async def test_search_and_filter_e2e(self, page, authenticated_client):
+        """测试搜索和过滤 - 前后端联通"""
+        timestamp = int(time.time() * 1000)
+        
+        # 1. 通过API创建多个测试用户
+        user_ids = []
+        for i in range(3):
+            username = f"search_{timestamp}_{i}"
+            response = await authenticated_client.post(
+                "/api/users",
+                json={
+                    "username": username,
+                    "password": "Test123!@#",
+                    "email": f"search_{timestamp}_{i}@example.com",
+                    "status": 1
+                }
+            )
+            assert response.status_code == 201
+            user_ids.append(response.json()["id"])
+        
+        try:
+            # 2. 通过前端登录
+            await page.goto("http://localhost:3002/login")
+            await page.fill('input[name="username"]', settings.TEST_USERNAME)
+            await page.fill('input[name="password"]', settings.TEST_PASSWORD)
+            await page.click('button[type="submit"]')
+            await page.wait_for_url("**/")
+            
+            # 3. 通过前端搜索用户
+            await page.click('text=用户管理')
+            await page.wait_for_url("**/users")
+            
+            await page.fill('input[name="keyword"]', f"search_{timestamp}")
+            await page.click('button[type="search"]')
+            
+            await page.wait_for_load_state("networkidle")
+            
+            # 4. 验证搜索结果显示
+            page_content = await page.content()
+            assert f"search_{timestamp}" in page_content
+            
+            # 5. 通过API验证搜索结果
+            search_response = await authenticated_client.get(
+                "/api/users/page",
+                params={"keyword": f"search_{timestamp}", "page": 0, "size": 10}
+            )
+            assert search_response.status_code == 200
+            search_data = search_response.json()
+            assert len(search_data["content"]) >= 3
+            
+        finally:
+            # 6. 清理测试数据
+            for user_id in user_ids:
+                try:
+                    await authenticated_client.delete(f"/api/users/{user_id}")
+                except Exception:
+                    pass

api_integration_tests/tests/test_role.py

@@ -0,0 +1,344 @@
+"""
+角色管理测试用例
+"""
+
+import pytest
+from api.role_api import RoleAPI
+
+
+@pytest.mark.role
+@pytest.mark.regression
+class TestRole:
+    """角色管理测试类"""
+    
+    @pytest.mark.asyncio
+    async def test_create_role_success(self, authenticated_client, test_role_data, cleanup_role):
+        """测试创建角色成功"""
+        role_api = RoleAPI(authenticated_client)
+        response = await role_api.create_role(test_role_data)
+        
+        assert response.status_code == 201
+        data = response.json()
+        assert "id" in data
+        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"])
+    
+    @pytest.mark.asyncio
+    async def test_create_role_duplicate_name(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.create_role(test_role_data)
+        
+        assert response.status_code in [400, 409]
+        
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_get_role_by_id_success(self, authenticated_client, test_role_data, cleanup_role):
+        """测试根据ID获取角色成功"""
+        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.get_role_by_id(role_id)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == role_id
+        assert data["roleName"] == test_role_data["roleName"]
+        
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_get_role_by_id_not_found(self, authenticated_client):
+        """测试获取不存在的角色"""
+        role_api = RoleAPI(authenticated_client)
+        response = await role_api.get_role_by_id(999999)
+        
+        assert response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_get_role_by_name_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.get_role_by_name(test_role_data["roleName"])
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["roleName"] == test_role_data["roleName"]
+        
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_get_all_roles_success(self, authenticated_client):
+        """测试获取所有角色成功"""
+        role_api = RoleAPI(authenticated_client)
+        response = await role_api.get_all_roles()
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+    
+    @pytest.mark.asyncio
+    async def test_update_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"]
+        
+        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["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)
+        role_id = create_response.json()["id"]
+        
+        response = await role_api.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
+        
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_restore_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"]
+        
+        await role_api.delete_role(role_id)
+        
+        response = await role_api.restore_role(role_id)
+        
+        assert response.status_code == 200
+        
+        get_response = await role_api.get_role_by_id(role_id)
+        assert get_response.status_code == 200
+        
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_check_name_exists_true(self, authenticated_client, test_role_data, cleanup_role):
+        """测试检查角色名存在-返回true"""
+        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.check_name_exists(test_role_data["roleName"])
+        
+        assert response.status_code == 200
+        assert response.json() is True
+        
+        cleanup_role.append(role_id)
+    
+    @pytest.mark.asyncio
+    async def test_check_name_exists_false(self, authenticated_client):
+        """测试检查角色名存在-返回false"""
+        role_api = RoleAPI(authenticated_client)
+        response = await role_api.check_name_exists("NONEXISTENT_ROLE")
+        
+        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

api_integration_tests/tests/test_user.py

@@ -0,0 +1,340 @@
+"""
+用户管理测试用例
+"""
+
+import pytest
+from api.user_api import UserAPI
+from config.settings import settings
+
+
+@pytest.mark.user
+@pytest.mark.regression
+class TestUser:
+    """用户管理测试类"""
+    
+    @pytest.mark.asyncio
+    async def test_create_user_success(self, authenticated_client, test_user_data, cleanup_user):
+        """测试创建用户成功"""
+        user_api = UserAPI(authenticated_client)
+        response = await user_api.create_user(test_user_data)
+        
+        print(f"Response status: {response.status_code}")
+        print(f"Response text: {response.text}")
+        
+        assert response.status_code == 201
+        data = response.json()
+        assert "id" in data
+        assert data["username"] == test_user_data["username"]
+        assert data["email"] == test_user_data["email"]
+        assert "password" not in data or data["password"] != test_user_data["password"]
+        
+        cleanup_user.append(data["id"])
+    
+    @pytest.mark.asyncio
+    async def test_create_user_duplicate_username(self, authenticated_client, test_user_data, cleanup_user):
+        """测试创建重复用户名"""
+        user_api = UserAPI(authenticated_client)
+        
+        await user_api.create_user(test_user_data)
+        response = await user_api.create_user(test_user_data)
+        
+        assert response.status_code in [400, 409]
+    
+    @pytest.mark.asyncio
+    async def test_get_user_by_id_success(self, authenticated_client, test_user_data, cleanup_user):
+        """测试根据ID获取用户成功"""
+        user_api = UserAPI(authenticated_client)
+        
+        create_response = await user_api.create_user(test_user_data)
+        user_id = create_response.json()["id"]
+        
+        response = await user_api.get_user_by_id(user_id)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == user_id
+        assert data["username"] == test_user_data["username"]
+        
+        cleanup_user.append(user_id)
+    
+    @pytest.mark.asyncio
+    async def test_get_user_by_id_not_found(self, authenticated_client):
+        """测试获取不存在的用户"""
+        user_api = UserAPI(authenticated_client)
+        response = await user_api.get_user_by_id(999999)
+        
+        assert response.status_code == 404
+    
+    @pytest.mark.asyncio
+    async def test_get_all_users_success(self, authenticated_client):
+        """测试获取所有用户成功"""
+        user_api = UserAPI(authenticated_client)
+        response = await user_api.get_all_users()
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+    
+    @pytest.mark.asyncio
+    async def test_update_user_success(self, authenticated_client, test_user_data, cleanup_user):
+        """测试更新用户成功"""
+        user_api = UserAPI(authenticated_client)
+        
+        create_response = await user_api.create_user(test_user_data)
+        user_id = create_response.json()["id"]
+        
+        update_data = {"email": "updated@example.com"}
+        response = await user_api.update_user(user_id, update_data)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["email"] == "updated@example.com"
+        
+        cleanup_user.append(user_id)
+    
+    @pytest.mark.asyncio
+    async def test_delete_user_success(self, authenticated_client, test_user_data, cleanup_user):
+        """测试删除用户成功"""
+        user_api = UserAPI(authenticated_client)
+        
+        create_response = await user_api.create_user(test_user_data)
+        user_id = create_response.json()["id"]
+        
+        response = await user_api.delete_user(user_id)
+        
+        assert response.status_code == 204
+    
+    @pytest.mark.asyncio
+    async def test_logical_delete_user_success(self, authenticated_client, test_user_data, cleanup_user):
+        """测试逻辑删除用户成功"""
+        user_api = UserAPI(authenticated_client)
+        
+        create_response = await user_api.create_user(test_user_data)
+        user_id = create_response.json()["id"]
+        
+        response = await user_api.logical_delete_user(user_id)
+        
+        assert response.status_code == 204
+        
+        get_response = await user_api.get_user_by_id(user_id)
+        assert get_response.status_code == 404
+        
+        get_deleted_response = await user_api.get_all_users(include_deleted=True)
+        deleted_users = get_deleted_response.json()
+        assert any(u["id"] == user_id for u in deleted_users)
+        
+        cleanup_user.append(user_id)
+    
+    @pytest.mark.asyncio
+    async def test_restore_user_success(self, authenticated_client, test_user_data, cleanup_user):
+        """测试恢复用户成功"""
+        user_api = UserAPI(authenticated_client)
+        
+        create_response = await user_api.create_user(test_user_data)
+        user_id = create_response.json()["id"]
+        
+        await user_api.logical_delete_user(user_id)
+        
+        response = await user_api.restore_user(user_id)
+        
+        assert response.status_code == 204
+        
+        get_response = await user_api.get_user_by_id(user_id)
+        assert get_response.status_code == 200
+        
+        cleanup_user.append(user_id)
+    
+    @pytest.mark.asyncio
+    async def test_check_username_exists_true(self, authenticated_client, test_user_data, cleanup_user):
+        """测试检查用户名存在-返回true"""
+        user_api = UserAPI(authenticated_client)
+        
+        create_response = await user_api.create_user(test_user_data)
+        user_id = create_response.json()["id"]
+        
+        response = await user_api.check_username_exists(test_user_data["username"])
+        
+        assert response.status_code == 200
+        assert response.json() is True
+        
+        cleanup_user.append(user_id)
+    
+    @pytest.mark.asyncio
+    async def test_check_username_exists_false(self, authenticated_client):
+        """测试检查用户名存在-返回false"""
+        user_api = UserAPI(authenticated_client)
+        response = await user_api.check_username_exists("nonexistent_user")
+        
+        assert response.status_code == 200
+        assert response.json() is False
+    
+    @pytest.mark.asyncio
+    async def test_check_email_exists_true(self, authenticated_client, test_user_data, cleanup_user):
+        """测试检查邮箱存在-返回true"""
+        user_api = UserAPI(authenticated_client)
+        
+        create_response = await user_api.create_user(test_user_data)
+        user_id = create_response.json()["id"]
+        
+        response = await user_api.check_email_exists(test_user_data["email"])
+        
+        assert response.status_code == 200
+        assert response.json() is True
+        
+        cleanup_user.append(user_id)
+    
+    @pytest.mark.asyncio
+    async def test_check_email_exists_false(self, authenticated_client):
+        """测试检查邮箱存在-返回false"""
+        user_api = UserAPI(authenticated_client)
+        response = await user_api.check_email_exists("nonexistent@example.com")
+        
+        assert response.status_code == 200
+        assert response.json() is False
+    
+    @pytest.mark.asyncio
+    async def test_get_users_by_page_success(self, authenticated_client, test_user_data, cleanup_user):
+        """测试分页获取用户成功"""
+        import time
+        user_api = UserAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        for i in range(5):
+            user_data = test_user_data.copy()
+            user_data["username"] = f"testuser_{timestamp}_{i}"
+            user_data["email"] = f"testuser_{timestamp}_{i}@example.com"
+            create_response = await user_api.create_user(user_data)
+            cleanup_user.append(create_response.json()["id"])
+        
+        response = await user_api.get_users_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_users_by_page_with_sort(self, authenticated_client, test_user_data, cleanup_user):
+        """测试分页获取用户并排序成功"""
+        import time
+        user_api = UserAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        user1_data = test_user_data.copy()
+        user1_data["username"] = f"user_a_{timestamp}"
+        user1_data["email"] = f"user_a_{timestamp}@example.com"
+        create_response1 = await user_api.create_user(user1_data)
+        cleanup_user.append(create_response1.json()["id"])
+        
+        user2_data = test_user_data.copy()
+        user2_data["username"] = f"user_b_{timestamp}"
+        user2_data["email"] = f"user_b_{timestamp}@example.com"
+        create_response2 = await user_api.create_user(user2_data)
+        cleanup_user.append(create_response2.json()["id"])
+        
+        response = await user_api.get_users_by_page(page=0, size=10, sort="username", order="asc")
+        
+        assert response.status_code == 200
+        data = response.json()
+        usernames = [user["username"] for user in data["content"]]
+        assert usernames == sorted(usernames)
+    
+    @pytest.mark.asyncio
+    async def test_get_users_by_page_with_search(self, authenticated_client, test_user_data, cleanup_user):
+        """测试分页获取用户并搜索成功"""
+        import time
+        user_api = UserAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        user1_data = test_user_data.copy()
+        user1_data["username"] = f"search_test_user_{timestamp}"
+        user1_data["email"] = f"search_test_{timestamp}@example.com"
+        create_response1 = await user_api.create_user(user1_data)
+        cleanup_user.append(create_response1.json()["id"])
+        
+        user2_data = test_user_data.copy()
+        user2_data["username"] = f"other_user_{timestamp}"
+        user2_data["email"] = f"other_{timestamp}@example.com"
+        create_response2 = await user_api.create_user(user2_data)
+        cleanup_user.append(create_response2.json()["id"])
+        
+        response = await user_api.get_users_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 user["username"] or "search" in user["email"] 
+                  for user in data["content"])
+    
+    @pytest.mark.asyncio
+    async def test_get_user_count_success(self, authenticated_client, test_user_data, cleanup_user):
+        """测试获取用户总数成功"""
+        user_api = UserAPI(authenticated_client)
+        
+        initial_count_response = await user_api.get_user_count()
+        initial_count = initial_count_response.json()
+        
+        create_response = await user_api.create_user(test_user_data)
+        cleanup_user.append(create_response.json()["id"])
+        
+        final_count_response = await user_api.get_user_count()
+        final_count = final_count_response.json()
+        
+        assert final_count == initial_count + 1
+    
+    @pytest.mark.asyncio
+    async def test_get_users_by_page_with_different_page_sizes(self, authenticated_client, test_user_data, cleanup_user):
+        """测试不同页面大小的分页获取用户成功"""
+        import time
+        user_api = UserAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        for i in range(15):
+            user_data = test_user_data.copy()
+            user_data["username"] = f"pagesize_test_{timestamp}_{i}"
+            user_data["email"] = f"pagesize_test_{timestamp}_{i}@example.com"
+            create_response = await user_api.create_user(user_data)
+            cleanup_user.append(create_response.json()["id"])
+        
+        response_size_10 = await user_api.get_users_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 user_api.get_users_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_users_by_page_with_page_navigation(self, authenticated_client, test_user_data, cleanup_user):
+        """测试分页导航成功"""
+        import time
+        user_api = UserAPI(authenticated_client)
+        
+        timestamp = int(time.time() * 1000)
+        for i in range(25):
+            user_data = test_user_data.copy()
+            user_data["username"] = f"pagination_test_{timestamp}_{i}"
+            user_data["email"] = f"pagination_test_{timestamp}_{i}@example.com"
+            create_response = await user_api.create_user(user_data)
+            cleanup_user.append(create_response.json()["id"])
+        
+        page1_response = await user_api.get_users_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 user_api.get_users_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 user_api.get_users_by_page(page=2, size=10)
+        page3_data = page3_response.json()
+        assert page3_data["currentPage"] == 2
+        assert len(page3_data["content"]) >= 5

api_integration_tests/tests/test_websocket.py

@@ -0,0 +1,191 @@
+"""
+WebSocket实时通信测试用例
+"""
+
+import pytest
+import asyncio
+import json
+import os
+from websockets.client import connect
+from websockets.exceptions import ConnectionClosed
+
+
+@pytest.mark.websocket
+@pytest.mark.regression
+class TestWebSocket:
+    """WebSocket实时通信测试类"""
+    
+    @pytest.fixture
+    def websocket_url(self):
+        """WebSocket连接URL"""
+        api_base_url = os.getenv("API_BASE_URL", "http://localhost:8084")
+        ws_url = api_base_url.replace("http://", "ws://")
+        return f"{ws_url}/ws"
+    
+    @pytest.fixture
+    async def websocket_connection(self, websocket_url):
+        """WebSocket连接fixture"""
+        async with connect(websocket_url) as websocket:
+            yield websocket
+    
+    @pytest.fixture
+    async def authenticated_websocket(self, websocket_url, authenticated_client):
+        """带认证的WebSocket连接"""
+        token = authenticated_client.headers.get("Authorization")
+        url_with_token = f"{websocket_url}?token={token.replace('Bearer ', '')}"
+        
+        async with connect(url_with_token) as websocket:
+            yield websocket
+    
+    @pytest.mark.asyncio
+    async def test_websocket_connection(self, websocket_url):
+        """测试WebSocket连接建立"""
+        try:
+            async with connect(websocket_url) as websocket:
+                assert websocket.open
+        except ConnectionRefusedError:
+            pytest.skip("WebSocket服务未启动")
+    
+    @pytest.mark.asyncio
+    async def test_websocket_ping_pong(self, websocket_connection):
+        """测试WebSocket心跳机制"""
+        ping_message = {
+            "type": "ping",
+            "timestamp": 1234567890
+        }
+        
+        await websocket_connection.send(json.dumps(ping_message))
+        
+        response = await asyncio.wait_for(websocket_connection.recv(), timeout=5.0)
+        pong_message = json.loads(response)
+        
+        assert pong_message["type"] == "pong"
+        assert "timestamp" in pong_message
+    
+    @pytest.mark.asyncio
+    async def test_websocket_subscribe(self, websocket_connection):
+        """测试WebSocket订阅"""
+        subscribe_message = {
+            "type": "subscribe",
+            "channel": "notifications"
+        }
+        
+        await websocket_connection.send(json.dumps(subscribe_message))
+        
+        response = await asyncio.wait_for(websocket_connection.recv(), timeout=5.0)
+        message = json.loads(response)
+        
+        assert message["type"] in ["subscribe_ack", "pong"]
+    
+    @pytest.mark.asyncio
+    async def test_websocket_multiple_messages(self, websocket_connection):
+        """测试WebSocket多消息处理"""
+        messages = [
+            {"type": "ping"},
+            {"type": "subscribe", "channel": "test"},
+            {"type": "ping"}
+        ]
+        
+        responses = []
+        for msg in messages:
+            await websocket_connection.send(json.dumps(msg))
+            try:
+                response = await asyncio.wait_for(websocket_connection.recv(), timeout=2.0)
+                responses.append(json.loads(response))
+            except asyncio.TimeoutError:
+                pass
+        
+        assert len(responses) >= 2
+    
+    @pytest.mark.asyncio
+    async def test_websocket_invalid_message(self, websocket_connection):
+        """测试WebSocket无效消息处理"""
+        invalid_messages = [
+            "invalid json",
+            "",
+            json.dumps({"type": "unknown_type"}),
+            json.dumps({})
+        ]
+        
+        for msg in invalid_messages:
+            try:
+                await websocket_connection.send(msg)
+                await asyncio.sleep(0.5)
+            except Exception:
+                pass
+    
+    @pytest.mark.asyncio
+    async def test_websocket_connection_close(self, websocket_url):
+        """测试WebSocket连接关闭"""
+        async with connect(websocket_url) as websocket:
+            assert websocket.open
+            await websocket.close()
+            assert not websocket.open
+    
+    @pytest.mark.asyncio
+    async def test_websocket_timeout(self, websocket_url):
+        """测试WebSocket超时"""
+        try:
+            async with connect(websocket_url, ping_timeout=2.0) as websocket:
+                await asyncio.sleep(3.0)
+        except (ConnectionClosed, asyncio.TimeoutError):
+            pass
+    
+    @pytest.mark.asyncio
+    async def test_websocket_concurrent_connections(self, websocket_url):
+        """测试WebSocket并发连接"""
+        async def create_connection():
+            try:
+                async with connect(websocket_url) as websocket:
+                    await websocket.send(json.dumps({"type": "ping"}))
+                    await asyncio.wait_for(websocket_connection.recv(), timeout=2.0)
+            except Exception:
+                pass
+        
+        connections = [create_connection() for _ in range(5)]
+        await asyncio.gather(*connections, return_exceptions=True)
+    
+    @pytest.mark.asyncio
+    async def test_websocket_large_message(self, websocket_connection):
+        """测试WebSocket大消息处理"""
+        large_data = "x" * 10000
+        message = {
+            "type": "test",
+            "data": large_data
+        }
+        
+        await websocket_connection.send(json.dumps(message))
+        
+        try:
+            response = await asyncio.wait_for(websocket_connection.recv(), timeout=5.0)
+            assert response
+        except asyncio.TimeoutError:
+            pass
+    
+    @pytest.mark.asyncio
+    async def test_websocket_reconnect(self, websocket_url):
+        """测试WebSocket重连"""
+        for i in range(3):
+            try:
+                async with connect(websocket_url) as websocket:
+                    await websocket.send(json.dumps({"type": "ping"}))
+                    response = await asyncio.wait_for(websocket.recv(), timeout=2.0)
+                    assert response
+            except Exception:
+                pass
+    
+    @pytest.mark.asyncio
+    async def test_websocket_unicode_message(self, websocket_connection):
+        """测试WebSocket Unicode消息"""
+        unicode_message = {
+            "type": "test",
+            "content": "测试中文🎉🚀"
+        }
+        
+        await websocket_connection.send(json.dumps(unicode_message))
+        
+        try:
+            response = await asyncio.wait_for(websocket_connection.recv(), timeout=2.0)
+            assert response
+        except asyncio.TimeoutError:
+            pass