419 lines
26 KiB
Python
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('-', '')})
|