def test_alter_admin(self, mock_sms_token):
mock_sms_token.side_effect = [
{
'mobile': 'mobile_1'
},
{
'mobile': 'mobile_2'
},
]
old_admin = User.create_user('old_admin', 'old_admin')
old_admin.is_boss = True
old_admin.mobile = 'mobile_1'
old_admin.save()
new_admin = User.create_user('new_admin', '')
new_admin.mobile = 'mobile_2'
new_admin.save()
res = self.client.json_patch(reverse('siteapi:alter_admin'),
data={
'old_admin_sms_token': 'test',
'new_admin_sms_token': 'test'
})
self.assertEqual(res.status_code, 200)
old_admin = User.objects.get(username='******')
new_admin = User.objects.get(username='******')
self.assertFalse(old_admin.is_boss)
self.assertTrue(new_admin.is_boss)
def setUp(self):
super().setUp()
root = Dept.valid_objects.get(uid='root')
level_1 = Dept.valid_objects.create(uid='level_1',
name='level_1',
parent=root)
Dept.valid_objects.create(uid='level_2-1',
name='level_2-1',
parent=level_1,
order_no=2)
Dept.valid_objects.create(uid='level_2-2',
name='level_2-2',
parent=level_1,
order_no=1)
user = User.create_user('employee', 'employee')
DeptMember.valid_objects.create(user=user, owner=root)
user = User.create_user('employee_2', 'employee_2')
root = Group.valid_objects.get(uid='root')
role_group = Group.valid_objects.create(uid='role_group_1',
name='role_group_1',
parent=root,
accept_user=False)
role_1 = Group.valid_objects.create(uid='role_1',
name='role_1',
parent=role_group,
order_no=2)
Group.valid_objects.create(uid='role_2',
name='role_2',
parent=role_group,
order_no=1)
GroupMember.valid_objects.create(user=user, owner=role_1)
def test_update_group_child_user(self):
url = reverse('siteapi:group_child_user', args=('role_1', ))
res = self.client.json_patch(url, data={
'subject': 'delete',
'user_uids': ['employee'],
})
expect = {'users': []}
self.assertEqual(res.json(), expect)
res = self.client.json_patch(url, data={
'subject': 'add',
'user_uids': ['employee_2', 'employee'],
})
expect = ['employee_2', 'employee']
self.assertEqual([user['username'] for user in res.json()['users']], expect)
res = self.client.json_patch(url, data={
'subject': 'sort',
'user_uids': ['employee', 'employee_2'],
})
expect = ['employee', 'employee_2']
self.assertEqual([user['username'] for user in res.json()['users']], expect)
User.create_user('employee_3', 'employee_3')
res = self.client.json_patch(url,
data={
'subject': 'override',
'user_uids': ['employee_3', 'employee_2', 'employee'],
})
expect = ['employee_3', 'employee_2', 'employee']
self.assertEqual([user['username'] for user in res.json()['users']], expect)
def test_valid_username_unique(self):
user = User.create_user('user', 'user')
with self.assertRaises(ValidationError):
User.create_user('user', 'user')
user.name = 'name'
user.save()
user.delete()
User.create_user('user', 'user')
def setUp(self):
super(DeptTestCase, self).setUp()
root = Dept.valid_objects.get(uid='root')
level_1 = Dept.valid_objects.create(uid='level_1', name='level_1', parent=root)
Dept.valid_objects.create(uid='level_2-1', name='level_2-1', parent=level_1, order_no=2)
Dept.valid_objects.create(uid='level_2-2', name='level_2-2', parent=level_1, order_no=1)
user = User.create_user('employee', 'employee')
DeptMember.valid_objects.create(user=user, owner=root)
user = User.create_user('employee_2', 'employee_2')
def setUp(self):
super(GroupTestCase, self).setUp()
root = Group.valid_objects.get(uid='root')
self.root = root
role_group = Group.valid_objects.create(uid='role_group_1', name='role_group_1', parent=root, accept_user=False)
role_1 = Group.valid_objects.create(uid='role_1', name='role_1', parent=role_group, order_no=2)
Group.valid_objects.create(uid='role_2', name='role_2', parent=role_group, order_no=1)
user = User.create_user('employee', 'employee')
GroupMember.valid_objects.create(user=user, owner=role_1)
user = User.create_user('employee_2', 'employee_2')
def setUp(self):
super().setUp()
employee = User.create_user('employee', 'employee')
self.employee = self.login_as(employee)
self._employee = employee
manager = User.create_user('manager', 'manager')
self.manager = self.login_as(manager)
self._manager = manager
group = Group.objects.create(name='test')
ManagerGroup.objects.create(group=group, scope_subject=2, apps=['app', 'demo'])
GroupMember.objects.create(owner=group, user=User.objects.get(username='******'))
def test_group_user_search(self):
role_group = Group.valid_objects.create(uid='group_3',
name='group_3',
parent=self.root,
accept_user=False)
role_3 = Group.valid_objects.create(uid='role_3',
name='role_3',
parent=role_group,
order_no=3)
user = User.create_user('zhangsan', 'zhangsan')
user.name = '张三'
user.email = '*****@*****.**'
user.mobile = '13412341233'
user.created = '2019-01-01T00:00:00+08:00'
user.last_active_time = '2019-02-01T00:00:00+08:00'
user.save()
GroupMember.valid_objects.create(user=user, owner=role_3)
user2 = User.create_user('zhangsi', 'zhangsi')
user2.name = '张四'
user2.email = '*****@*****.**'
user2.mobile = '13412341234'
user2.created = '2019-03-01T00:00:00+08:00'
user2.last_active_time = '2019-04-01T00:00:00+08:00'
user2.save()
GroupMember.valid_objects.create(user=user2, owner=role_3)
user3 = User.create_user('lisan', 'lisan')
user3.name = '李三'
user3.email = '*****@*****.**'
user3.mobile = '13412341235'
user3.created = '2019-05-01T00:00:00+08:00'
user3.last_active_time = '2019-06-01T00:00:00+08:00'
user3.save()
GroupMember.valid_objects.create(user=user3, owner=role_3)
user4 = User.create_user('lisi', 'lisi')
user4.name = '李四'
user4.email = '*****@*****.**'
user4.mobile = '13412341236'
user4.created = '2019-07-01T00:00:00+08:00'
user4.last_active_time = '2019-08-01T00:00:00+08:00'
user4.save()
GroupMember.valid_objects.create(user=user4, owner=role_3)
test_list = [{'email':'12341234'}, {'name':'张'}, {'username':'******'}, {'mobile':'12341234'}, \
{'before_created':'2019-06-01T00:00:00+08:00'}, {'after_created':'2019-06-01T00:00:00+08:00'}, \
{'before_last_active_time':'2019-03-01T00:00:00+08:00'}, \
{'after_last_active_time':'2019-03-01T00:00:00+08:00'}]
result_list = []
for test in test_list:
res = self.client.get(reverse('siteapi:node_child_user',
args=('g_role_3', )),
data=test)
result_list.append(res.json()['count'])
expect = [1, 2, 2, 1, 3, 1, 1, 3]
self.assertEqual(result_list, expect)
def test_send_sms_to_update_mobile(self, mock_redis_set, mock_redis_get, mock_redis_delete, mock_send_sms,
mock_gen_code):
mock_redis_get.return_value = SMS_CODE
mock_redis_set.return_value = True
mock_redis_delete.return_value = None
mock_send_sms.return_value = True
mock_gen_code.return_value = SMS_CODE
url = reverse('infra:sms', args=('update_mobile', ))
res = self.anonymous.json_post(reverse('infra:sms', args=('update_mobile', )), data={'mobile': MOBILE})
self.assertEqual(res.status_code, 401)
user = User.create_user(username='******', password='******')
self.client = self.login_as(user)
new_mobile = '18810041004'
res = self.client.json_post(url, data={'mobile': MOBILE, 'password': '******'})
expect = {'mobile': ['existed']}
self.assertEqual(expect, res.json())
self.assertEqual(res.status_code, 400)
res = self.client.json_post(url, data={'mobile': new_mobile, 'password': '******'})
expect = {'password': ['invalid']}
self.assertEqual(expect, res.json())
self.assertEqual(res.status_code, 400)
self.client = self.login_as(user)
res = self.client.json_post(url, data={'mobile': new_mobile, 'password': '******'})
self.assertEqual(res.status_code, 201)
res = self.client.get(url, data={'mobile': new_mobile, 'code': SMS_CODE})
self.assertIn('sms_token', res.json())
self.assertEqual(res.status_code, 200)
def test_ucenter_sub_account(self):
res = self.create_sub_account_perm()
perm = Perm.objects.get(uid=res.json()['uid'])
employee = User.create_user(username='******', password='******')
client = self.login_as(employee)
res = client.get(reverse('siteapi:ucenter_sub_account_list'))
self.assertEqual(res.json()['count'], 0)
res = client.get(reverse('siteapi:ucenter_app_list'))
self.assertEqual(res.json()['count'], 0)
UserPerm.objects.create(owner=employee, perm=perm).permit()
res = client.get(reverse('siteapi:ucenter_sub_account_list'))
self.assertEqual(res.json()['count'], 1)
sub_account_test = res.json()['results'][0]
sub_account_test.pop('uuid')
sub_account_except = {
'domain': 'www.longguikeji.com',
'username': '******',
'password': '******'
}
self.assertEqual(sub_account_except, sub_account_test)
res = client.get(reverse('siteapi:ucenter_app_list'))
self.assertEqual(res.json()['count'], 1)
app_test = [item['uid'] for item in res.json()['results']]
app_expect = ['lg']
self.assertEqual(app_expect, app_test)
res = client.get(reverse('siteapi:ucenter_sub_account_list'),
data={'domain': 'www.longguikeji.com'})
self.assertEqual(res.json()['count'], 1)
res = client.get(reverse('siteapi:ucenter_sub_account_list'),
data={'domain': 'arkid.longguikeji.com'})
self.assertEqual(res.json()['count'], 0)
def setUp(self):
super(DeptPermTestCase, self).setUp()
root = Dept.valid_objects.get(uid='root')
level_1 = Dept.valid_objects.create(uid='l1', name='l1', parent=root)
Dept.valid_objects.create(uid='l11', name='l11', parent=level_1, order_no=2)
Dept.valid_objects.create(uid='l12', name='l12', parent=level_1, order_no=1)
user = User.create_user('employee', 'employee')
DeptMember.valid_objects.create(user=user, owner=root)
user = User.create_user('employee_2', 'employee_2')
token = self.client.post(reverse('siteapi:user_login'), data={
'username': '******',
'password': '******'
}).json()['token']
self.employee = APIClient()
self.employee.credentials(HTTP_AUTHORIZATION='Token ' + token)
def test_dept_union_unique(self):
user = User.create_user('user', 'user')
dept = Dept.valid_objects.create(uid='dept')
DeptMember.valid_objects.create(owner=dept, user=user)
with self.assertRaises(db.utils.IntegrityError):
DeptMember.valid_objects.create(owner=dept, user=user)
def test_group_union_unique(self):
user = User.create_user('user', 'user')
group = Group.valid_objects.create(uid='group')
GroupMember.valid_objects.create(owner=group, user=user)
with self.assertRaises(db.utils.IntegrityError):
GroupMember.valid_objects.create(owner=group, user=user)
def test_ding_login(self, mock_auth_code):
mock_auth_code.return_value = "ding_uid"
client = APIClient()
res = client.post(reverse('siteapi:ding_login'), data={'code': 'ding_code'})
expect = {'code': ["this account hasn't registered"]}
self.assertEqual(res.json(), expect)
self.assertEqual(res.status_code, 400)
user = User.create_user(username='******', password='')
DingUser.valid_objects.create(user=user, uid='ding_uid')
res = client.post(reverse('siteapi:ding_login'), data={'code': 'ding_code'})
self.assertEqual(res.status_code, 200)
self.assertIn('token', res.json())
def test_update_self_mobile(self, mock_check_sms_token):
mock_check_sms_token.side_effect = [
{
'mobile': 'mobile_1'
},
{
'mobile': 'mobile_2'
},
{
'mobile': 'mobile_1'
},
{
'mobile': 'mobile_3'
},
]
employee_1 = User.create_user('employee_1', 'employee_1')
employee_1.mobile = 'mobile_1'
employee_1.save()
client_1 = self.login('employee_1', 'employee_1')
employee_2 = User.create_user('employee_2', 'employee_2')
employee_2.mobile = 'mobile_2'
employee_2.save()
res = client_1.json_patch(reverse('siteapi:ucenter_mobile'),
data={
'old_mobile_sms_token': 'any',
'new_mobile_sms_token': 'any'
})
self.assertEqual(res.json(), {'new_mobile': ['has been used']})
res = client_1.json_patch(reverse('siteapi:ucenter_mobile'),
data={
'old_mobile_sms_token': 'any',
'new_mobile_sms_token': 'any'
})
expect = {'new_mobile': 'mobile_3'}
self.assertEqual(res.json(), expect)
def test_email_link(self, mock_hgetall):
'''
更新邮箱测试
'''
mock_hgetall.return_value = {"email": "*****@*****.**", "username": "******", "name": ""}
user = User.create_user(username='******', password='******')
user.mobile = '18812341234'
user.email = '*****@*****.**'
user.save()
client = self.login_as(user)
url = reverse('infra:email', args=('update_email', ))
update_email_response = client.get(url, data={'email_token': 'test_email_token'})
self.assertEqual(update_email_response.status_code, 200)
def get_users_from_uids(user_uids):
'''
根据user uid按顺序返回user list
:param list user_uids:
'''
try:
users = User.get_from_pks(pks=user_uids,
pk_name='username',
raise_exception=True,
is_del=False)
except ObjectDoesNotExist as error:
bad_uid = error.args[0]
raise ValidationError(
{'user_uids': ['user:{} does not exist'.format(bad_uid)]})
return users
def get_object(self):
'''
filter the boss
'''
admins = User.valid_objects.filter(is_boss=True)
if admins.count() > 1:
raise AssertionError(
"there more than one super manager: {}".format(
admin.username for admin in admins))
if admins.count() == 0:
admin = User.create_user('manager', 'manager')
admin.is_boss = True
admin.name = "请尽快修改密码或更改主管理员"
admin.save()
else:
admin = admins.first()
return admin
def test_login(self, mock_check_sms_token):
mock_check_sms_token.side_effect = [{'mobile': '18812341234'}]
user = User.create_user(username='******', password='******')
user.mobile = '18812341234'
user.private_email = '*****@*****.**'
user.save()
client = APIClient()
res = client.get(reverse('siteapi:user_self_perm'))
self.assertEqual(res.status_code, 401)
res = client.post(reverse('siteapi:user_login'), data={'username': '******', 'password': '******'})
self.assertEqual(res.status_code, 200)
res = client.post(reverse('siteapi:user_login'), data={'private_email': '*****@*****.**', 'password': '******'})
self.assertEqual(res.status_code, 200)
res = client.post(reverse('siteapi:user_login'), data={'mobile': '18812341234', 'sms_token': 'mock'})
self.assertEqual(res.status_code, 200)
user = User.objects.get(username='******')
self.assertIsNotNone(user.last_active_time)
self.assertTrue(user.is_settled)
client.credentials(HTTP_AUTHORIZATION='Token ' + res.json()['token'])
res = client.get(reverse('siteapi:user_self_perm'))
self.assertEqual(res.status_code, 200)
res = client.post(reverse('siteapi:user_login'), data={'username': '******', 'password': '******'})
self.assertEqual(res.json()['perms'], ['system_oneid_all', 'system_ark-meta-server_all'])
# test login failed because of account_config
email_config = EmailConfig.get_current()
email_config.is_valid = False
email_config.save()
res = client.post(reverse('siteapi:user_login'), data={'private_email': '*****@*****.**', 'password': '******'})
self.assertEqual(res.status_code, 400)
mobile_config = SMSConfig.get_current()
mobile_config.is_valid = False
mobile_config.save()
res = client.post(reverse('siteapi:user_login'), data={'mobile': '18812341234', 'sms_token': 'mock'})
self.assertEqual(res.status_code, 400)
def refresh_visibility_scope(self):
'''
更新可见范围
'''
old_node_scope = set(self.node_scope)
old_user_scope = set(self.user_scope)
valid_node_scope = set(node.node_uid for node in self.retrieve_nodes(old_node_scope)) # pylint: disable=no-member
from oneid_meta.models import User # pylint: disable=import-outside-toplevel
valid_user_scope = set(user.username for user in User.get_from_pks(old_user_scope, pk_name='username'))
if valid_node_scope != old_node_scope:
self.node_scope = list(valid_node_scope)
self.save(update_fields=['node_scope'])
if valid_user_scope != old_user_scope:
self.user_scope = list(valid_user_scope)
self.save(update_fields=['user_scope'])
def setUp(self):
self.rdb_executer = RDBExecuter()
self.user = User.create_user('user', 'user')
self.root = Dept.valid_objects.get(uid='root')
self.dept_1 = Dept.valid_objects.create(uid='1', parent=self.root)
self.dept_1_1 = Dept.valid_objects.create(uid='1_1',
parent=self.dept_1)
self.dept_1_2 = Dept.valid_objects.create(uid='1_2',
parent=self.dept_1)
self.dept_1_1_1 = Dept.valid_objects.create(uid='1_1_1',
parent=self.dept_1_1)
self.dept_1_1_2 = Dept.valid_objects.create(uid='1_1_2',
parent=self.dept_1_1)
self.dept_1_1_3 = Dept.valid_objects.create(uid='1_1_3',
parent=self.dept_1_1)
self.dept_2 = Dept.valid_objects.create(uid='2', parent=self.root)
self.dept_2_1 = Dept.valid_objects.create(uid='2_1',
parent=self.dept_2)
self.dept_2_2 = Dept.valid_objects.create(uid='2_2',
parent=self.dept_2)
self.front_walker_depts = [
self.root,
self.dept_1,
self.dept_1_1,
self.dept_1_1_1,
self.dept_1_1_2,
self.dept_1_1_3,
self.dept_1_2,
self.dept_2,
self.dept_2_1,
self.dept_2_2,
]
self.perm = Perm.valid_objects.create(uid='perm')
for dept in self.front_walker_depts:
DeptPerm.valid_objects.create(owner=dept, perm=self.perm)
def test_update_dept_child_user(self):
url = reverse('siteapi:dept_child_user', args=('root', ))
res = self.client.json_patch(url, data={
'subject': 'delete',
'user_uids': ['employee'],
})
expect = {'users': []}
self.assertEqual(res.json(), expect)
res = self.client.json_patch(url, data={
'subject': 'add',
'user_uids': ['employee_2', 'employee'],
})
expect = ['employee_2', 'employee']
self.assertEqual([user['username'] for user in res.json()['users']], expect)
res = self.client.json_patch(url, data={
'subject': 'sort',
'user_uids': ['employee', 'employee_2'],
})
expect = ['employee', 'employee_2']
self.assertEqual([user['username'] for user in res.json()['users']], expect)
User.create_user('employee_3', 'employee_3')
res = self.client.json_patch(url,
data={
'subject': 'override',
'user_uids': ['employee_3', 'employee_2', 'employee'],
})
expect = ['employee_3', 'employee_2', 'employee']
self.assertEqual([user['username'] for user in res.json()['users']], expect)
# test batch move out
Dept.objects.create(uid='another', name='another')
self.client.json_patch(url,
data={
'subject': 'move_out',
'user_uids': ['employee_3', 'employee_2'],
'dept_uids': ['another']
})
res = self.client.get(url)
expect = set(['employee'])
self.assertEqual(
set([user['username'] for user in res.json()['results']]), # pylint:disable=consider-using-set-comprehension
expect,
)
res = self.client.get(reverse('siteapi:dept_child_user', args=('another', )))
expect = set(['employee_3', 'employee_2'])
self.assertEqual(expect, set([user['username'] for user in res.json()['results']])) # pylint:disable=consider-using-set-comprehension
# test batch move inpalce
res = self.client.json_patch(reverse('siteapi:dept_child_user', args=('another', )),
data={
'subject': 'move_out',
'user_uids': ['employee_3', 'employee_2'],
'dept_uids': ['another'],
})
res = self.client.get(reverse('siteapi:dept_child_user', args=('another', )))
expect = set(['employee_3', 'employee_2'])
self.assertEqual(expect, set([user['username'] for user in res.json()['results']])) # pylint:disable=consider-using-set-comprehension
def test_send_email(self, mock_send_email, mock_redis):
mock_send_email.delay.return_value = None
mock_Redis = mock.Mock() # pylint: disable=invalid-name
mock_Redis.get.return_value = EMAIL.encode()
mock_Redis.set.return_value = True
mock_redis.Redis.return_value = mock_Redis
res = self.anonymous.json_post(reverse('infra:email',
args=('register', )),
data={'email': EMAIL})
self.assertEqual(res.status_code, 201)
res = self.anonymous.get(reverse('infra:email', args=('register', )),
data={'email_token': EMAIL_TOKEN})
expect = {'email': EMAIL}
self.assertEqual(expect, res.json())
new_user = User.objects.create(username='******', private_email=EMAIL)
res = self.anonymous.json_post(reverse('infra:email',
args=('reset_password', )),
data={'email': EMAIL})
self.assertEqual(res.status_code, 201)
expect = {'email': EMAIL, 'username': '******', 'name': ''}
res = self.anonymous.get(reverse('infra:email',
args=('reset_password', )),
data={'email_token': EMAIL_TOKEN})
self.assertEqual(expect, res.json())
inviter = User.objects.create(username='******')
invitee = new_user
invitation = Invitation.objects.create(inviter=inviter,
invitee=invitee)
res = self.anonymous.json_post(reverse('infra:email',
args=('activate_user', )),
data={'key': invitation.key})
self.assertEqual(res.status_code, 201)
mock_Redis.hgetall.return_value = {
b'email': EMAIL.encode(),
b'key': invitation.key.encode()
}
mock_redis.Redis.return_value = mock_Redis
res = self.anonymous.get(reverse('infra:email',
args=('activate_user', )),
data={
'email_token': EMAIL_TOKEN
}).json()
self.assertIn('key', res)
res.pop('key')
expect = {'email': EMAIL, 'name': '', 'username': '******'}
self.assertEqual(expect, res)
# update_email
url = reverse('infra:email', args=('update_email', ))
res = self.anonymous.json_post(url, data={'email': EMAIL})
self.assertEqual(res.status_code, 401)
user_a = User.create_user(username='******', password='******')
self.employee = self.login_as(user_a)
res = self.employee.json_post(url,
data={
'email': EMAIL,
'password': '******'
})
self.assertEqual(res.status_code, 400)
expect = {'email': ['existed']}
self.assertEqual(res.json(), expect)
res = self.employee.json_post(url,
data={
'email': '18812341234',
'password': '******'
})
self.assertEqual(res.status_code, 400)
expect = {'password': ['invalid']}
self.assertEqual(expect, res.json())
res = self.employee.json_post(url,
data={
'email': '18812341234',
'password': '******'
})
self.assertEqual(res.status_code, 201)
mock_Redis.hgetall.return_value = {
b'email': b'18812341234',
b'username': b'a'
}
mock_redis.Redis.return_value = mock_Redis
res = self.employee.get(url, data={'email_token': EMAIL_TOKEN})
expect = {'email': '18812341234', 'username': '******', 'name': ''}
self.assertEqual(expect, res.json())
