from django.test import TestCase from django.conf import settings from django.core.cache import cache from unittest.mock import patch import json from rest_framework.exceptions import ValidationError from rest_framework.test import APIRequestFactory from common.constants.permission_constants import RoleConstants from common.constants.cache_version import Cache_Version from common.exception.app_exception import AppApiException from common.utils.common import password_encrypt from common.utils.rsa_util import encrypt, generate from users.models import User, UserActivationApplication, ActivationStatus, UserRoleAssignment from users.serializers.login import LoginSerializer from users.serializers.register import RegisterSerializer from users.serializers.user import UserManageSerializer from users.serializers.user_manage_ext import ActivationSerializer, RoleAssignmentSerializer, send_activation_notice from users.serializers.user import exclude_unactivated_users from system_manage.serializers.user_resource_permission import UserResourcePermissionSerializer, ResourceUserPermissionSerializer from unittest.mock import Mock from users.views.register import RegisterView from users.views.user_manage_ext import UserActivationApproveView @patch('users.serializers.user.DatabaseModelManage.get_model', return_value=None) class RegistrationTests(TestCase): def setUp(self): self.payload = { 'username': 'signup_test', 'nick_name': '注册测试', 'email': 'signup@example.com', 'phone': '', 'password': 'Signup@123', 're_password': 'Signup@123', } self.admin = User.objects.create( username='review_admin', nick_name='审核员', email='review@example.com', password=password_encrypt('Review@123'), role=RoleConstants.ADMIN.name, ) def test_public_registration_forces_pending_local_user(self, _registry): response = RegisterView.as_view()(APIRequestFactory().post('/user/register', { **self.payload, 'is_active': True, 'pending_activation': False, 'role': 'ADMIN', 'source': 'LDAP', 'role_setting': [{'role_id': 'ADMIN', 'workspace_ids': ['default']}], }, format='json')) self.assertEqual(response.status_code, 200) user = User.objects.get(username=self.payload['username']) self.assertFalse(user.is_active) self.assertEqual(user.role, 'USER') self.assertEqual(user.source, 'LOCAL') self.assertEqual(user.password, password_encrypt(self.payload['password'])) self.assertEqual(user.activation_application.status, ActivationStatus.PENDING) self.assertFalse(UserRoleAssignment.objects.filter(user=user).exists()) def test_password_confirmation_is_required(self, _registry): with self.assertRaises(ValidationError): RegisterSerializer.register({**self.payload, 're_password': 'Other@123'}) self.assertFalse(User.objects.filter(username=self.payload['username']).exists()) def test_encrypted_registration_credentials(self, _registry): key_pair = generate() credentials = {key: self.payload[key] for key in ('password', 're_password')} payload = {key: value for key, value in self.payload.items() if key not in credentials} payload['encryptedData'] = encrypt(json.dumps(credentials), public_key=key_pair['key']) with patch('common.utils.rsa_util.get_key_pair', return_value=key_pair): RegisterSerializer.register(payload) user = User.objects.get(username=self.payload['username']) self.assertEqual(user.password, password_encrypt(self.payload['password'])) self.assertFalse(user.is_active) def test_anonymous_user_cannot_approve(self, _registry): RegisterSerializer.register(self.payload) application = UserActivationApplication.objects.get() response = UserActivationApproveView.as_view()( APIRequestFactory().post('/activation/approve', {}, format='json'), application_id=str(application.id), ) self.assertEqual(response.status_code, 401) application.refresh_from_db() self.assertEqual(application.status, ActivationStatus.PENDING) def test_invalid_email_and_weak_password_are_rejected(self, _registry): for change in ({'email': 'invalid'}, {'password': '123456', 're_password': '123456'}): with self.subTest(change=list(change)): with self.assertRaises(ValidationError): RegisterSerializer.register({**self.payload, **change}) def test_duplicate_registration_does_not_create_another_application(self, _registry): RegisterSerializer.register(self.payload) with self.assertRaises(AppApiException): RegisterSerializer.register(self.payload) self.assertEqual(UserActivationApplication.objects.count(), 1) @patch.object(LoginSerializer, 'get_auth_setting', return_value={'max_attempts': 1}) def test_login_requires_approval(self, _settings, _registry): RegisterSerializer.register(self.payload) credentials = {'username': self.payload['username'], 'password': self.payload['password']} with self.assertRaises(AppApiException) as error: LoginSerializer.login(credentials.copy()) self.assertIn('待审核', str(error.exception)) application = UserActivationApplication.objects.get() ActivationSerializer.approve(str(application.id), str(self.admin.id)) self.assertIn('token', LoginSerializer.login(credentials.copy())) application.refresh_from_db() self.assertEqual(application.status, ActivationStatus.APPROVED) self.assertEqual(application.audit_by_id, self.admin.id) self.assertTrue(UserRoleAssignment.objects.filter(user=application.user, role_id='USER').exists()) with self.assertRaises(AppApiException): ActivationSerializer.approve(str(application.id), str(self.admin.id)) @patch.object(LoginSerializer, 'get_auth_setting', return_value={'max_attempts': -1}) def test_rejected_registration_cannot_login(self, _settings, _registry): RegisterSerializer.register(self.payload) application = UserActivationApplication.objects.get() ActivationSerializer.reject(str(application.id), str(self.admin.id), '审核未通过') with self.assertRaises(AppApiException) as error: LoginSerializer.login({'username': self.payload['username'], 'password': self.payload['password']}) self.assertIn('未通过', str(error.exception)) application.user.refresh_from_db() self.assertFalse(application.user.is_active) def test_admin_creation_can_activate_immediately(self, _registry): data = UserManageSerializer().save({**self.payload, 'pending_activation': False}, str(self.admin.id)) self.assertTrue(data['is_active']) self.assertFalse(UserActivationApplication.objects.filter(user_id=data['id']).exists()) def test_admin_creation_can_require_approval(self, _registry): data = UserManageSerializer().save({**self.payload, 'pending_activation': True}, str(self.admin.id)) self.assertFalse(data['is_active']) self.assertTrue(UserActivationApplication.objects.filter(user_id=data['id'], status='PENDING').exists()) def test_admin_creation_defaults_to_pending(self, _registry): data = UserManageSerializer().save(self.payload, str(self.admin.id)) self.assertFalse(data['is_active']) self.assertTrue(UserActivationApplication.objects.filter(user_id=data['id'], status='PENDING').exists()) def test_anonymous_configuration_does_not_import_django_auth(self, _registry): self.assertIsNone(settings.REST_FRAMEWORK.get('UNAUTHENTICATED_USER', 'missing')) def test_false_string_does_not_require_approval(self, _registry): data = UserManageSerializer().save({**self.payload, 'pending_activation': 'false'}, str(self.admin.id)) self.assertTrue(data['is_active']) def test_pending_user_hidden_from_management_list_and_page(self, _registry): RegisterSerializer.register(self.payload) query = UserManageSerializer.Query(data={'username': self.payload['username']}) self.assertEqual(query.list(), []) page = query.page(1, 20, str(self.admin.id)) self.assertEqual(page['total'], 0) self.assertEqual(page['records'], []) self.assertEqual(ActivationSerializer.page(1, 20)['total'], 1) def test_approved_user_appears_enabled_in_management(self, _registry): RegisterSerializer.register(self.payload) application = UserActivationApplication.objects.get() ActivationSerializer.approve(str(application.id), str(self.admin.id)) page = UserManageSerializer.Query(data={'username': self.payload['username']}).page(1, 20, str(self.admin.id)) self.assertEqual(page['total'], 1) self.assertTrue(page['records'][0]['is_active']) self.assertEqual(ActivationSerializer.page(1, 20)['total'], 0) def test_normal_disabled_account_remains_in_management(self, _registry): data = UserManageSerializer().save({**self.payload, 'pending_activation': False}, str(self.admin.id)) User.objects.filter(id=data['id']).update(is_active=False) page = UserManageSerializer.Query(data={'username': self.payload['username'], 'is_active': False}).page(1, 20, str(self.admin.id)) self.assertEqual(page['total'], 1) self.assertFalse(page['records'][0]['is_active']) def test_rejection_preserves_account_and_allows_resubmission(self, _registry): RegisterSerializer.register(self.payload) application = UserActivationApplication.objects.get() ActivationSerializer.reject(str(application.id), str(self.admin.id), '资料不符') application.refresh_from_db() self.assertEqual(application.reject_reason, '资料不符') self.assertEqual(ActivationSerializer.page(1, 20)['total'], 0) self.assertEqual(ActivationSerializer.page(1, 20, status=ActivationStatus.REJECTED)['total'], 1) page = UserManageSerializer.Query(data={'username': self.payload['username']}).page(1, 20, str(self.admin.id)) self.assertEqual(page['total'], 0) self.assertEqual(page['records'], []) user_id = application.user_id result = RegisterSerializer.register({**self.payload, 'nick_name': '重新提交姓名', 'phone': '13800138009', 'email': 'reapply@example.com'}) self.assertTrue(result['re_register']) application.refresh_from_db() self.assertEqual(application.user_id, user_id) self.assertEqual(application.status, ActivationStatus.PENDING) self.assertEqual(application.reject_reason, '') self.assertIsNone(application.audit_time) self.assertIsNone(application.audit_by_id) user = User.objects.get(id=user_id) self.assertFalse(user.is_active) self.assertEqual(user.nick_name, '重新提交姓名') self.assertEqual(user.phone, '13800138009') self.assertEqual(user.email, 'reapply@example.com') self.assertEqual(application.email, user.email) self.assertEqual(UserActivationApplication.objects.count(), 1) def test_activation_audit_keeps_pending_and_rejected_with_phone(self, _registry): for index, status in enumerate((ActivationStatus.PENDING, ActivationStatus.REJECTED, ActivationStatus.APPROVED)): user = User.objects.create(username=f'audit_{index}', nick_name=f'审核{index}', role='USER', phone=f'1380013800{index}', is_active=status == ActivationStatus.APPROVED) UserActivationApplication.objects.create(user=user, status=status, reject_reason='资料不符' if status == ActivationStatus.REJECTED else '') page = ActivationSerializer.page(1, 20, status='UNAPPROVED') self.assertEqual(page['total'], 2) self.assertEqual({row['status'] for row in page['records']}, {'PENDING', 'REJECTED'}) self.assertEqual({row['phone'] for row in page['records']}, {'13800138000', '13800138001'}) rejected = next(row for row in page['records'] if row['status'] == 'REJECTED') self.assertEqual(rejected['reject_reason'], '资料不符') filtered = ActivationSerializer.page(1, 20, keyword='13800138001', status='UNAPPROVED') self.assertEqual(filtered['total'], 1) self.assertEqual(filtered['records'][0]['status'], 'REJECTED') def test_activation_audit_returns_empty_phone_when_not_provided(self, _registry): RegisterSerializer.register(self.payload) page = ActivationSerializer.page(1, 20, status='UNAPPROVED') self.assertEqual(page['records'][0]['phone'], '') def test_profile_edit_cannot_change_roles(self, _registry): user = User.objects.create(username='profile_user', nick_name='资料用户', role='USER') for changes in ({'role': 'ADMIN'}, {'role_setting': [{'role_id': 'ADMIN'}]}): with self.subTest(changes=changes): with self.assertRaises(AppApiException): UserManageSerializer.Operate(data={'id': str(user.id)}).edit(changes, str(self.admin.id)) user.refresh_from_db() self.assertEqual(user.role, 'USER') def test_profile_edit_keeps_existing_role_assignment(self, _registry): user = User.objects.create(username='profile_admin', nick_name='资料管理员', role='ADMIN') assignment = UserRoleAssignment.objects.create(user=user, role_id='ADMIN', workspace_id='default') UserManageSerializer.Operate(data={'id': str(user.id)}).edit({'nick_name': '更新姓名'}, str(self.admin.id)) user.refresh_from_db() self.assertEqual(user.nick_name, '更新姓名') self.assertEqual(user.role, 'ADMIN') self.assertTrue(UserRoleAssignment.objects.filter(id=assignment.id).exists()) def test_role_choices_are_user_and_admin(self, _registry): detail = RoleAssignmentSerializer.detail(str(self.admin.id)) self.assertEqual(detail['available_roles'], [{'id': 'USER', 'name': '普通用户'}, {'id': 'ADMIN', 'name': '管理员'}]) self.assertNotIn('workspaces', detail) def test_dedicated_role_assignment_updates_role_and_invalidates_cache(self, _registry): user = User.objects.create(username='role_user', nick_name='授权用户', role='USER') for version in (Cache_Version.PERMISSION_LIST, Cache_Version.ROLE_LIST, Cache_Version.USER): cache.set(version.get_key(user_id=user.id), ['old'], version=version.get_version()) RoleAssignmentSerializer.save(str(user.id), [{'role_id': 'ADMIN'}], str(self.admin.id)) user.refresh_from_db() self.assertEqual(user.role, 'ADMIN') assignment = UserRoleAssignment.objects.get(user=user) self.assertEqual(assignment.role_id, 'ADMIN') self.assertEqual(assignment.granted_by_id, self.admin.id) self.assertEqual(assignment.workspace_id, 'default') for version in (Cache_Version.PERMISSION_LIST, Cache_Version.ROLE_LIST, Cache_Version.USER): self.assertIsNone(cache.get(version.get_key(user_id=user.id), version=version.get_version())) RoleAssignmentSerializer.save(str(user.id), [{'role_id': 'USER'}], str(self.admin.id)) user.refresh_from_db() self.assertEqual(user.role, 'USER') self.assertEqual(UserRoleAssignment.objects.filter(user=user).count(), 1) def test_invalid_role_assignment_leaves_existing_role_unchanged(self, _registry): user = User.objects.create(username='invalid_role', nick_name='角色校验', role='USER') assignment = UserRoleAssignment.objects.create(user=user, role_id='USER', workspace_id='default') for roles in ([{'role_id': 'WORKSPACE_MANAGE'}], [{'role_id': 'ADMIN'}, {'role_id': 'USER'}], [{'role_id': 'ADMIN', 'workspace_ids': ['other']}], []): with self.subTest(roles=roles): with self.assertRaises(AppApiException): RoleAssignmentSerializer.save(str(user.id), roles, str(self.admin.id)) user.refresh_from_db() self.assertEqual(user.role, 'USER') self.assertTrue(UserRoleAssignment.objects.filter(id=assignment.id).exists()) def test_builtin_admin_role_cannot_be_downgraded(self, _registry): user = User.objects.create(id='f0dd8f71-e4ee-11ee-8c84-a8a1595801ab', username='builtin', nick_name='内置管理员', role='ADMIN') with self.assertRaises(AppApiException): RoleAssignmentSerializer.save(str(user.id), [{'role_id': 'USER'}], str(self.admin.id)) user.refresh_from_db() self.assertEqual(user.role, 'ADMIN') def test_approved_and_pending_cannot_reregister(self, _registry): RegisterSerializer.register(self.payload) app = UserActivationApplication.objects.get() for status in (ActivationStatus.PENDING, ActivationStatus.APPROVED): app.status = status app.save() with self.subTest(status=status), self.assertRaises(AppApiException): RegisterSerializer.register({**self.payload, 'phone': '13800138008'}) self.assertEqual(User.objects.get(username=self.payload['username']).phone, '') def test_rejected_requires_original_credentials(self, _registry): RegisterSerializer.register(self.payload) app = UserActivationApplication.objects.get() ActivationSerializer.reject(str(app.id), str(self.admin.id), '资料不符') for changed in ({'password': 'Other@123', 're_password': 'Other@123'}, {'username': 'other_name'}): with self.subTest(changed=changed), self.assertRaises(AppApiException): RegisterSerializer.register({**self.payload, **changed}) app.refresh_from_db() self.assertEqual(app.status, ActivationStatus.REJECTED) self.assertEqual(app.reject_reason, '资料不符') def test_reapply_does_not_overwrite_another_account(self, _registry): RegisterSerializer.register(self.payload) app = UserActivationApplication.objects.get() ActivationSerializer.reject(str(app.id), str(self.admin.id), '资料不符') other = User.objects.create(username='other', nick_name='其他姓名', email='other@example.com', role='USER') for changed in ({'nick_name': other.nick_name}, {'email': other.email}): with self.subTest(changed=changed), self.assertRaises(AppApiException): RegisterSerializer.register({**self.payload, **changed}) app.refresh_from_db() self.assertEqual(app.status, ActivationStatus.REJECTED) @patch.object(LoginSerializer, 'get_auth_setting', return_value={'max_attempts': -1}) def test_rejected_login_includes_reason_only_with_correct_password(self, _settings, _registry): RegisterSerializer.register(self.payload) app = UserActivationApplication.objects.get() ActivationSerializer.reject(str(app.id), str(self.admin.id), '手机号与申请资料不一致') with self.assertRaises(AppApiException) as error: LoginSerializer.login({'username': self.payload['username'], 'password': self.payload['password']}) self.assertIn('手机号与申请资料不一致', str(error.exception)) with self.assertRaises(AppApiException) as error: LoginSerializer.login({'username': self.payload['username'], 'password': 'Wrong@123'}) self.assertNotIn('手机号与申请资料不一致', str(error.exception)) def test_audit_notices_are_scheduled_after_commit(self, _registry): RegisterSerializer.register(self.payload) app = UserActivationApplication.objects.get() with patch('users.serializers.user_manage_ext.send_activation_notice') as notice: with self.captureOnCommitCallbacks(execute=True): ActivationSerializer.reject(str(app.id), str(self.admin.id), '资料不符') notice.assert_not_called() self.assertEqual(notice.call_args.args[1:], (False, '资料不符')) RegisterSerializer.register(self.payload) with patch('users.serializers.user_manage_ext.send_activation_notice') as notice: with self.captureOnCommitCallbacks(execute=True): ActivationSerializer.approve(str(app.id), str(self.admin.id)) notice.assert_not_called() self.assertTrue(notice.call_args.args[1]) def test_notice_without_email_configuration_does_not_send(self, _registry): with patch('users.serializers.user_manage_ext.SystemSetting.objects') as setting, \ patch('users.serializers.user_manage_ext.send_mail') as mail: setting.filter.return_value.first.return_value = None self.assertFalse(send_activation_notice(self.admin, True)) mail.assert_not_called() def test_notice_contains_result_and_reason(self, _registry): from types import SimpleNamespace with patch('users.serializers.user_manage_ext.SystemSetting.objects') as setting, \ patch('users.serializers.user_manage_ext.EmailBackend'), \ patch('users.serializers.user_manage_ext.send_mail', return_value=1) as mail: setting.filter.return_value.first.return_value = SimpleNamespace(meta={ 'email_host': 'smtp.example.invalid', 'email_port': 25, 'from_email': 'sender@example.com'}) self.assertTrue(send_activation_notice(self.admin, False, '手机号不符')) self.assertIn('未通过', mail.call_args.args[0]) self.assertIn('手机号不符', mail.call_args.args[1]) self.assertEqual(mail.call_args.kwargs['recipient_list'], [self.admin.email]) self.assertTrue(send_activation_notice(self.admin, True)) self.assertIn('审核通过', mail.call_args.args[0]) def test_mail_failure_does_not_change_audit_outcome(self, _registry): from types import SimpleNamespace with patch('users.serializers.user_manage_ext.SystemSetting.objects') as setting, \ patch('users.serializers.user_manage_ext.EmailBackend'), \ patch('users.serializers.user_manage_ext.send_mail', side_effect=RuntimeError('mock SMTP error')): setting.filter.return_value.first.return_value = SimpleNamespace(meta={'email_host': 'smtp.example.invalid'}) self.assertFalse(send_activation_notice(self.admin, True)) def test_resource_user_lists_exclude_unapproved_and_disabled(self, _registry): allowed = User.objects.create(username='allowed', nick_name='已通过', role='USER') UserActivationApplication.objects.create(user=allowed, status=ActivationStatus.APPROVED) direct = User.objects.create(username='direct', nick_name='直接激活', role='USER') for status in (ActivationStatus.PENDING, ActivationStatus.REJECTED): user = User.objects.create(username=status, nick_name=status, role='USER', is_active=True) UserActivationApplication.objects.create(user=user, status=status) User.objects.create(username='disabled', nick_name='停用', role='USER', is_active=False) members = UserManageSerializer().get_user_members('default') self.assertEqual({str(u['id']) for u in members}, {str(allowed.id), str(direct.id)}) for entries in (UserManageSerializer().get_user_list('default'), UserManageSerializer().get_all_user_list()): self.assertEqual({str(u['id']) for u in entries}, {str(allowed.id), str(direct.id), str(self.admin.id)}) def test_resource_authorization_cannot_use_hidden_user_id(self, _registry): RegisterSerializer.register(self.payload) user = User.objects.get(username=self.payload['username']) for kind in ('APPLICATION', 'KNOWLEDGE', 'TOOL', 'MODEL'): with self.subTest(kind=kind), self.assertRaises(AppApiException): UserResourcePermissionSerializer(data={'workspace_id': 'default', 'user_id': str(user.id), 'auth_target_type': kind}).is_valid(raise_exception=True) with self.subTest(kind=kind), self.assertRaises(AppApiException): ResourceUserPermissionSerializer(data={'workspace_id': 'default', 'target': 'test-target', 'auth_target_type': kind}).edit([{'user_id': str(user.id), 'permission': 'VIEW'}]) def test_direct_activation_schedules_notice(self, _registry): with patch('users.serializers.user_manage_ext.send_activation_notice') as notice: with self.captureOnCommitCallbacks(execute=True): UserManageSerializer().save({**self.payload, 'pending_activation': False}, str(self.admin.id)) notice.assert_not_called() self.assertTrue(notice.call_args.args[1]) def test_resource_user_sql_filters_all_four_modules(self, _registry): from django.db import connection from common.db.search import compiler_queryset allowed = User.objects.create(username='allowed_sql', nick_name='SQL已通过', role='USER') UserActivationApplication.objects.create(user=allowed, status=ActivationStatus.APPROVED) for status in (ActivationStatus.PENDING, ActivationStatus.REJECTED): user = User.objects.create(username='sql_'+status, nick_name='SQL'+status, role='USER') UserActivationApplication.objects.create(user=user, status=status) User.objects.create(username='disabled_sql', nick_name='SQL停用', role='USER', is_active=False) for kind in ('APPLICATION', 'KNOWLEDGE', 'TOOL', 'MODEL'): with self.subTest(kind=kind): serializer = ResourceUserPermissionSerializer(data={ 'workspace_id': 'default', 'target': 'test', 'auth_target_type': kind}) serializer.is_valid(raise_exception=True) query = serializer.get_queryset({'permission': []}, False)['user_query_set'] clause, params = compiler_queryset(query) with connection.cursor() as cursor: cursor.execute('SELECT u.id FROM "user" u ' + clause, params) ids = {str(row[0]).replace('-', '') for row in cursor.fetchall()} self.assertEqual(ids, {str(allowed.id).replace('-', '')})