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 test_update_os_template(self): """ @Test: Update provisioning template @Feature: OS - Positive Update @Assert: OS is updated @BZ: 1129612 """ os_name = generate_string("alpha", 6) major_version = generate_string('numeric', 1) template_name = generate_string("alpha", 4) temp_type = 'provision' template_path = get_data_file(OS_TEMPLATE_DATA_FILE) os_list = [os_name] with Session(self.browser) as session: make_os(session, name=os_name, major_version=major_version) self.assertIsNotNone(self.operatingsys.search(os_name)) make_templates(session, name=template_name, template_path=template_path, custom_really=True, template_type=temp_type, os_list=os_list) self.assertIsNotNone(self.template.search(template_name)) self.navigator.go_to_operating_systems() self.operatingsys.update(os_name, template=template_name) result_obj = self.operatingsys.get_os_entities(os_name, "template") self.assertEqual(template_name, result_obj['template'])
def setup_to_create_cv(self, cv_name, repo_name=None, repo_url=None, repo_type=None): """ Create product/repo and sync it and create CV """ cv_name = cv_name or generate_string("alpha", 8) repo_name = repo_name or generate_string("alpha", 8) prd_name = generate_string("alpha", 8) repo_url = repo_url or "http://inecas.fedorapeople.org/fakerepos/zoo3/" repo_type = repo_type or REPO_TYPE['yum'] self.navigator.go_to_products() self.products.create(prd_name) self.assertIsNotNone(self.products.search(prd_name)) self.repository.create(repo_name, product=prd_name, url=repo_url, repo_type=repo_type) self.assertIsNotNone(self.repository.search(repo_name)) self.navigator.go_to_sync_status() sync = self.sync.sync_custom_repos(prd_name, [repo_name]) self.assertIsNotNone(sync) self.navigator.go_to_content_views() self.content_views.create(cv_name) self.assertIsNotNone(self.content_views.search(cv_name))
def test_create_package_group_filter(self): """ @test: create content views package group filter(positive) @feature: Content Views @assert: content views filter created and selected package groups can be added for inclusion/exclusion """ cv_name = generate_string("alpha", 8) filter_name = generate_string("alpha", 8) repo_name = generate_string("alpha", 8) repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/" content_type = FILTER_CONTENT_TYPE['package group'] filter_type = FILTER_TYPE['include'] package_group = 'mammals' self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.navigator.go_to_content_views() self.setup_to_create_cv(cv_name, repo_name, repo_url) # Navigating to dashboard is a workaround to # refresh the repos under selected CV self.navigator.go_to_dashboard() self.navigator.go_to_content_views() self.content_views.add_remove_repos(cv_name, [repo_name]) self.content_views.add_filter(cv_name, filter_name, content_type, filter_type) # Navigating to dashboard is a workaround to # refresh filters under selected CV self.navigator.go_to_dashboard() self.navigator.go_to_content_views() self.content_views.add_remove_package_groups_to_filter( cv_name, filter_name, [package_group]) self.assertTrue( self.content_views.wait_until_element( common_locators["alert.success"]))
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_delete_template_1(self): """ @Test: Check if Template can be deleted @Feature: Template - Delete @Assert: Template is deleted @BZ: 1096333 """ content = generate_string("alpha", 10) name = generate_string("alpha", 10) new_obj = make_template({ 'name': name, 'content': content, }) result = Template.info({'id': new_obj['id']}) self.assertEqual(result.return_code, 0) self.assertEqual(len(result.stderr), 0) self.assertEqual(new_obj['name'], result.stdout['name']) Template.delete({'id': new_obj['id']}) result = Template.info({'id': new_obj['id']}) self.assertNotEqual(result.return_code, 0) self.assertGreater(len(result.stderr), 0)
def test_negative_create_os_8(self): """ @Test: OS - Create a new OS with same name and version @Feature: Create a new OS - Negative @Assert: OS is not created @BZ: 1120985 """ name = generate_string("alpha", 6) major_version = generate_string('numeric', 1) minor_version = generate_string('numeric', 1) os_family = "Red Hat" arch = "x86_64" with Session(self.browser) as session: make_os(session, name=name, major_version=major_version, minor_version=minor_version, os_family=os_family, archs=[arch]) self.assertIsNotNone(self.operatingsys.search(name)) make_os(session, name=name, major_version=major_version, minor_version=minor_version, os_family=os_family, archs=[arch]) self.assertIsNotNone(self.operatingsys.wait_until_element (common_locators["haserror"])) self.assertIsNone(self.operatingsys.search(name))
def test_remove_medium_1(self, medium): """@test: Remove medium by using organization name and medium name. @feature: Organizations disassociate installation media. @assert: medium is added then removed. """ strategy, value = common_locators["entity_select"] strategy1, value1 = common_locators["entity_deselect"] org_name = generate_string("alpha", 8) path = URL % generate_string("alpha", 6) os_family = "Red Hat" with Session(self.browser) as session: make_media(session, name=medium, path=path, os_family=os_family) self.assertIsNotNone(self.medium.search(medium)) make_org(session, org_name=org_name, medias=[medium], edit=True) self.org.search(org_name).click() session.nav.wait_until_element( tab_locators["context.tab_media"]).click() element = session.nav.wait_until_element((strategy1, value1 % medium)) # Item is listed in 'Selected Items' list and not 'All Items' list. self.assertIsNotNone(element) self.navigator.go_to_org() self.org.update(org_name, medias=[medium], new_medias=None) self.org.search(org_name).click() session.nav.wait_until_element( tab_locators["context.tab_media"]).click() element = session.nav.wait_until_element((strategy, value % medium)) # Item is listed in 'All Items' list and not 'Selected Items' list. self.assertIsNotNone(element)
def test_positive_delete_activation_key_4(self, cv_name): """ @Feature: Activation key - Positive Delete @Test: Create Activation key and delete it for all variations of Content Views @Steps: 1. Create Activation key for all valid Content Views in [1] using valid Name, Description, Environment, Usage limit 2. Delete the Activation key @Assert: Activation key is deleted """ name = generate_string("alpha", 8) env_name = generate_string("alpha", 6) self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.navigator.go_to_life_cycle_environments() self.contentenv.create(env_name, description=generate_string("alpha", 16)) self.assertTrue( self.contentenv.wait_until_element( common_locators["alert.success"])) self.create_cv(cv_name, env_name) self.navigator.go_to_activation_keys() self.activationkey.create(name, env_name, description=generate_string("alpha", 16), content_view=cv_name) self.assertIsNotNone(self.activationkey.search_key(name)) self.activationkey.delete(name, True) self.assertIsNone(self.activationkey.search_key(name))
def test_update_template_os(self): """ @Feature: Template - Positive Update @Test: Creates new template, along with two OS's and associate list of OS's with created template @Assert: The template should be updated with newly created OS's successfully """ name = generate_string("alpha", 6) new_name = generate_string("alpha", 6) temp_type = 'provision' os_name1 = generate_string("alpha", 6) os_name2 = generate_string("alpha", 6) os_list = [os_name1, os_name2] major_version = generate_string('numeric', 1) template_path = get_data_file(OS_TEMPLATE_DATA_FILE) self.login.login(self.katello_user, self.katello_passwd) for os_name in os_list: self.navigator.go_to_operating_systems() self.operatingsys.create(os_name, major_version) self.assertIsNotNone(self.operatingsys.search(os_name)) self.create_template(name, template_path, True, temp_type, None) self.template.update(name, False, new_name, new_os_list=os_list) self.assertIsNotNone(self.template.search(new_name))
def make_sync_plan(options=None): """ Usage: hammer sync-plan create [OPTIONS] Options: --description DESCRIPTION sync plan description --interval INTERVAL how often synchronization should run One of ''none',', ''hourly',', ''daily',', ''weekly'' Default: "none" --name NAME sync plan name --organization-id ORGANIZATION_ID Filter products by organization name or label --sync-date SYNC_DATE start date and time of the synchronization Date and time in YYYY-MM-DD HH:MM:SS or ISO 8601 format """ # Organization ID is a required field. if not options or not options.get('organization-id', None): raise Exception("Please provide a valid ORG ID.") args = { 'name': generate_string('alpha', 20), 'description': generate_string('alpha', 20), 'organization-id': None, 'sync-date': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 'interval': random.choice(SYNC_INTERVAL.values()), } args = update_dictionary(args, options) args.update(create_object(SyncPlan, args)) return args
def test_remove_content_host(self): """@Test: Check if content host can be removed from host collection @Feature: Host Collection @Assert: Host collection is created and content-host is removed """ host_col_name = generate_string('alpha', 15) content_host_name = generate_string('alpha', 15) try: new_host_col = self._new_host_collection({'name': host_col_name}) new_system = make_content_host({ u'name': content_host_name, u'organization-id': self.org['id'], u'content-view-id': self.default_cv['id'], u'lifecycle-environment-id': self.library['id']}) except CLIFactoryError as err: self.fail(err) result = HostCollection.add_content_host({ u'id': new_host_col['id'], u'organization-id': self.org['id'], u'content-host-ids': new_system['id'] }) self.assertEqual(result.return_code, 0, "Content Host not added to host collection") self.assertEqual(len(result.stderr), 0, "No error was expected") result = HostCollection.info({ u'id': new_host_col['id'], u'organization-id': self.org['id'] }) no_of_content_host = result.stdout['total-content-hosts'] result = HostCollection.remove_content_host({ u'id': new_host_col['id'], u'organization-id': self.org['id'], u'content-host-ids': new_system['id'] }) self.assertEqual(result.return_code, 0, "Content Host not removed host collection") self.assertEqual(len(result.stderr), 0, "No error was expected") result = HostCollection.info({ u'id': new_host_col['id'], u'organization-id': self.org['id'] }) self.assertEqual( result.return_code, 0, 'Failed to get info for host collection') self.assertEqual( len(result.stderr), 0, 'There should not be an error here') self.assertGreater(no_of_content_host, result.stdout['total-content-hosts'], "There should not be an exception here")
def test_cv_publish_custom_content(self): """ @test: attempt to publish a content view containing custom content @feature: Content Views @setup: Multiple environments for an org; custom content synced @assert: Content view can be published """ repo_name = generate_string("alpha", 8) env_name = generate_string("alpha", 8) repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/" name = generate_string("alpha", 8) with Session(self.browser) as session: session.nav.go_to_select_org(self.org_name) session.nav.go_to_life_cycle_environments() self.contentenv.create(env_name) self.assertIsNotNone(self.contentenv.wait_until_element (common_locators["alert.success"])) self.setup_to_create_cv(name, repo_name, repo_url) self.content_views.add_remove_repos(name, [repo_name]) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"])) self.content_views.publish(name) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"]))
def make_product(options=None): """ Usage: hammer product create [OPTIONS] Options: --description DESCRIPTION Product description --gpg-key-id GPG_KEY_ID Identifier of the GPG key --label LABEL --name NAME --organization-id ORGANIZATION_ID ID of the organization --sync-plan-id SYNC_PLAN_ID Plan numeric identifier -h, --help print help """ # Organization ID is a required field. if not options or not options.get('organization-id', None): raise Exception("Please provide a valid ORG ID.") args = { 'name': generate_string('alpha', 20), 'label': generate_string('alpha', 20), 'description': generate_string('alpha', 20), 'organization-id': None, 'gpg-key-id': None, 'sync-plan-id': None, } args = update_dictionary(args, options) args.update(create_object(Product, args)) return args
def test_add_medium_1(self, medium): """@test: Add medium by using the organization name and medium name. @feature: Organizations associate medium. @assert: medium is added. """ strategy, value = common_locators["entity_deselect"] org_name = generate_string("alpha", 8) path = URL % generate_string("alpha", 6) os_family = "Red Hat" with Session(self.browser) as session: make_org(session, org_name=org_name) self.assertIsNotNone(self.org.search(org_name)) make_media(session, name=medium, path=path, os_family=os_family) self.assertIsNotNone(self.medium.search(medium)) self.org.update(org_name, new_medias=[medium]) self.org.search(org_name).click() session.nav.wait_until_element( tab_locators["context.tab_media"]).click() element = session.nav.wait_until_element((strategy, value % medium)) self.assertIsNotNone(element)
def test_cv_composite_create(self): # Note: puppet repos cannot/should not be used in this test # It shouldn't work - and that is tested in a different case. # Individual modules from a puppet repo, however, are a valid # variation. """ @test: create a composite content views @feature: Content Views @setup: sync multiple content source/types (RH, custom, etc.) @assert: Composite content views are created """ repo_url = "http://davidd.fedorapeople.org/repos/random_puppet/" puppet_module = "httpd" module_ver = 'Latest' cv_name = generate_string("alpha", 8) composite_name = generate_string("alpha", 8) self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.setup_to_create_cv(cv_name, repo_url=repo_url, repo_type=REPO_TYPE['puppet']) module = self.content_views.add_puppet_module(cv_name, puppet_module, filter_term=module_ver) self.assertIsNotNone(module) self.content_views.publish(cv_name) self.content_views.create(composite_name, is_composite=True) self.content_views.add_remove_cv(composite_name, [cv_name]) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"]))
def test_cv_end_2_end(self): """ @test: create content view @feature: Content Views @steps: 1. Create Product/repo and Sync it 2. Create CV and add created repo in step1 3. Publish and promote it to 'Library' 4. Promote it to next environment @assert: content view is created, updated with repo publish and promoted to next selected env """ repo_name = generate_string("alpha", 8) env_name = generate_string("alpha", 8) repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/" name = generate_string("alpha", 8) publish_version = "Version 1" self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.navigator.go_to_life_cycle_environments() self.contentenv.create(env_name) self.assertIsNotNone(self.contentenv.wait_until_element (common_locators["alert.success"])) self.setup_to_create_cv(name, repo_name, repo_url) self.content_views.add_remove_repos(name, [repo_name]) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"])) self.content_views.publish(name) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"])) self.content_views.promote(name, publish_version, env_name) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"]))
def test_create_package_filter(self): """ @test: create content views package filter(positive) @feature: Content Views @assert: content views filter created and selected packages can be added for inclusion/exclusion """ cv_name = generate_string("alpha", 8) filter_name = generate_string("alpha", 8) repo_name = generate_string("alpha", 8) repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/" content_type = FILTER_CONTENT_TYPE['package'] filter_type = FILTER_TYPE['include'] package_names = ['cow', 'bird', 'crow', 'bear'] version_types = ['Equal To', 'Greater Than', 'Less Than', 'Range'] values = ['0.3', '0.5', '0.5', '4.1'] max_values = [None, None, None, '4.6'] self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.navigator.go_to_content_views() self.setup_to_create_cv(cv_name, repo_name, repo_url) self.content_views.add_remove_repos(cv_name, [repo_name]) self.content_views.add_filter(cv_name, filter_name, content_type, filter_type) self.content_views.add_packages_to_filter(cv_name, filter_name, package_names, version_types, values, max_values)
def test_negative_update_activation_key_2(self): """@Test: Update invalid Description in an activation key @Feature: Activation key - Negative Update @Steps: 1. Create Activation key 2. Update Description for all variations in [2] @Assert: Activation key is not updated. Appropriate error shown. @BZ: 1078676 """ name = generate_string("alpha", 10) description = generate_string("alpha", 10) new_description = generate_string("alpha", 1001) with Session(self.browser) as session: make_activationkey(session, org=self.org_name, name=name, env=ENVIRONMENT, description=description) self.assertIsNotNone(self.activationkey.search_key(name)) self.activationkey.update(name, description=new_description) self.assertIsNotNone(self.activationkey.wait_until_element (common_locators["alert.error"]))
def test_associate_product_2(self): """@Test: Test that custom product can be associated to Activation Keys @Feature: Activation key - Product @Steps: 1. Create Activation key 2. Associate custom product(s) to Activation Key @Assert: Custom products are successfully associated to Activation key @BZ: 1078676 """ name = generate_string("alpha", 8) cv_name = generate_string("alpha", 8) env_name = generate_string("alpha", 8) # Helper function to create and promote CV to next environment # and it returns product name to associate it with key product_name = self.create_cv(cv_name, env_name) with Session(self.browser) as session: make_activationkey(session, org=self.org_name, name=name, env=env_name, description=generate_string("alpha", 16), content_view=cv_name) self.assertIsNotNone(self.activationkey.search_key(name)) self.activationkey.associate_product(name, [product_name]) self.assertIsNotNone(self.activationkey.wait_until_element (common_locators["alert.success"]))
def test_positive_update_activation_key_3(self, env_name): """@Test: Update Environment in an Activation key @Feature: Activation key - Positive Update @Steps: 1. Create Activation key 2. Update Environment for all variations in [1] @Assert: Activation key is updated @BZ: 1089637 """ name = generate_string("alpha", 8) cv_name = generate_string("alpha", 8) # Helper function to create and promote CV to next environment self.create_cv(cv_name, env_name) with Session(self.browser) as session: make_activationkey(session, org=self.org_name, name=name, env=ENVIRONMENT, description=generate_string("alpha", 16)) self.assertIsNotNone(self.activationkey.search_key(name)) env_locator = locators["ak.selected_env"] selected_env = self.activationkey.get_attribute(name, env_locator) self.assertEqual(ENVIRONMENT, selected_env) self.activationkey.update(name, content_view=cv_name, env=env_name) self.assertIsNotNone(self.activationkey.wait_until_element (common_locators["alert.success"])) selected_env = self.activationkey.get_attribute(name, env_locator) self.assertEqual(env_name, selected_env)
def test_update_resource(self): """ @Feature: Compute Resource - Update @Test: Update a libvirt Compute Resource @Assert: The libvirt Compute Resource is updated """ name = generate_string("alpha", 8) newname = generate_string("alpha", 8) org_name = generate_string("alpha", 8) new_org = generate_string("alpha", 8) libvirt_url = "qemu+tcp://%s:16509/system" url = (libvirt_url % conf.properties['main.server.hostname']) self.login.login(self.katello_user, self.katello_passwd) self.create_org(org_name) self.create_org(new_org) self.navigator.go_to_compute_resources() self.compute_resource.create(name, [org_name], provider_type="Libvirt", url=url) self.navigator.go_to_compute_resources() self.compute_resource.update(name, newname, [org_name], [new_org], libvirt_set_passwd=False) self.navigator.go_to_compute_resources() search = self.compute_resource.search(newname) self.assertIsNotNone(search)
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_create_package_group_filter(self): """ @test: create content views package group filter(positive) @feature: Content Views @assert: content views filter created and selected package groups can be added for inclusion/exclusion """ cv_name = generate_string("alpha", 8) filter_name = generate_string("alpha", 8) repo_name = generate_string("alpha", 8) repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/" content_type = FILTER_CONTENT_TYPE['package group'] filter_type = FILTER_TYPE['include'] package_group = 'mammals' self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.navigator.go_to_content_views() self.setup_to_create_cv(cv_name, repo_name, repo_url) self.content_views.add_remove_repos(cv_name, [repo_name]) self.content_views.add_filter(cv_name, filter_name, content_type, filter_type) self.content_views.add_remove_package_groups_to_filter(cv_name, filter_name, [package_group]) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"]))
def test_positive_create_activation_key_3(self, env): """ @Feature: Activation key - Positive Create @Test: Create Activation key for all variations of Environments @Steps: 1. Create Activation key for all valid Environments in [1] using valid Name, Description, Content View and Usage limit @Assert: Activation key is created @BZ: 1078676 """ name = generate_string("alpha", 8) cv_name = generate_string("alpha", 8) self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.navigator.go_to_life_cycle_environments() self.contentenv.create(env, description=generate_string("alpha", 16)) self.assertTrue( self.contentenv.wait_until_element( common_locators["alert.success"])) self.create_cv(cv_name, env) self.navigator.go_to_activation_keys() self.activationkey.create(name, env, description=generate_string("alpha", 16), content_view=cv_name) self.assertIsNotNone(self.activationkey.search_key(name))
def test_create_package_filter(self): """@test: create content views package filter(positive) @feature: Content Views @assert: content views filter created and selected packages can be added for inclusion/exclusion """ cv_name = generate_string("alpha", 8) filter_name = generate_string("alpha", 8) repo_name = generate_string("alpha", 8) content_type = FILTER_CONTENT_TYPE['package'] filter_type = FILTER_TYPE['include'] package_names = ['cow', 'bird', 'crow', 'bear'] version_types = ['Equal To', 'Greater Than', 'Less Than', 'Range'] values = ['0.3', '0.5', '0.5', '4.1'] max_values = [None, None, None, '4.6'] with Session(self.browser) as session: self.setup_to_create_cv(session, cv_name, repo_name) self.content_views.add_remove_repos(cv_name, [repo_name]) self.content_views.add_filter(cv_name, filter_name, content_type, filter_type) self.content_views.add_packages_to_filter(cv_name, filter_name, package_names, version_types, values, max_values)
def test_positive_update_user_1(self, new_username): """@Test: Update Username in User @Feature: User - Positive Update @Steps: 1. Create User 2. Update User name for all variations in [1] @Assert: User is updated @Status: Manual @BZ: 1139616 """ name = generate_string("alpha", 6) password = generate_string("alpha", 8) search_key = "login" self.login.login(self.katello_user, self.katello_passwd) # login self.create_user(name, password) self.user.update(search_key, name, new_username) self.assertIsNotNone( self.user.search(new_username, search_key)) self.login.logout() self.login.login(new_username, password) self.assertTrue(self.login.is_logged())
def create_medium(self, name=None, path=None, os_family=None): "Create Installation media with navigation steps" name = name or generate_string("alpha", 6) path = path or URL % generate_string("alpha", 6) self.navigator.go_to_installation_media() # go to media page self.medium.create(name, path, os_family) self.assertIsNotNone(self.medium.search(name))
def test_positive_create_user_10(self): """@Test: Create User with multiple roles @Feature: User - Positive Create @Steps: 1. Create User with multiple roles assigned to it @Assert: User is created @Status: Manual """ strategy = common_locators["entity_deselect"][0] value = common_locators["entity_deselect"][1] name = generate_string("alpha", 6) role1 = generate_string("alpha", 6) role2 = generate_string("alpha", 6) search_key = "login" self.login.login(self.katello_user, self.katello_passwd) # login self.navigator.go_to_roles() self.role.create(role1) self.role.create(role2) self.create_user(name, roles=[role1, role2]) self.user.search(name, search_key).click() self.user.wait_until_element(tab_locators["users.tab_roles"]).click() element1 = self.user.wait_until_element((strategy, value % role1)) element2 = self.user.wait_until_element((strategy, value % role2)) self.assertTrue(element1) self.assertTrue(element2)
def test_positive_create_user_25(self): """@Test: Create User associated to multiple Orgs @Feature: User - Positive Create @Assert: User is created @Status: Manual """ strategy = common_locators["entity_deselect"][0] value = common_locators["entity_deselect"][1] name = generate_string("alpha", 6) org_name1 = generate_string("alpha", 6) org_name2 = generate_string("alpha", 6) search_key = "login" self.login.login(self.katello_user, self.katello_passwd) # login make_org(Session(self.browser), org_name=org_name1) make_org(Session(self.browser), org_name=org_name2) self.create_user(name, organizations=[org_name1, org_name2]) self.user.search(name, search_key).click() self.user.wait_until_element( tab_locators["users.tab_organizations"]).click() element1 = self.user.wait_until_element((strategy, value % org_name1)) element2 = self.user.wait_until_element((strategy, value % org_name2)) self.assertTrue(element1) self.assertTrue(element2)
def test_cv_publish_custom_content(self): """@test: attempt to publish a content view containing custom content @feature: Content Views @setup: Multiple environments for an org; custom content synced @assert: Content view can be published """ repo_name = generate_string("alpha", 8) env_name = generate_string("alpha", 8) name = generate_string("alpha", 8) with Session(self.browser) as session: make_lifecycle_environment(session, org=self.org_name, name=env_name) self.assertIsNotNone(self.contentenv.wait_until_element (common_locators["alert.success"])) self.setup_to_create_cv(session, name, repo_name) self.content_views.add_remove_repos(name, [repo_name]) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"])) self.content_views.publish(name) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"]))
def test_update_role(self): """@Test: Update role for a user @Feature: User - Update @Assert: User role is updated """ strategy = common_locators["entity_deselect"][0] value = common_locators["entity_deselect"][1] name = generate_string("alpha", 6) role = generate_string("alpha", 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) self.user.search(name, search_key).click() self.user.wait_until_element(tab_locators["users.tab_roles"]).click() element1 = self.user.wait_until_element((strategy, value % role)) self.assertIsNone(element1) self.user.update(search_key, name, new_roles=[role]) self.user.search(name, search_key).click() self.user.wait_until_element(tab_locators["users.tab_roles"]).click() element2 = self.user.wait_until_element((strategy, value % role)) self.assertTrue(element2)
def test_update_template_1(self): """@Test: Check if Template can be updated @Feature: Template - Update @Assert: Template is updated """ content = generate_string("alpha", 10) name = generate_string("alpha", 10) try: new_obj = make_template( { 'name': name, 'content': content, } ) except CLIFactoryError as e: self.fail(e) result = Template.info({'id': new_obj['id']}) self.assertEqual(result.return_code, 0) self.assertEqual(len(result.stderr), 0) self.assertEqual(new_obj['name'], result.stdout['name']) updated_name = generate_string("alpha", 10) Template.update({'id': new_obj['id'], 'name': updated_name}) result = Template.info({'id': new_obj['id']}) self.assertEqual(result.return_code, 0) self.assertEqual(len(result.stderr), 0) self.assertEqual(updated_name, result.stdout['name'])
def test_create_package_group_filter(self): """@test: create content views package group filter(positive) @feature: Content Views @assert: content views filter created and selected package groups can be added for inclusion/exclusion """ cv_name = generate_string("alpha", 8) filter_name = generate_string("alpha", 8) repo_name = generate_string("alpha", 8) content_type = FILTER_CONTENT_TYPE['package group'] filter_type = FILTER_TYPE['include'] package_group = 'mammals' with Session(self.browser) as session: self.setup_to_create_cv(session, cv_name, repo_name) self.content_views.add_remove_repos(cv_name, [repo_name]) self.content_views.add_filter(cv_name, filter_name, content_type, filter_type) self.content_views.add_remove_package_groups_to_filter( cv_name, filter_name, [package_group] ) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"]))
def test_create_errata_filter(self): """@test: create content views errata filter(positive) @feature: Content Views @assert: content views filter created and selected errata-id can be added for inclusion/exclusion """ cv_name = generate_string("alpha", 8) filter_name = generate_string("alpha", 8) repo_name = generate_string("alpha", 8) content_type = FILTER_CONTENT_TYPE['erratum by id'] filter_type = FILTER_TYPE['include'] errata_ids = ['RHEA-2012:0001', 'RHEA-2012:0004'] with Session(self.browser) as session: self.setup_to_create_cv(session, cv_name, repo_name) self.content_views.add_remove_repos(cv_name, [repo_name]) self.content_views.add_filter(cv_name, filter_name, content_type, filter_type) self.content_views.add_remove_errata_to_filter(cv_name, filter_name, errata_ids) self.assertIsNotNone(self.content_views.wait_until_element (common_locators["alert.success"]))
def test_dump_template_1(self): """@Test: Check if Template can be created with specific content @Feature: Template - Create @Assert: Template is created with specific content """ content = generate_string("alpha", 10) name = generate_string("alpha", 10) new_obj = make_template( { 'name': name, 'content': content, } ) result = Template.info({'id': new_obj['id']}) self.assertEqual(result.return_code, 0) self.assertEqual(len(result.stderr), 0) self.assertEqual(new_obj['name'], result.stdout['name']) template_content = Template.dump({'id': new_obj['id']}) self.assertIn(content, template_content.stdout[0])
def test_add_medium_1(self, medium): """ @feature: Organizations @test: Add medium by using the organization name and medium name @assert: medium is added @BZ: 1076562 """ strategy = common_locators["entity_deselect"][0] value = common_locators["entity_deselect"][1] org_name = generate_string("alpha", 8) path = URL % generate_string("alpha", 6) os_family = "Red Hat" 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_installation_media() self.medium.create(medium, path, os_family) self.assertIsNotNone(self.medium.search(medium)) self.navigator.go_to_org() self.org.update(org_name, new_medias=[medium]) self.org.search(org_name).click() self.org.wait_until_element(tab_locators["orgs.tab_media"]).click() element = self.org.wait_until_element((strategy, value % medium)) self.assertTrue(element)
def test_remove_filter(self): """ @test: create empty content views filter and remove it(positive) @feature: Content Views @assert: content views filter removed successfully """ cv_name = generate_string("alpha", 8) filter_name = generate_string("alpha", 8) content_type = FILTER_CONTENT_TYPE['package'] filter_type = FILTER_TYPE['exclude'] self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.navigator.go_to_content_views() self.content_views.create(cv_name) self.assertIsNotNone(self.content_views.search(cv_name)) self.content_views.add_filter(cv_name, filter_name, content_type, filter_type) # Navigating to dashboard is a workaround to # refresh filters under selected CV self.navigator.go_to_dashboard() self.navigator.go_to_content_views() self.content_views.remove_filter(cv_name, [filter_name]) self.assertTrue( self.content_views.wait_until_element( common_locators["alert.success"]))
def test_delete_template_1(self): """@Test: Check if Template can be deleted @Feature: Template - Delete @Assert: Template is deleted @BZ: 1096333 """ content = generate_string("alpha", 10) name = generate_string("alpha", 10) new_obj = make_template( { 'name': name, 'content': content, } ) result = Template.info({'id': new_obj['id']}) self.assertEqual(result.return_code, 0) self.assertEqual(len(result.stderr), 0) self.assertEqual(new_obj['name'], result.stdout['name']) Template.delete({'id': new_obj['id']}) result = Template.info({'id': new_obj['id']}) self.assertNotEqual(result.return_code, 0) self.assertGreater(len(result.stderr), 0)
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 create_arch(self, arch_name, os_names=None): """ Function navigates and creates new architecture from UI """ arch_name = arch_name or generate_string("alpha", 10) os_names = os_names or [generate_string("alpha", 10)] self.navigator.go_to_architectures() # go to architecture page self.architecture.create(arch_name, os_names) self.assertIsNotNone(self.architecture.search(arch_name))
def test_create_medium(self): """ @Feature: Media - Create @Test: Create a new media @Assert: Media is created """ name = generate_string("alpha", 6) path = URL % generate_string("alpha", 6) os_family = "Red Hat" self.login.login(self.katello_user, self.katello_passwd) # login self.create_medium(name, path, os_family)
def test_set_parameter(self): """ @Feature: OS - Positive Update @Test: Set OS parameter @Assert: OS is updated """ name = generate_string("alpha", 4) major_version = generate_string('numeric', 1) param_name = generate_string("alpha", 4) param_value = generate_string("alpha", 3) self.login.login(self.katello_user, self.katello_passwd) # login self.create_os(name, major_version) self.operatingsys.set_os_parameter(name, param_name, param_value)
def create_os(self, name=None, major_version=None, minor_version=None, os_family=None, archs=None): """ Function to create OS with all navigation steps """ name = name or generate_string("alpha", 6) major_version = major_version or generate_string('numeric', 1) minor_version = minor_version or generate_string('numeric', 1) self.navigator.go_to_operating_systems() # go to operating system page self.operatingsys.create(name, major_version, minor_version, os_family, archs) self.assertIsNotNone(self.operatingsys.search(name))
def test_create_env(self): """ @Feature: Environment - Positive Create @Test: Create new environment @Assert: Environment is created """ name = generate_string("alpha", 8) org_name = generate_string("alpha", 8) self.login.login(self.katello_user, self.katello_passwd) self.create_org(org_name) self.navigator.go_to_environments() self.environment.create(name, [org_name]) search = self.environment.search(name) self.assertIsNotNone(search)
def test_create_arch(self): """ @Feature: Architecture - Create @Test: Create a new Architecture @Assert: Architecture is created """ name = generate_string("alpha", 4) os_name = generate_string("alpha", 6) major_version = generate_string('numeric', 1) self.login.login(self.katello_user, self.katello_passwd) # login self.navigator.go_to_operating_systems() # go to operating system page self.operatingsys.create(os_name, major_version) self.assertIsNotNone(self.operatingsys.search(os_name)) self.create_arch(name, [os_name])
def test_remove_env(self): """ @Feature: Environment - Positive Delete @Test: Delete an environment @Assert: Environment is deleted """ name = generate_string("alpha", 6) org_name = generate_string("alpha", 8) self.login.login(self.katello_user, self.katello_passwd) self.create_org(org_name) self.navigator.go_to_environments() self.environment.create(name, [org_name]) self.environment.delete(name, really=True) notif = self.user.wait_until_element(common_locators["notif.success"]) self.assertTrue(notif)
def test_update_hostgroup(self): """ @Feature: Hostgroup - Positive Update @Test: Update hostgroup with a new name @Assert: Hostgroup is updated """ name = generate_string("alpha", 7) updated_name = generate_string("alpha", 7) self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_host_groups() self.hostgroup.create(name) # confirm the Hostgroup appears in the UI self.assertIsNotNone(self.hostgroup.search(name)) self.hostgroup.update(name, new_name=updated_name) self.assertIsNotNone(self.hostgroup.search(updated_name))
def test_remove_medium(self): """ @Feature: Media - Delete @Test: Delete a media @Assert: Media is deleted """ name = generate_string("alpha", 6) path = URL % generate_string("alpha", 6) os_family = "Red Hat" self.login.login(self.katello_user, self.katello_passwd) # login self.create_medium(name, path, os_family) self.medium.delete(name, True) self.assertTrue(self.medium.wait_until_element (common_locators["notif.success"])) self.assertIsNone(self.medium.search(name))
def test_positive_create_content_environment_1(self): """ @Feature: Content Environment - Positive Create @Test: Create Content Environment with minimal input parameters @Assert: Environment is created """ name = generate_string("alpha", 6) description = generate_string("alpha", 6) self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.navigator.go_to_life_cycle_environments() self.contentenv.create(name, description) self.assertTrue( self.contentenv.wait_until_element( common_locators["alert.success"]))
class TestFact(BaseCLI): """ Fact related tests. """ @unittest.skip("Need to create facts before we can check them.") @data( 'uptime', 'uptime_days', 'uptime_seconds', 'memoryfree', 'ipaddress', ) @attr('cli', 'fact') def test_list_success(self, fact): """ @Feature: Fact - List Positive @Test: Test Fact List @Assert: Fact List is displayed """ args = { 'search': "fact='%s'" % fact, } result = Fact().list(args) stdout = result.stdout self.assertEqual(stdout[0]['fact'], fact) @data( generate_string("alpha", 10), generate_string("alpha", 10), generate_string("alpha", 10), generate_string("alpha", 10), ) @attr('cli', 'fact') def test_list_fail(self, fact): """ @Feature: Fact - List Negative @Test: Test Fact List failure @Assert: Fact List is not displayed """ args = { 'search': "fact='%s'" % fact, } self.assertEqual(Fact().list(args).stdout, [], "No records should be returned")
def test_update_subnet_1(self): """ @Feature: Subnet - Positive Update @Test: Update Subnet name @Assert: Subnet name is updated """ subnet_name = generate_string("alpha", 8) subnet_network = generate_ipaddr(ip3=True) subnet_mask = "255.255.255.0" self.login.login(self.katello_user, self.katello_passwd) self.create_subnet(subnet_name, subnet_network, subnet_mask) new_subnet_name = generate_string("alpha", 10) self.subnet.update(subnet_name, new_subnet_name=new_subnet_name) result_object = self.subnet.search_subnet(new_subnet_name) self.assertEqual(new_subnet_name, result_object['name'])
def test_update_medium(self): """ @Feature: Media - Update @Test: Update a media with name, path, OS family @Assert: Media is updated """ name = generate_string("alpha", 6) newname = generate_string("alpha", 4) path = URL % generate_string("alpha", 6) newpath = URL % generate_string("alpha", 6) os_family = "Red Hat" new_os_family = "Debian" self.login.login(self.katello_user, self.katello_passwd) # login self.create_medium(name, path, os_family) self.medium.update(name, newname, newpath, new_os_family) self.assertTrue(self, self.medium.search(newname))
def test_positive_create_3(self): """ @Feature: Content Sync Plan - Positive Create @Test: Create Sync plan with specified start time @Assert: Sync Plan is created with the specified time. @BZ: 1082632 """ locator = locators["sp.fetch_startdate"] plan_name = generate_string("alpha", 8) self.configure_syncplan() description = "sync plan create with start date" current_date = datetime.now() startdate = current_date + timedelta(minutes=10) starthour = startdate.strftime("%H") startminute = startdate.strftime("%M") # Formatting current_date to web-UI format "%b %d, %Y %I:%M:%S %p" # Removed zero padded hrs & mins as fetching via web-UI doesn't have it # Removed the seconds info as it would be too quick to validate via UI. fetch_starttime = startdate.strftime("%b %d, %Y %I:%M:%S %p").\ lstrip("0").replace(" 0", " ").rpartition(':')[0] self.syncplan.create(plan_name, description, start_hour=starthour, start_minute=startminute) self.assertIsNotNone(self.products.search(plan_name)) self.syncplan.search(plan_name).click() self.syncplan.wait_for_ajax() # Removed the seconds info as it would be too quick to validate via UI. starttime_text = str(self.syncplan.wait_until_element(locator).text).\ rpartition(':')[0] self.assertEqual(starttime_text, fetch_starttime)
def setUp(self): super(ActivationKey, self).setUp() # Make sure to use the Class' org_name instance if ActivationKey.org_name is None: ActivationKey.org_name = generate_string("alpha", 10) with Session(self.browser) as session: make_org(session, org_name=ActivationKey.org_name)
def setUp(self): super(Syncplan, self).setUp() # Make sure to use the Class' org_name instance if Syncplan.org_name is None: Syncplan.org_name = generate_string("alpha", 8) with Session(self.browser) as session: make_org(session, org_name=Syncplan.org_name)
def test_positive_update_3(self, plan_name): """ @Feature: Content Sync Plan - Positive Update add products @Test: Update Sync plan and associate products @Assert: Sync Plan has the associated product """ prd_name = generate_string("alpha", 8) description = "update sync plan, add prds" strategy, value = locators["sp.prd_select"] self.login.login(self.katello_user, self.katello_passwd) self.navigator.go_to_select_org(self.org_name) self.navigator.go_to_products() self.products.create(prd_name, description) self.assertIsNotNone(self.products.search(prd_name)) self.navigator.go_to_sync_plans() self.syncplan.create(plan_name, description) self.assertIsNotNone(self.products.search(plan_name)) self.syncplan.update(plan_name, add_products=[prd_name]) self.syncplan.search(plan_name).click() self.syncplan.wait_for_ajax() self.syncplan.wait_until_element(tab_locators["sp.tab_products"]).\ click() self.syncplan.wait_for_ajax() prd_element = self.syncplan.wait_until_element( (strategy, value % prd_name)) self.assertTrue(prd_element)