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)