def set_up(self): with allure.step("send an admin login request"): admin_success_login = SendRequest( Login.get_test_case("test_login_with_admin_success")) with allure.step("Get admin token"): TestLogOutWithAdminSuccess.admin_token = admin_success_login.get_token()
def set_up(self): with allure.step("Send an admin login request"): admin_success_login = SendRequest( Login.get_test_case("test_login_with_admin_success")) with allure.step("Get admin login token"): TestAdminStatusLoggedIn.admin_token = admin_success_login.get_token( )
def test_login_with_banned_username(self): with allure.step('Send a login request with banned username'): login_with_banned_username = SendRequest( Login.get_test_case("test_login_with_banned_username")) with allure.step('Checking Err_msg'): allure.attach( "Err_msg contains: " + constants.ERR_MSG_WRONG_PASSWORD_OR_BANNED_USERNAME, "Expected:") allure.attach( "Err_msg: " + login_with_banned_username.get_err_msg(), "Actual:") assert constants.ERR_MSG_WRONG_PASSWORD_OR_BANNED_USERNAME in login_with_banned_username.get_err_msg( ) with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach("Ret: " + str(login_with_banned_username.get_ret()), "Actual:") assert login_with_banned_username.get_ret() == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_2), "Expected:") allure.attach( "Err_code: " + str(login_with_banned_username.get_err_code()), "Actual:") assert login_with_banned_username.get_err_code( ) == constants.ERR_CODE_2
def test_users_list_get_admin(self): with allure.step( "Send a get list request with role admin, page 1 and 10 per page" ): all_admin_list = SendRequest( UsersList.get_test_case("test_users_list_get_admin")) with allure.step('Checking if per page is less or equal to 10'): is_per_page_less_or_equal_10 = len( all_admin_list.get_users_list()) <= int(constants.PER_PAGE_10) allure.attach("Per page is less or equal to 10: True", "Expected:") allure.attach( "Per page is less or equal to 10: " + str(is_per_page_less_or_equal_10), "Actual:") assert is_per_page_less_or_equal_10 is True with allure.step('Checking if all users are admin'): is_all_users_admin = all_admin_list.is_all_users_admin() allure.attach("All users are admin: True", "Expected:") allure.attach("All users are admin: " + str(is_all_users_admin), "Actual:") assert is_all_users_admin is True with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach("Ret: " + str(all_admin_list.get_ret()), "Actual:") assert all_admin_list.get_ret() == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_0), "Expected:") allure.attach("Err_code: " + str(all_admin_list.get_err_code()), "Actual:") assert all_admin_list.get_err_code() == constants.ERR_CODE_0
def test_users_list_get_all(self): with allure.step( "Send a get list request with role all, page 1 and default 30 per page" ): all_users_list = SendRequest( UsersList.get_test_case("test_users_list_get_all")) with allure.step('Checking if per page is less or equal 30'): is_per_page_30 = len(all_users_list.get_users_list()) <= int( constants.PER_PAGE_30) allure.attach("Per page is 330: True", "Expected:") allure.attach("Per page is " + str(is_per_page_30), "Actual:") assert is_per_page_30 is True with allure.step('Checking if all user type return'): is_all_users_return = all_users_list.is_all_users_type_in_the_list( ) allure.attach("All users type return: True", "Expected:") allure.attach("All users type return: " + str(is_all_users_return), "Actual:") assert is_all_users_return is True with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach("Ret: " + str(all_users_list.get_ret()), "Actual:") assert all_users_list.get_ret() == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_0), "Expected:") allure.attach("Err_code: " + str(all_users_list.get_err_code()), "Actual:") assert all_users_list.get_err_code() == constants.ERR_CODE_0
def test_alter_password_with_short_new_password(self): with allure.step( 'Send alter password request with short new password'): alter_password_with_short_new_password = SendRequest( AlterPassword.get_test_case( "test_alter_password_with_short_new_password")) with allure.step("Checking msg"): allure.attach( "Msg contains: " + constants.ERR_MSG_NEW_PASSWORD_TOO_SHORT, "Expected") allure.attach( "Msg: " + alter_password_with_short_new_password.get_msg(), "Actual:") assert constants.ERR_MSG_NEW_PASSWORD_TOO_SHORT in alter_password_with_short_new_password.get_msg( ) with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach( "Ret: " + str(alter_password_with_short_new_password.get_ret()), "Actual:") assert alter_password_with_short_new_password.get_ret( ) == constants.RET_400
def test_login_with_regular_user_success(self): with allure.step('Send a valid regular user login request'): login_with_regular_user_success = SendRequest( Login.get_test_case("test_login_with_regular_user_success")) with allure.step('Checking Uuid'): allure.attach("Uuid: " + constants.USER_UUID, "Expected:") allure.attach( "Uuid: " + login_with_regular_user_success.get_uuid(), "Actual:") assert login_with_regular_user_success.get_uuid( ) == constants.USER_UUID with allure.step('Checking role'): allure.attach("Role: " + constants.ROLE_USER, "Expected:") allure.attach( "Role: " + login_with_regular_user_success.get_role(), "Actual:") assert login_with_regular_user_success.get_role( ) == constants.ROLE_USER with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach( "Ret: " + str(login_with_regular_user_success.get_ret()), "Actual:") assert login_with_regular_user_success.get_ret( ) == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_0), "Expected:") allure.attach( "Err_code: " + str(login_with_regular_user_success.get_err_code()), "Actual:") assert login_with_regular_user_success.get_err_code( ) == constants.ERR_CODE_0
def test_login_with_nonexistent_username(self): with allure.step('Send a login request with nonexistent username'): login_with_nonexistent_username = SendRequest(Login.get_test_case("test_login_with_nonexistent_username")) with allure.step('Checking Err_msg'): allure.attach("Err_msg contains: " + constants.ERR_MSG_NONEXISTENT_USERNAME, "Expected:") allure.attach("Err_msg: " + login_with_nonexistent_username.get_err_msg(), "Actual:") assert constants.ERR_MSG_NONEXISTENT_USERNAME in login_with_nonexistent_username.get_err_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach("Ret: " + str(login_with_nonexistent_username.get_ret()), "Actual:") assert login_with_nonexistent_username.get_ret() == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_1), "Expected:") allure.attach("Err_code: " + str(login_with_nonexistent_username.get_err_code()), "Actual:") assert login_with_nonexistent_username.get_err_code() == constants.ERR_CODE_1
def test_register_with_existing_username(self): with allure.step("Send a register request with existing username"): register_with_existing_username = SendRequest( Register.get_test_case("test_register_with_existing_username")) with allure.step('Checking Err_msg'): allure.attach("Err_msg contains: " + constants.ERR_MSG_EXISTING_USERNAME, "Expected:") allure.attach("Err_msg: " + register_with_existing_username.get_err_msg(), "Actual:") assert constants.ERR_MSG_EXISTING_USERNAME in register_with_existing_username.get_err_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach("Ret: " + str(register_with_existing_username.get_ret()), "Actual:") assert register_with_existing_username.get_ret() == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_1), "Expected:") allure.attach("Err_code: " + str(register_with_existing_username.get_err_code()), "Actual:") assert register_with_existing_username.get_err_code() == constants.ERR_CODE_1
def test_alter_password_with_same_password(self): with allure.step('Send alter password request with same password'): alter_password_same_password = SendRequest( AlterPassword.get_test_case("test_alter_password_with_same_password")) with allure.step('Checking Err_msg'): allure.attach("Err_msg contains: " + constants.ERR_MSG_WRONG_PASSWORD_OR_USERNAME, "Expected:") allure.attach("Err_msg: " + alter_password_same_password.get_err_msg(), "Actual:") assert constants.ERR_MSG_SAME_PASSWORD in alter_password_same_password.get_err_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach("Ret: " + str(alter_password_same_password.get_ret()), "Actual:") assert alter_password_same_password.get_ret() == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_2), "Expected:") allure.attach("Err_code: " + str(alter_password_same_password.get_err_code()), "Actual:") assert alter_password_same_password.get_err_code() == constants.ERR_CODE_2
def test_login_without_app_key(self): with allure.step('Send an admin login request without app key'): login_without_app_key = SendRequest(Login.get_test_case("test_login_without_app_key")) with allure.step('Checking msg'): allure.attach("Msg contains: " + constants.ERR_MSG_WITHOUT_APP_KEY, "Expected:") allure.attach("Msg: " + login_without_app_key.get_msg(), "Actual:") assert constants.ERR_MSG_WITHOUT_APP_KEY in login_without_app_key.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(login_without_app_key.get_ret()), "Actual:") assert login_without_app_key.get_ret() == constants.RET_400
def test_register_without_username(self): with allure.step('Send register request without username'): register_without_username = SendRequest(Register.get_test_case("test_register_without_username")) with allure.step('Checking msg'): allure.attach("Msg contains: " + constants.ERR_MSG_WITHOUT_USERNAME, "Expected:") allure.attach("Msg: " + register_without_username.get_msg(), "Actual:") assert constants.ERR_MSG_WITHOUT_USERNAME in register_without_username.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(register_without_username.get_ret()), "Actual:") assert register_without_username.get_ret() == constants.RET_400
def test_users_list_with_long_token(self): with allure.step("Send a get list request with long token"): users_list_with_long_token = SendRequest(UsersList.get_test_case("test_users_list_with_long_token")) with allure.step('Checking msg'): allure.attach("Msg contains: " + str(constants.ERR_MSG_LONG_TOKEN), "Expected:") allure.attach("Msg: " + str(users_list_with_long_token.get_msg()), "Actual:") assert constants.ERR_MSG_LONG_TOKEN in users_list_with_long_token.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(users_list_with_long_token.get_ret()), "Actual:") assert users_list_with_long_token.get_ret() == constants.RET_400
def test_register_without_password(self): with allure.step('Send register request without password'): register_without_password = SendRequest(Register.get_test_case("test_register_without_password")) with allure.step('Checking msg'): allure.attach("Msg contains: " + constants.ERR_MSG_WITHOUT_PASSWORD, "Expected:") allure.attach("Msg: " + register_without_password.get_msg(), "Actual:") assert constants.ERR_MSG_WITHOUT_PASSWORD in register_without_password.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(register_without_password.get_ret()), "Actual:") assert register_without_password.get_ret() == constants.RET_400
def test_login_with_long_password(self): with allure.step('Send a login request with long password'): login_with_long_password = SendRequest(Login.get_test_case("test_login_with_long_password")) with allure.step('Checking msg'): allure.attach("Msg contains: " + constants.ERR_MSG_LONG_PASSWORD, "Expected:") allure.attach("Msg: " + login_with_long_password.get_msg(), "Actual:") assert constants.ERR_MSG_LONG_PASSWORD in login_with_long_password.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(login_with_long_password.get_ret()), "Actual:") assert login_with_long_password.get_ret() == constants.RET_400
def test_users_list_without_app_key(self): with allure.step("Send a get list request without app key"): users_list_without_app_key = SendRequest(UsersList.get_test_case("test_users_list_without_app_key")) with allure.step('Checking msg'): allure.attach("Msg contains: " + str(constants.ERR_MSG_WITHOUT_APP_KEY), "Expected:") allure.attach("Msg: " + str(users_list_without_app_key.get_msg()), "Actual:") assert constants.ERR_MSG_WITHOUT_APP_KEY in users_list_without_app_key.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(users_list_without_app_key.get_ret()), "Actual:") assert users_list_without_app_key.get_ret() == constants.RET_400
def test_login_with_short_username(self): with allure.step('Send a login request with short username'): login_with_short_username = SendRequest(Login.get_test_case("test_login_with_short_username")) with allure.step('Checking msg'): allure.attach("Msg contains: " + constants.ERR_MSG_SHORT_USERNAME, "Expected:") allure.attach("Msg: " + login_with_short_username.get_msg(), "Actual:") assert constants.ERR_MSG_SHORT_USERNAME in login_with_short_username.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(login_with_short_username.get_ret()), "Actual:") assert login_with_short_username.get_ret() == constants.RET_400
def test_check_user_status_with_long_uuid(self): with allure.step("Send check user status request with long uuid"): check_user_status_with_long_uuid = SendRequest( CheckUserStatus.get_test_case("test_check_user_status_with_long_uuid")) with allure.step("Checking msg"): allure.attach("Msg contains: " + constants.ERR_MSG_LONG_UUID, "Expected") allure.attach("Msg: " + check_user_status_with_long_uuid.get_msg(), "Actual:") assert constants.ERR_MSG_LONG_UUID in check_user_status_with_long_uuid.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(check_user_status_with_long_uuid.get_ret()), "Actual:") assert check_user_status_with_long_uuid.get_ret() == constants.RET_400
def test_logout_with_admin_success(self): with allure.step("Send an admin logout request"): admin_success_logout = SendRequest(Logout.get_test_case( "test_logout_with_admin_success", TestLogOutWithAdminSuccess.admin_token)) with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach("Ret: " + str(admin_success_logout.get_ret()), "Actual:") assert admin_success_logout.get_ret() == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_0), "Expected:") allure.attach("Err_code: " + str(admin_success_logout.get_err_code()), "Actual:") assert admin_success_logout.get_err_code() == constants.ERR_CODE_0
def test_alter_password_without_app_key(self): with allure.step('Send alter password request without app key'): alter_password_without_app_key = SendRequest( AlterPassword.get_test_case("test_alter_password_without_app_key")) with allure.step("Checking msg"): allure.attach("Msg contains: " + constants.ERR_MSG_WITHOUT_APP_KEY, "Expected") allure.attach("Msg: " + alter_password_without_app_key.get_msg(), "Actual:") assert constants.ERR_MSG_WITHOUT_APP_KEY in alter_password_without_app_key.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(alter_password_without_app_key.get_ret()), "Actual:") assert alter_password_without_app_key.get_ret() == constants.RET_400
def test_logout_without_token(self): with allure.step('Send logout request without token'): log_out_without_token = SendRequest( Logout.get_test_case("test_logout_without_token", constants.TMP_TOKEN)) with allure.step('Checking msg'): allure.attach("Msg contains: " + constants.ERR_MSG_WITHOUT_TOKEN, "Expected:") allure.attach("Msg: " + log_out_without_token.get_msg(), "Actual:") assert constants.ERR_MSG_WITHOUT_TOKEN in log_out_without_token.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(log_out_without_token.get_ret()), "Actual:") assert log_out_without_token.get_ret() == constants.RET_400
def test_register_with_short_app_key(self): with allure.step("Send a register request with short app key"): register_with_short_app_key = SendRequest( Register.get_test_case("test_register_with_short_app_key")) with allure.step('Checking msg'): allure.attach("Msg contains: " + constants.ERR_MSG_SHORT_APP_KEY, "Expected:") allure.attach("Msg: " + register_with_short_app_key.get_msg(), "Actual:") assert constants.ERR_MSG_SHORT_APP_KEY in register_with_short_app_key.get_msg() with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(register_with_short_app_key.get_ret()), "Actual:") assert register_with_short_app_key.get_ret() == constants.RET_400
def test_users_list_get_regular_user(self): with allure.step( "Send a get list request with role user, page 2 and 15 per page" ): all_regular_users_list = SendRequest( UsersList.get_test_case("test_users_list_get_regular_users")) with allure.step('Checking if per page is less or equal 15'): is_per_page_less_or_equal_15 = len( all_regular_users_list.get_users_list()) <= int( constants.PER_PAGE_15) allure.attach("Per page is less or equal 15: True", "Expected:") allure.attach( "Per page is less or equal 15" + str(is_per_page_less_or_equal_15), "Actual:") assert is_per_page_less_or_equal_15 is True with allure.step('Checking if all user type return'): is_all_users_type_return = all_regular_users_list.is_all_users_type_in_the_list( ) allure.attach("All users type return: True", "Expected:") allure.attach( "All users type return: " + str(all_regular_users_list), "Actual:") assert is_all_users_type_return is True with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach("Ret: " + str(all_regular_users_list.get_ret()), "Actual:") assert all_regular_users_list.get_ret() == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_0), "Expected:") allure.attach( "Err_code: " + str(all_regular_users_list.get_err_code()), "Actual:") assert all_regular_users_list.get_err_code( ) == constants.ERR_CODE_0
def test_users_list_with_0_per_page(self): with allure.step("Send a get list request with 0 per page"): users_list_with_0_per_page = SendRequest(UsersList.get_test_case("test_users_list_with_0_per_page")) with allure.step('Checking if per page is equal to 0'): is_per_page_equal_to_0 = len(users_list_with_0_per_page.get_users_list()) == int(constants.PER_PAGE_0) allure.attach("Per page is equal to 0: True", "Expected:") allure.attach("Per page is equal to 0" + str(is_per_page_equal_to_0), "Actual:") assert is_per_page_equal_to_0 is True with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach("Ret: " + str(users_list_with_0_per_page.get_ret()), "Actual:") assert users_list_with_0_per_page.get_ret() == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_0), "Expected:") allure.attach("Err_code: " + str(users_list_with_0_per_page.get_err_code()), "Actual:") assert users_list_with_0_per_page.get_err_code() == constants.ERR_CODE_0
def test_log_out_without_uuid(self): with allure.step("Send an admin logout request"): logout_without_uuid = SendRequest( Logout.get_test_case("test_logout_without_uuid", constants.TMP_TOKEN)) with allure.step('Checking msg'): allure.attach("Msg contains " + constants.ERR_MSG_WITHOUT_UUID, "Expected:") allure.attach("Msg: " + logout_without_uuid.get_msg(), "Actual:") assert constants.ERR_MSG_WITHOUT_UUID in logout_without_uuid.get_msg( ) with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(logout_without_uuid.get_ret()), "Actual:") assert logout_without_uuid.get_ret() == constants.RET_400
def test_log_out_with_short_app_key(self): with allure.step("Send logout request with short app key"): logout_with_short_app_key = SendRequest( Logout.get_test_case("test_logout_with_short_app_key", constants.TMP_TOKEN)) with allure.step('Checking msg'): allure.attach("Msg contains:" + constants.ERR_MSG_SHORT_APP_KEY, "Expected:") allure.attach("Msg: " + logout_with_short_app_key.get_msg(), "Actual:") assert constants.ERR_MSG_SHORT_APP_KEY in logout_with_short_app_key.get_msg( ) with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach("Ret: " + str(logout_with_short_app_key.get_ret()), "Actual:") assert logout_with_short_app_key.get_ret() == constants.RET_400
def test_check_user_status_without_token(self): with allure.step("Send check user status request without token"): check_user_status_without_token = SendRequest( CheckUserStatus.get_test_case( "test_check_user_status_without_token")) with allure.step("Checking msg"): allure.attach("Msg contains: " + constants.ERR_MSG_WITHOUT_TOKEN, "Expected") allure.attach("Msg: " + check_user_status_without_token.get_msg(), "Actual:") assert constants.ERR_MSG_WITHOUT_TOKEN in check_user_status_without_token.get_msg( ) with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach( "Ret: " + str(check_user_status_without_token.get_ret()), "Actual:") assert check_user_status_without_token.get_ret( ) == constants.RET_400
def test_users_list_with_101_per_page(self): with allure.step("Send a get list request with 101 per page"): users_list_with_101_per_page = SendRequest( UsersList.get_test_case("test_users_list_with_101_per_page")) with allure.step('Checking msg'): allure.attach( "Msg: " + str(constants.ERR_MSG_USERS_LIST_101_PER_PAGE), "Expected:") allure.attach( "Msg: " + str(users_list_with_101_per_page.get_msg()), "Actual:") assert constants.ERR_MSG_USERS_LIST_101_PER_PAGE in users_list_with_101_per_page.get_msg( ) with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach( "Ret: " + str(users_list_with_101_per_page.get_ret()), "Actual:") assert users_list_with_101_per_page.get_ret() == constants.RET_400
def test_alter_password_with_short_username(self): with allure.step('Send alter password request with short username'): alter_password_with_short_username = SendRequest( AlterPassword.get_test_case( "test_alter_password_with_short_username")) with allure.step("Checking msg"): allure.attach("Msg contains: " + constants.ERR_MSG_SHORT_USERNAME, "Expected") allure.attach( "Msg: " + alter_password_with_short_username.get_msg(), "Actual:") assert constants.ERR_MSG_SHORT_USERNAME in alter_password_with_short_username.get_msg( ) with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_400), "Expected:") allure.attach( "Ret: " + str(alter_password_with_short_username.get_ret()), "Actual:") assert alter_password_with_short_username.get_ret( ) == constants.RET_400
def test_check_user_status_not_logged_in(self): with allure.step("Send check user status request(not logged in"): check_user_status_not_logged_in = SendRequest( CheckUserStatus.get_test_case( "test_check_user_status_not_logged_in")) with allure.step('Checking Ret'): allure.attach("Ret: " + str(constants.RET_200), "Expected:") allure.attach( "Ret: " + str(check_user_status_not_logged_in.get_ret()), "Actual:") assert check_user_status_not_logged_in.get_ret( ) == constants.RET_200 with allure.step('Checking Err_code'): allure.attach("Err_code: " + str(constants.ERR_CODE_1), "Expected:") allure.attach( "Err_code: " + str(check_user_status_not_logged_in.get_err_code()), "Actual:") assert check_user_status_not_logged_in.get_err_code( ) == constants.ERR_CODE_1