UnisKB/apps/users/tests.py

419 lines
26 KiB
Python

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('-', '')})