def test_add_user_2(self, name): """@test: Create different types of users then add user by using the organization name. @feature: Organizations associate user. @assert: User is added to organization. """ strategy, value = common_locators["entity_deselect"] org_name = generate_string("alpha", 8) password = generate_string("alpha", 8) email = generate_email_address() search_key = "login" with Session(self.browser) as session: make_org(session, org_name=org_name) self.assertIsNotNone(self.org.search(org_name)) make_user(session, username=name, first_name=name, last_name=name, email=email, password1=password, password2=password) self.assertIsNotNone(self.user.search(name, search_key)) self.org.wait_for_ajax() self.org.update(org_name, new_users=[name]) self.org.search(org_name).click() session.nav.wait_until_element( tab_locators["context.tab_users"]).click() element = session.nav.wait_until_element((strategy, value % name)) self.assertIsNotNone(element)
def test_add_user_2(self, user): """ @feature: Organizations @test: Create different types of users then add user by using the organization name @assert: User is added to organization @BZ: 1076562 """ strategy = common_locators["entity_deselect"][0] value = common_locators["entity_deselect"][1] org_name = generate_string("alpha", 8) password = generate_string("alpha", 8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_org() self.org.create(org_name) self.navigator.go_to_org() self.assertIsNotNone(self.org.search(org_name)) self.navigator.go_to_users() self.user.create(user, email, password, password) self.assertIsNotNone(self.user.search(user, search_key)) self.navigator.go_to_org() self.org.update(org_name, new_users=[user]) self.org.search(org_name).click() self.org.wait_until_element(tab_locators["orgs.tab_users"]).click() element = self.org.wait_until_element((strategy, value % user)) self.assertTrue(element)
def test_remove_user_3(self, user_name): """ @feature: Organizations @test: Create admin users then add user and remove it by using the organization name @assert: The user is added then removed from the organization @BZ: 1076562 """ strategy = common_locators["entity_select"][0] value = common_locators["entity_select"][1] strategy1 = common_locators["entity_deselect"][0] value1 = common_locators["entity_deselect"][1] org_name = generate_string("alpha", 8) password = generate_string("alpha", 8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_users() self.user.create(user_name, email, password, password) self.assertIsNotNone(self.user.search(user_name, search_key)) self.navigator.go_to_org() self.org.create(org_name, users=[user_name], edit=True) self.org.search(org_name).click() self.org.wait_until_element(tab_locators["orgs.tab_users"]).click() element = self.org.wait_until_element((strategy1, value1 % user_name)) # Item is listed in 'Selected Items' list and not 'All Items' list. self.assertTrue(element) self.navigator.go_to_org() self.org.update(org_name, users=[user_name], new_users=None) self.org.search(org_name).click() self.org.wait_until_element(tab_locators["orgs.tab_users"]).click() element = self.org.wait_until_element((strategy, value % user_name)) # Item is listed in 'All Items' list and not 'Selected Items' list. self.assertTrue(element)
def create_user(self, name=None, password=None, email=None, firstname=None, lastname=None, locale=None, roles=None, organizations=None, locations=None, authorized_by="INTERNAL", password2=None): """Function to create a new User""" name = name or generate_string("alpha", 8) password = password or generate_string("alpha", 8) if not password2: password2 = password email = email or generate_email_address() first_name = firstname or generate_string("alpha", 10) last_name = lastname or generate_string("alpha", 8) self.navigator.go_to_users() self.user.create(username=name, email=email, password1=password, password2=password2, first_name=first_name, last_name=last_name, roles=roles, locations=locations, organizations=organizations, locale=locale, authorized_by=authorized_by, edit=True)
def test_remove_user_3(self, testdata): """ @test: Create admin users then add user and remove it by using the organization name. @feature: Organizations dis-associate user. @assert: The user is added then removed from the organization """ user_name = testdata['name'] strategy, value = common_locators["entity_select"] strategy1, value1 = common_locators["entity_deselect"] org_name = generate_string("alpha", 8) password = generate_string("alpha", 8) email = generate_email_address() search_key = "login" with Session(self.browser) as session: make_user(session, username=user_name, email=email, password1=password, password2=password) self.assertIsNotNone(self.user.search(user_name, search_key)) make_org(session, org_name=org_name, users=[user_name], edit=True) self.org.search(org_name).click() session.nav.wait_until_element( tab_locators["context.tab_users"]).click() element = session.nav.wait_until_element((strategy1, value1 % user_name)) # Item is listed in 'Selected Items' list and not 'All Items' list. self.assertIsNotNone(element) self.org.update(org_name, users=[user_name], new_users=None) self.org.search(org_name).click() session.nav.wait_until_element( tab_locators["context.tab_users"]).click() element = session.nav.wait_until_element((strategy, value % user_name)) # Item is listed in 'All Items' list and not 'Selected Items' list. self.assertIsNotNone(element)
def test_add_user_1(self, testdata): """@test: Create user then add user by using the location name @feature: Locations @assert: User is added to location """ user = testdata['name'] strategy, value = common_locators["entity_deselect"] loc_name = generate_string("alpha", 8) password = generate_string("alpha", 8) email = generate_email_address() search_key = "login" with Session(self.browser) as session: make_loc(session, name=loc_name) self.assertIsNotNone(self.location.search(loc_name)) make_user(session, username=user, first_name=user, last_name=user, email=email, password1=password, password2=password) self.assertIsNotNone(self.user.search(user, search_key)) self.location.update(loc_name, new_users=[user]) self.location.search(loc_name).click() session.nav.wait_until_element( tab_locators["context.tab_users"]).click() element = session.nav.wait_until_element((strategy, value % user)) self.assertIsNotNone(element)
def __init__(self, generate=False): if generate: self.login = unicode(generate_name(6)) self.password = unicode(generate_name(8)) self.mail = unicode(generate_email_address()) self.firstname = unicode(generate_name(6)) self.lastname = unicode(generate_name(6)) self.admin = False self.auth_source_id = 1
def test_create_user(self): "Create a new User" name = generate_name(6) password = generate_name(8) email = generate_email_address() self.login.login(self.katello_user, self.katello_passwd) # login self.navigator.go_to_users() self.user.create(name, email, password, password) self.assertIsNotNone(self.user.search(name)) #confirm the User appears in the UI
def test_create_user(self): """ Create a new User """ name = generate_name(6) password = generate_name(8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.create_user(name, password, email, search_key)
def test_delete_user(self): "Create and Delete a User" name = generate_name(6) password = generate_name(8) email = generate_email_address() self.login.login(self.katello_user, self.katello_passwd) # login self.navigator.go_to_users() self.user.create(name, email, password, password) self.assertIsNotNone(self.user.search(name)) #confirm the User appears in the UI self.user.delete(name, really=True) self.assertTrue(self.user.wait_until_element(locators["notif.success"]))
def create_user(self, name=None, password=None, email=None, search_key=None): """ Function to create a new User """ name = name or generate_name(8) password = password or generate_name(8) email = email or generate_email_address() self.navigator.go_to_users() self.user.create(name, email, password, password) self.assertIsNotNone(self.user.search(name, search_key))
def test_create_user(self): """ @Feature: User - Create @Test: Create a new user @Assert: User is created """ name = generate_name(6) password = generate_name(8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.create_user(name, password, email, search_key)
def test_delete_user(self): """ Create and Delete a User """ name = generate_name(6) password = generate_name(8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) # login self.create_user(name, password, email, search_key) self.user.delete(name, search_key, really=True) self.assertTrue(self.user.wait_until_element(common_locators ["notif.success"]))
def test_update_password(self): "Creates a User and updates the password" name = generate_name(6) password = generate_name(8) new_password = generate_name(8) email = generate_email_address() self.login.login(self.katello_user, self.katello_passwd) # login self.navigator.go_to_users() self.user.create(name, email, password, password) self.assertIsNotNone(self.user.search(name)) #confirm the User appears in the UI self.user.update(name, password = new_password) self.login.logout() self.login.login(name, new_password) self.assertTrue(self.login.is_logged()) #confirm user can login with new password
def test_create_usergroup(self): """ Creates new usergroup """ user_name = generate_name(6) group_name = generate_name(6) password = generate_name(8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_users() self.user.create(user_name, email, password, password) self.assertIsNotNone(self.user.search(user_name, search_key)) self.create_usergroup(group_name, [user_name])
def test_update_password(self): """ Creates a User and updates the password """ name = generate_name(6) password = generate_name(8) new_password = generate_name(8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) # login self.create_user(name, password, email, search_key) self.user.update(search_key, name, None, None, new_password) self.login.logout() self.login.login(name, new_password) self.assertTrue(self.login.is_logged())
def test_update_role(self): """ Creates a User and updates the password """ name = generate_name(6) password = generate_name(8) email = generate_email_address() role = generate_name(6) search_key = "login" self.login.login(self.katello_user, self.katello_passwd) # login self.navigator.go_to_roles() self.role.create(role) self.assertIsNotNone(self, self.role.search(role)) self.create_user(name, password, email, search_key) self.user.update(search_key, name, new_roles=[role])
def test_create_usergroup(self): """ @Feature: Usergroup - Positive Create @Test: Create new Usergroup @Assert: Usergroup is created """ user_name = generate_name(6) group_name = generate_name(6) password = generate_name(8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_users() self.user.create(user_name, email, password, password) self.assertIsNotNone(self.user.search(user_name, search_key)) self.create_usergroup(group_name, [user_name])
def test_update_usergroup(self): """ Create new usergroup and update its name or users """ name = generate_name(6) new_name = generate_name(4) user_name = generate_name(6) password = generate_name(8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_users() self.user.create(user_name, email, password, password) self.assertIsNotNone(self.user.search(user_name, search_key)) self.create_usergroup(name) self.usergroup.update(name, new_name, new_users=[user_name])
def test_create_usergroup(self): """ @Feature: Usergroup - Positive Create @Test: Create new Usergroup @Assert: Usergroup is created """ user_name = generate_string("alpha", 10) group_name = generate_string("alpha", 10) password = generate_string("alpha", 10) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_users() self.user.create(user_name, email, password, password) self.assertIsNotNone(self.user.search(user_name, search_key)) self.create_usergroup(group_name, [user_name])
def test_update_password(self): """ @Feature: User - Update @Test: Update password for a user @Assert: User password is updated """ name = generate_name(6) password = generate_name(8) new_password = generate_name(8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) # login self.create_user(name, password, email, search_key) self.user.update(search_key, name, None, None, new_password) self.login.logout() self.login.login(name, new_password) self.assertTrue(self.login.is_logged())
def test_update_role(self): """ @Feature: User - Update @Test: Update role for a user @Assert: User role is updated """ name = generate_name(6) password = generate_name(8) email = generate_email_address() role = generate_name(6) search_key = "login" self.login.login(self.katello_user, self.katello_passwd) # login self.navigator.go_to_roles() self.role.create(role) self.assertIsNotNone(self, self.role.search(role)) self.create_user(name, password, email, search_key) self.user.update(search_key, name, new_roles=[role])
def test_update_usergroup(self): """ @Feature: Usergroup - Positive Update @Test: Update usergroup with name or users @Assert: Usergroup is updated """ name = generate_name(6) new_name = generate_name(4) user_name = generate_name(6) password = generate_name(8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_users() self.user.create(user_name, email, password, password) self.assertIsNotNone(self.user.search(user_name, search_key)) self.create_usergroup(name) self.usergroup.update(name, new_name, new_users=[user_name])
def test_update_usergroup(self): """ @Feature: Usergroup - Positive Update @Test: Update usergroup with name or users @Assert: Usergroup is updated """ name = generate_string("alpha", 6) new_name = generate_string("alpha", 4) user_name = generate_string("alpha", 6) password = generate_string("alpha", 8) email = generate_email_address() search_key = "login" self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_users() self.user.create(user_name, email, password, password) self.assertIsNotNone(self.user.search(user_name, search_key)) self.create_usergroup(name) self.usergroup.update(name, new_name, new_users=[user_name]) self.assertIsNotNone(self.usergroup.search(new_name))
def make_user(session, org=None, loc=None, force_context=False, **kwargs): """ Creates a user """ password = generate_string("alpha", 6) create_args = { "username": None, "email": generate_email_address(), "password1": password, "password2": password, "authorized_by": "INTERNAL", "locale": None, "first_name": generate_string("alpha", 6), "last_name": generate_string("alpha", 6), "roles": None, "locations": None, "organizations": None, "edit": False, "select": True, } page = session.nav.go_to_users core_factory(create_args, kwargs, session, page, org=org, loc=loc, force_context=force_context) User(session.browser).create(**create_args)
def generate(self): return generate_email_address( name_length=self.name_length, domain_length=self.domain_length)
def test_return_type(self): """Tests if generate email address returns a unicode string""" self.assertIsInstance(generate_email_address(), unicode)
def generate(self): return generate_email_address(name_length=self.name_length, domain_length=self.domain_length)