def immutable_group_with_child():
"""
:return: {}
"""
groups_id = deque([], maxlen=5)
data = {"$name": random_string(), "$parentGroupId": root_group_id()}
response_parent = send_request.post(mgr.groups, data)
groups_id.appendleft(response_parent.json()['groupId'])
data_child = {"$name": random_string(), "$parentGroupId": groups_id[0]}
response_child = send_request.post(mgr.groups, data_child)
response = send_request.get(mgr.groups, id_to_url=groups_id[0])
groups_id.appendleft(response_child.json()['groupId'])
yield response.json()
for i in groups_id:
send_request.delete(mgr.groups, id_to_url=i)
def _user(role_name=None, enabled=True):
role_name = "ROOT" if role_name is None else role_name
role_id = get_role_id(role_name)
user_group_and_role = make_user_group_roles({root_group_id(): role_id})
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$password": "******",
"$roleId": role_id,
"$agentId": random_string(),
"$ADlogin": random_string(),
"$pname": random_string(),
"$email": random_string() + '@.com.ua',
"$phone": str(random.randint(11111, 99999999)),
"$fax": random_string(),
"$userGroupRoles": user_group_and_role,
"$enabled": enabled
}
response = send_request.post(mgr.users, data)
user = response.json()
user['dateCreate'] = round(user['dateCreate'] / 1000) * 1000
def fin():
send_request.delete(mgr.users, id_to_url=user['userId'])
request.addfinalizer(fin)
return user
def test_add_role_without_group(self):
data = {"$name": random_string(), "$groupId": None}
response = send_request.post(mgr.roles, data)
expected_response = {
'ADM_VALIDATION_ROLE_GROUP_EMPTY': 'Role group not specified'
}
assert (response.status_code, response.json()) == (400,
expected_response)
def immutable_role(immutable_group_with_child):
data = {
"$name": random_string(),
"$groupId": immutable_group_with_child['groupId']
}
response = send_request.post(mgr.roles, data)
yield response.json()
send_request.delete(mgr.roles, id_to_url=response.json()['roleId'])
def test_addGroup_without_name(self):
data = {"$name": None, "$parentGroupId": root_group_id()}
response = send_request.post(mgr.groups, data)
excepted_response = {
'ADM_VALIDATION_GROUP_NAME': 'Group name not specified'
}
assert (response.status_code, response.json()) == (400,
excepted_response)
def test_add_role_with_first_root_child(self, immutable_group_with_child):
data = {
"$name": random_string(),
"$groupId": immutable_group_with_child['groupId']
}
response = send_request.post(mgr.roles, data)
assert equal_schema(response.json(),
response.expected) and response.status_code == 201
def test_get_token_with_wrong_credentials(self):
data = {"$principal": random_string(), "$credential": random_string()}
response = send_request.post(AuthServer.token, data)
expected_result = {
'PRINCIPAL_NOT_FOUND': 'Not authorized. No user found'
}
assert (response.status_code, response.json()) == (500,
expected_result)
def test_addGroup_without_group(self):
data = {"$name": random_string(), "$parentGroupId": None}
response = send_request.post(mgr.groups, data)
excepted_response = {
'COMMON_REQUESTED_RESOURCES_NOT_FOUND':
'GROUP by groupId=null not found'
}
assert (response.status_code, response.json()) == (400,
excepted_response)
def test_get_token_for_root(self):
credentials = cfg.credentials
data = {
"$principal": credentials['principal'],
"$credential": credentials['credential']
}
response = send_request.post(AuthServer.token, data)
assert (response.status_code,
"X-Smiddle-Auth-Token") == (200, response.json()['name'])
def test_add_role_with_existing_name(self, role):
existing_name = role['name']
data = {"$name": existing_name, "$groupId": role['group']['groupId']}
response = send_request.post(mgr.roles, data)
expected_response = {
'COMMON_ENTITY_WITH_SUCH_FIELD_EXISTS': 'Name is not unique'
}
assert (response.status_code, response.json()) == (409,
expected_response)
def test_get_token_for_disabled_user(self, add_user_with_role):
user = add_user_with_role("ROOT", enabled=False)
data = {"$principal": user['login'], "$credential": "qwerty"}
response = send_request.post(AuthServer.token, data)
expected_response = {
'USER_DISABLED': 'Account %s disabled.' % user['login']
}
assert (response.status_code, response.json()) == (500,
expected_response)
def test_get_token_for_user_without_credentials(self, immutable_user):
data = {"$principal": immutable_user['login'], "$credential": "qwerty"}
response = send_request.post(AuthServer.token, data)
expected_response = {
'BAD_CREDENTIALS': 'Not authorized. Wrong credential.'
}
assert (response.json(),
response.status_code) == (expected_response,
response.status_code)
def test_get_token_with_empty_credentials(self):
data = {"principal": None, "credential": None}
response = send_request.post(AuthServer.token, data)
expected_result = {
'PRINCIPAL_EMPTY': 'principal is empty',
'CREDENTIALS_EMPTY': 'credentials is empty'
}
assert (response.status_code, response.json()) == (400,
expected_result)
def test_addGroup_with_unknown_parentGroupId(self):
random_group_id = random_string()
data = {"$name": random_string(), "$parentGroupId": random_group_id}
response = send_request.post(mgr.groups, data)
expected_response = {
'COMMON_REQUESTED_RESOURCES_NOT_FOUND':
'GROUP by groupId=%s not found' % random_group_id
}
assert (response.status_code, response.json()) == (400,
expected_response)
def test_add_role_with_unknown_group(self):
unknown_group_id = random_string()
data = {"$name": random_string(), "$groupId": unknown_group_id}
response = send_request.post(mgr.roles, data)
expected_response = {
'ADM_VALIDATION_GROUP_NOT_FOUND':
'Group by the following group id not found: %s' % unknown_group_id
}
assert (response.status_code, response.json()) == (400,
expected_response)
def test_add_role_without_name(self, immutable_group_with_child):
data = {
"$name": None,
"$groupId": immutable_group_with_child['groupId']
}
response = send_request.post(mgr.roles, data)
expected_response = {
'ADM_VALIDATION_ROLE_NAME': 'Role name not specified'
}
assert (response.status_code, response.json()) == (400,
expected_response)
def test_get_token_for_deleted_user(self, immutable_deleted_user):
data = {
"$principal": immutable_deleted_user['login'],
"$credential": "qwerty"
}
response = send_request.post(AuthServer.token, data)
expected_response = {
'PRINCIPAL_NOT_FOUND': 'Not authorized. No user found'
}
assert (response.json(),
response.status_code) == (expected_response,
response.status_code)
def test_add_role_with_templateRole(self):
data = {
"$name": random_string(),
"$groupId": root_group_id(),
"$templateRole": {
"roleId": root_role_id()
}
}
response = send_request.post(mgr.roles, data)
assert (response.status_code,
response.json()['templateRole']['roleId']) == (201,
root_role_id())
def test_add_user_with_required_fields(self, immutable_role,
userGroupRoles):
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$roleId": immutable_role['roleId'],
"$userGroupRoles": userGroupRoles
}
response = send_request.post(mgr.users, data)
assert equal_schema(response.json(),
response.expected) and response.status_code == 201
def test_add_user_without_groupId(self, immutable_role):
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$groupId": None,
"$roleId": immutable_role['roleId']
}
response = send_request.post(mgr.users, data)
expected_response = {
'ADM_VALIDATION_USER_USER_GROUP_ROLES': 'User group roles is empty'
}
assert (response.status_code, response.json()) == (400,
expected_response)
def test_add_user_without_groupId_roleId(self, userGroupRoles):
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$userGroupRoles": userGroupRoles,
"$roleId": None
}
response = send_request.post(mgr.users, data)
expected_response = {
'ADM_VALIDATION_ROLES_NOT_FOUND':
'Roles by the following role ids not found: null'
}
assert (response.status_code, response.json()) == (400,
expected_response)
def test_add_user_with_existing_login(self, immutable_role, userGroupRoles,
immutable_user):
existing_login = immutable_user['login']
data = {
"$login": existing_login,
"$fname": random_string(),
"$lname": random_string(),
"$userGroupRoles": userGroupRoles,
"$roleId": immutable_role['roleId']
}
response = send_request.post(mgr.users, data)
expected_response = {
'COMMON_ENTITY_WITH_SUCH_FIELD_EXISTS': 'Login is not unique'
}
assert (response.status_code, response.json()) == (409,
expected_response)
def test_signin_with_token_check_login(self, add_user_with_role):
user = add_user_with_role('ADMINISTRATOR')
data = {
"$principal": user['login'],
"$credential": "qwerty",
"$sessionLiveTimeSec": 300
}
response_auth = send_request.post(AuthServer.token, data)
response_auth = response_auth.json()
headers = {
'content-type': "application/json;charset=UTF-8",
response_auth['name']: response_auth['token']
}
response_current_account = send_request.get(mgr.account,
headers=headers)
assert user['login'] == response_current_account.json()['login']
def test_add_user_with_role_in_userGroupRoles_which_not_exist_in_roleId(
self, userGroupRoles):
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$roleId": root_role_id(),
"$userGroupRoles": userGroupRoles
}
response = send_request.post(mgr.users, data)
expected_response = {
'ADM_VALIDATION_USER_NOT_ALLOWED_ROLE_IN_GROUP':
'Roles in groups by the following role ids not allowed: %s' %
userGroupRoles[0]['roles'][0]['roleId']
}
assert (response.status_code, response.json()) == (400,
expected_response)
def test_add_user_with_all_fields(self, immutable_role, userGroupRoles):
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$roleId": immutable_role['roleId'],
"$agentId": random_string(),
"$ADlogin": random_string(),
"$pname": random_string(),
"$email": random_string() + '@.com.ua',
"$phone": str(random.randint(11111, 99999999)),
"$fax": random_string(),
"$userGroupRoles": userGroupRoles
}
response = send_request.post(mgr.users, data)
assert equal_schema(response.json(),
response.expected) and response.status_code == 201
def test_add_user_check_userGroupRoles(self, immutable_role,
userGroupRoles):
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$roleId": immutable_role['roleId'],
"$userGroupRoles": userGroupRoles
}
response = send_request.post(mgr.users, data)
response_user_group_roles = response.json()['userGroupRoles']
response_group_roles_set = set(
response_user_group_roles[0]['group'].items()
| response_user_group_roles[0]['roles'][0].items())
added_user_group_roles = set(userGroupRoles[0]['roles'][0].items()
| userGroupRoles[0]['group'].items())
assert added_user_group_roles.issubset(response_group_roles_set)
def test_add_user_with_existing_phone(self, immutable_role, userGroupRoles,
immutable_user):
existing_phone = immutable_user['phone']
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$userGroupRoles": userGroupRoles,
"$roleId": immutable_role['roleId'],
"$phone": existing_phone
}
response = send_request.post(mgr.users, data)
expected_response = {
'COMMON_EXCEPTION':
'Not deleted user with phone = %s already exist!' % existing_phone
}
assert (response.status_code, response.json()) == (500,
expected_response)
def test_add_user_with_existing_agentId(self, immutable_role,
userGroupRoles, immutable_user):
existing_agent_id = immutable_user['agentId']
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$userGroupRoles": userGroupRoles,
"$roleId": immutable_role['roleId'],
"$agentId": existing_agent_id
}
response = send_request.post(mgr.users, data)
expected_response = {
'COMMON_ENTITY_WITH_SUCH_FIELD_EXISTS':
'AGENT ID =%s already exists' % existing_agent_id
}
assert (response.status_code, response.json()) == (409,
expected_response)
def immutable_user(userGroupRoles, immutable_role):
data = {
"$login": random_string(),
"$fname": random_string(),
"$lname": random_string(),
"$roleId": immutable_role['roleId'],
"$agentId": random_string(),
"$ADlogin": random_string(),
"$pname": random_string(),
"$email": random_string() + '@.com.ua',
"$phone": str(random.randint(11111, 99999999)),
"$fax": random_string(),
"$userGroupRoles": userGroupRoles
}
response = send_request.post(mgr.users, data)
user = response.json()
user['dateCreate'] = round(user['dateCreate'] / 1000) * 1000
yield user
send_request.delete(mgr.users, id_to_url=response.json()['userId'])
def test_add_user_without_login_fname_lname(self, immutable_role,
userGroupRoles):
data = {
"$login": None,
"$fname": None,
"$lname": None,
"$userGroupRoles": userGroupRoles,
"$roleId": immutable_role['roleId']
}
response = send_request.post(mgr.users, data)
expected_response = {
'ADM_VALIDATION_USER_LAST_NAME_LENGTH':
'Last name length from 1 to 256',
'ADM_VALIDATION_USER_FIRST_NAME_LENGTH':
'First name length from 1 to 256',
'ADM_VALIDATION_USER_LOGIN_LENGTH': 'Login length from 1 to 104'
}
assert (response.status_code, response.json()) == (400,
expected_response)
