def test_post_scenario_yum_plugins_count(self): """Upgrade katello agent on pre-upgrade content host registered with Satellite. :id: postupgrade-45241ada-c2c4-409e-a6e2-92c2cf0ac16c :steps: 1. Create custom tool repo as per upgraded Satellite version and sync. 2. Add in content-view and publish it. 2. Update Katello-agent and Restart goferd. 2. Check yum plugins count. :expectedresults: 1. Loaded yum plugins should not load more than two times. """ entity_data = get_entity_data(self.__class__.__name__) client = entity_data.get('rhel_client') client_container_id = list(client.values())[0] product_id = entity_data.get('product_id') conten_view_id = entity_data.get('conten_view_id') product = entities.Product(id=product_id).read() content_view = entities.ContentView(id=conten_view_id).read() tools_repo, rhel_repo = self._create_custom_rhel_tools_repos(product) product.sync() for repo in (tools_repo, rhel_repo): content_view.repository.append(repo) content_view = content_view.update(['repository']) content_view.publish() self._install_or_update_package(client_container_id, "katello-agent", update=True) self._run_goferd(client_container_id) self._check_yum_plugins_count(client_container_id)
def test_post_crud_virt_who_configuration(self): """Virt-who config is intact post upgrade and verify the config can be updated and deleted. :id: postupgrade-d7ae7b2b-3291-48c8-b412-cb54e444c7a4 :steps: 1. Post upgrade, Verify virt-who exists and has same status. 2. Verify the connection of the guest on Content host. 3. Verify the virt-who config-file exists. 4. Update virt-who config with new name. 5. Delete virt-who config. :expectedresults: 1. virt-who config is intact post upgrade. 2. the config and guest connection have the same status. 3. virt-who config should update and delete successfully. """ org = entities.Organization().search(query={'search': 'name={0}'.format(self.org_name)})[0] # Post upgrade, Verify virt-who exists and has same status. vhd = entities.VirtWhoConfig(organization_id=org.id).search( query={'search': 'name={}'.format(self.name)} )[0] if not is_open('BZ:1802395'): self.assertEqual(vhd.status, 'ok') # Verify virt-who status via CLI as we cannot check it via API now vhd_cli = VirtWhoConfig.exists(search=('name', self.name)) self.assertEqual( VirtWhoConfig.info({'id': vhd_cli['id']})['general-information']['status'], 'OK' ) # Vefify the connection of the guest on Content host entity_data = get_entity_data(self.__class__.__name__) hypervisor_name = entity_data.get('hypervisor_name') guest_name = entity_data.get('guest_name') hosts = [hypervisor_name, guest_name] for hostname in hosts: result = ( entities.Host(organization=org.id) .search(query={'search': hostname})[0] .read_json() ) self.assertEqual(result['subscription_status_label'], 'Fully entitled') # Verify the virt-who config-file exists. config_file = get_configure_file(vhd.id) get_configure_option('hypervisor_id', config_file), # Update virt-who config modify_name = gen_string('alpha') vhd.name = modify_name vhd.update(['name']) # Delete virt-who config vhd.delete() self.assertFalse( entities.VirtWhoConfig(organization_id=org.id).search( query={'search': 'name={}'.format(modify_name)} ) )
def test_post_scenario_preclient_package_installation(self): """Post-upgrade scenario that installs the package on pre-upgrade client remotely and then verifies if the package installed :id: postupgrade-eedab638-fdc9-41fa-bc81-75dd2790f7be :steps: Install package on a pre-upgrade client :expectedresults: The package is installed in client """ client = get_entity_data(self.__class__.__name__) client_name = str(list(client.keys())[0]).lower() client_id = entities.Host().search( query={'search': 'name={}'.format(client_name)} )[0].id entities.Host().install_content(data={ 'organization_id': self.org.id, 'included': {'ids': [client_id]}, 'content_type': 'package', 'content': [self.package_name], }) # Validate if that package is really installed installed_package = execute( docker_execute_command, list(client.values())[0], 'rpm -q {}'.format(self.package_name), host=self.docker_vm )[self.docker_vm] self.assertIn(self.package_name, installed_package)
def test_post_user_scenario_capsule_sync(self): """Post-upgrade scenario that sync capsule from satellite and then verifies if the repo/rpm of pre-upgrade scenario is synced to capsule :id: postupgrade-eb8970fa-98cc-4a99-99fb-1c12c4e319c9 :steps: 1. Run capsule sync post upgrade. 2. Check if the repo/rpm is been synced to capsule. :expectedresults: 1. The capsule sync should be successful 2. The repos/rpms from satellite should be synced to satellite """ env_name = get_entity_data(self.__class__.__name__)['env_name'] cap_data = hammer.hammer('capsule list') cap_id = hammer.get_attribute_value(cap_data, self.cap_host, 'id') org_data = hammer.hammer('organization list') org_name = hammer.get_attribute_value(org_data, int(self.org_id), 'label') print hammer.hammer( 'capsule content synchronize --id {0}'.format(cap_id)) result = execute( lambda: run('[ -f /var/lib/pulp/published/yum/http/repos/' '{0}/{1}/{2}/custom/{3}/{4}/Packages/b/{5} ]; echo $?'. format(org_name, env_name, self.cv_name, self. prod_name, self.repo_name, self.rpm_name)), host=self.cap_host)[self.cap_host] self.assertEqual('0', result)
def test_post_scenario_preclient_package_installation(default_org): """Post-upgrade install of a package on a client created and registered pre-upgrade. :id: postupgrade-eedab638-fdc9-41fa-bc81-75dd2790f7be :steps: Install package on the pre-upgrade registered client :expectedresults: The package is installed on client """ client = get_entity_data(__name__) client_name = str(list(client.keys())[0]).lower() client_id = entities.Host().search( query={'search': f'name={client_name}'})[0].id entities.Host().install_content( data={ 'organization_id': default_org.id, 'included': { 'ids': [client_id] }, 'content_type': 'package', 'content': [FAKE_0_CUSTOM_PACKAGE], }) # Verifies that package is really installed installed_package = execute( docker_execute_command, list(client.values())[0], f'rpm -q {FAKE_0_CUSTOM_PACKAGE}', host=docker_vm, )[docker_vm] assert FAKE_0_CUSTOM_PACKAGE in installed_package
def test_post_sync_plan_migration(self): """Post-upgrade scenario that tests existing sync plans are working as expected after satellite upgrade with migrating from pulp to katello :id: badaeec2-d42f-41d5-bd85-4b23d6d5a724 :steps: 1. Verify sync plan exists and works as earlier :expectedresults: Post Upgrade, Sync plans exists and works as earlier. """ entity_data = get_entity_data(self.__class__.__name__) org = entities.Organization(id=entity_data.get('org_id')) product = entities.Product(id=entity_data.get("product_id")).read() sync_plan = entities.SyncPlan(id=entity_data.get("sync_plan_id"), organization=org).read() self.assertEqual(product.sync_plan.id, sync_plan.id) self.assertEqual(sync_plan.name, entity_data.get("sync_plan_name")) self.assertEqual(sync_plan.interval, entity_data.get("interval")) self.assertEqual(sync_plan.sync_date, entity_data.get("sync_date")) # checking sync plan update on upgraded satellite sync_plan.interval = SYNC_INTERVAL['custom'] sync_plan.cron_expression = gen_choice(valid_cron_expressions()) self.assertEqual( sync_plan.update(['interval', 'cron_expression']).interval, SYNC_INTERVAL['custom'] ) # checking sync plan delete on upgraded satellite sync_plan.delete() product = product.read() self.assertIsNone(product.sync_plan) with self.assertRaises(HTTPError): sync_plan.read()
def test_post_user_scenario_capsule_sync(self): """Post-upgrade scenario that sync capsule from satellite and then verifies if the repo/rpm of pre-upgrade scenario is synced to capsule :id: postupgrade-eb8970fa-98cc-4a99-99fb-1c12c4e319c9 :steps: 1. Run capsule sync post upgrade. 2. Check if the repo/rpm is been synced to capsule. :expectedresults: 1. The capsule sync should be successful 2. The repos/rpms from satellite should be synced to satellite """ env_name = get_entity_data(self.__class__.__name__)['env_name'] org_name = (entities.Organization().search( query={'search': 'id={}'.format(self.org_id)})[0].label) capsule = entities.SmartProxy().search( query={'search': 'name={}'.format(self.cap_host)})[0] call_entity_method_with_timeout( entities.Capsule(id=capsule.id).content_sync, timeout=3600) result = execute( lambda: run('[ -f /var/lib/pulp/published/yum/http/repos/' '{0}/{1}/{2}/custom/{3}/{4}/Packages/b/{5} ]; echo $?'. format(org_name, env_name, self.cv_name, self. prod_name, self.repo_name, self.rpm_name)), host=self.cap_host, )[self.cap_host] self.assertEqual('0', result)
def test_post_user_scenario_capsule_sync(self): """Post-upgrade scenario that sync capsule from satellite and then verifies if the repo/rpm of pre-upgrade scenario is synced to capsule :id: postupgrade-eb8970fa-98cc-4a99-99fb-1c12c4e319c9 :steps: 1. Run capsule sync post upgrade. 2. Check if the repo/rpm is been synced to capsule. :expectedresults: 1. The capsule sync should be successful 2. The repos/rpms from satellite should be synced to satellite """ env_name = get_entity_data(self.__class__.__name__)['env_name'] org_name = entities.Organization().search( query={'search': 'id={}'.format(self.org_id)})[0].label capsule = entities.SmartProxy().search( query={'search': 'name={}'.format(self.cap_host)})[0] entities.Capsule(id=capsule.id).content_sync() result = execute( lambda: run( '[ -f /var/lib/pulp/published/yum/http/repos/' '{0}/{1}/{2}/custom/{3}/{4}/Packages/b/{5} ]; echo $?'.format( org_name, env_name, self.cv_name, self.prod_name, self.repo_name, self.rpm_name)), host=self.cap_host )[self.cap_host] self.assertEqual('0', result)
def test_post_scenario_remoteexecution_satellite(self): """Run a REX job on pre-upgrade created client registered with Satellite. :id: postupgrade-ad3b1564-d3e6-4ada-9337-3a6ee6863bae :steps: 1. Run a REX job on content host. :expectedresults: 1. The job should successfully executed on pre-upgrade created client. """ client_name = get_entity_data(self.__class__.__name__)['client_name'] job = entities.JobInvocation().run( data={ 'job_template_id': 89, 'inputs': { 'command': "ls" }, 'targeting_type': 'static_query', 'search_query': f"name = {client_name}", }) self.assertEqual(job['output']['success_count'], 1) cleanup_of_provisioned_server(hostname=client_name, provisioning_server=self.libvirt_vm, distro=DISTRO_RHEL7)
def test_post_scenario_remoteexecution_external_capsule(self): """Run a REX job on pre-upgrade created client registered with external capsule. :id: postupgrade-00ed2a25-b0bd-446f-a3fc-09149c57fe94 :steps: 1. Run a REX job on content host. :expectedresults: 1. The job should successfully executed on pre-upgrade created client. """ client_name = get_entity_data(self.__class__.__name__)['client_name'] job = entities.JobInvocation().run( data={ 'job_template_id': 89, 'inputs': { 'command': "ls" }, 'targeting_type': 'static_query', 'search_query': "name = {0}".format(client_name) }) self.assertEqual(job['output']['success_count'], 1) cleanup_of_provisioned_server(hostname=client_name, provisioning_server=self.libvirt_vm, distro=DISTRO_RHEL7)
def test_post_scenario_preclient_package_installation(self): """Post-upgrade scenario that installs the package on pre-upgrade client remotely and then verifies if the package installed :id: postupgrade-eedab638-fdc9-41fa-bc81-75dd2790f7be :steps: Install package on a pre-upgrade client :expectedresults: The package is installed in client """ client = get_entity_data(self.__class__.__name__) client_name = str(client.keys()[0]).lower() client_id = entities.Host().search( query={'search': 'name={}'.format(client_name)} )[0].id entities.Host().install_content(data={ 'organization_id': self.org.id, 'included': {'ids': [client_id]}, 'content_type': 'package', 'content': [self.package_name], }) # Holding on for 20 seconds to let the package install time.sleep(20) # Validate if that package is really installed installed_package = execute( docker_execute_command, client.values()[0], 'rpm -q {}'.format(self.package_name), host=self.docker_vm )[self.docker_vm] self.assertIn(self.package_name, installed_package)
def test_post_scenario_generate_errata_with_previous_version_katello_agent_client( self): """Post-upgrade scenario that installs the package on pre-upgraded client remotely and then verifies if the package installed and errata counts. :id: postupgrade-b61f8f5a-44a3-4d3e-87bb-fc399e03ba6f :steps: 1. Recovered pre_upgrade data for post_upgrade verification. 2. Verifying errata count has not changed on satellite. 3. Restart goferd/Katello-agent running. 4. Verifying the errata_ids. 5. Verifying installation errata passes successfully. 6. Verifying that package installation passed successfully by remote docker exec. :expectedresults: 1. errata count, erratum list should same after satellite upgrade. 2. Installation of errata should be pass successfully and check errata counts is 0. """ entity_data = get_entity_data(self.__class__.__name__) client = entity_data.get('rhel_client') client_container_id = list(client.values())[0] custom_repo_id = entity_data.get('custom_repo_id') custom_yum_repo = entities.Repository(id=custom_repo_id).read() activation_key = entity_data.get('activation_key') host = entities.Host().search( query={'search': f'activation_key={activation_key}'})[0] installable_errata_count = host.content_facet_attributes[ 'errata_counts']['total'] assert installable_errata_count > 1 erratum_list = entities.Errata(repository=custom_yum_repo).search( query={ 'order': 'updated ASC', 'per_page': 1000 }) errata_ids = [errata.errata_id for errata in erratum_list] assert sorted(errata_ids) == sorted(settings.repos.yum_9.errata) for errata in settings.repos.yum_9.errata: host.errata_apply(data={'errata_ids': [errata]}) for package in FAKE_9_YUM_UPDATED_PACKAGES: install_or_update_package(client_hostname=client_container_id, package=package) # waiting for errata count to become 0, as profile uploading take some # amount of time wait_for( lambda: self._errata_count(ak=activation_key) == 0, timeout=400, delay=2, logger=logger, ) assert self._errata_count(ak=activation_key) == 0
def test_post_sync_plan_migration(self): """Post-upgrade scenario that tests existing sync plans are working as expected after satellite upgrade with migrating from pulp to katello :id: badaeec2-d42f-41d5-bd85-4b23d6d5a724 :steps: 1. Verify sync plan exists and works as earlier :expectedresults: Post Upgrade, Sync plans exists and works as earlier. """ entity_data = get_entity_data(self.__class__.__name__) org = entities.Organization(id=entity_data.get('org_id')) product = entities.Product(id=entity_data.get("product_id")).read() sync_plan = entities.SyncPlan(id=entity_data.get("sync_plan_id"), organization=org).read() self.assertEqual(product.sync_plan.id, sync_plan.id) self.assertEqual(sync_plan.name, entity_data.get("sync_plan_name")) self.assertEqual(sync_plan.interval, entity_data.get("interval")) self.assertEqual(sync_plan.sync_date, entity_data.get("sync_date")) # checking sync plan update on upgraded satellite sync_plan.interval = SYNC_INTERVAL['custom'] sync_plan.cron_expression = gen_choice(valid_cron_expressions()) self.assertEqual( sync_plan.update(['interval', 'cron_expression']).interval, SYNC_INTERVAL['custom']) # checking sync plan delete on upgraded satellite sync_plan.delete() product = product.read() self.assertIsNone(product.sync_plan) with self.assertRaises(HTTPError): sync_plan.read()
def test_post_version_cv_export_import(self): """Export and Import cv version created before upgrade :id: postupgrade-f19e4928-94db-4df6-8ce8-b5e4afe34258 :steps: Export and Import the Content Views version created before upgrade :expectedresults: Content-view created before upgrade should be exported and imported after upgrade """ prescene_dict = get_entity_data(self.__class__.__name__) exporting_cv = entities.ContentView( organization=prescene_dict['exporting_orgid']).search(query={ 'search': 'name={}'.format(prescene_dict['exporting_cvname']) })[0] exporting_cvv_id = max([cvv.id for cvv in exporting_cv.version]) exporting_cvv_version = entities.ContentViewVersion( id=exporting_cvv_id).read().version ContentView.version_export({ 'export-dir': '{}'.format(self.export_base), 'id': exporting_cvv_id }) exported_tar = '{0}/export-{1}-{2}.tar'.format(self.export_base, exporting_cv.name, exporting_cvv_version) result = ssh.command("[ -f {0} ]".format(exported_tar)) self.assertEqual(result.return_code, 0) exported_packages = Package.list( {'content-view-version-id': exporting_cvv_id}) self.assertTrue(len(exported_packages) > 0) self.set_importing_org( prescene_dict['exporting_prodname'], prescene_dict['exporting_reponame'], exporting_cv.name, ) ContentView.version_import({ 'export-tar': exported_tar, 'organization-id': self.importing_org.id }) importing_cvv = self.importing_cv.read().version self.assertTrue(len(importing_cvv) == 1) imported_packages = Package.list( {'content-view-version-id': importing_cvv[0].id}) self.assertTrue(len(imported_packages) > 0) self.assertEqual(len(exported_packages), len(imported_packages)) self.tearDownScenario()
def test_post_scenario_custom_repo_check(self, default_sat): """This is post-upgrade scenario test to verify if we can alter the created custom repository and satellite will be able to sync back the repo. :id: postupgrade-5c793577-e573-46a7-abbf-b6fd1f20b06e :steps: 1. Remove old and add new package into custom repo. 2. Sync repo , publish the new version of cv. 3. Try to install new package on client. :expectedresults: Content host should able to pull the new rpm. """ entity_data = get_entity_data(self.__class__.__name__) client = entity_data.get('rhel_client') client_container_id = list(client.values())[0] content_view_name = entity_data.get('content_view_name') lce_id = entity_data.get('lce_id') lce_name = entity_data.get('lce_name') org_label = entity_data.get('org_label') prod_label = entity_data.get('prod_label') repo_name = entity_data.get('repo_name') create_repo(rpm2, FILE_PATH, post_upgrade=True, other_rpm=rpm1) repo = default_sat.api.Repository(name=repo_name).search()[0] repo.sync() content_view = default_sat.api.ContentView( name=content_view_name).search()[0] content_view.publish() content_view = default_sat.api.ContentView( name=content_view_name).search()[0] promote(content_view.version[-1], lce_id) result = default_sat.execute( 'ls /var/lib/pulp/published/yum/https/repos/{}/{}/{}/custom/{}/{}/' 'Packages/c/| grep {}'.format(org_label, lce_name, content_view.label, prod_label, repo.label, RPM2_NAME)) assert result.status == 0 assert len(result.stdout) install_or_update_package(client_hostname=client_container_id, package=RPM2_NAME)
def test_post_subscription_scenario_autoattach(self): """Run subscription auto-attach on pre-upgrade content host registered with Satellite. :id: postupgrade-940fc78c-ffa6-4d9a-9c4b-efa1b9480a22 :steps: 1. Run subscription auto-attach on content host. :expectedresults: 1. Pre-upgrade content host should get Subscribed. """ client_container_id = get_entity_data(self.__class__.__name__)['client_container_id'] subscription = execute(docker_execute_command, client_container_id, 'subscription-manager attach --auto', host=self.docker_vm)[self.docker_vm] self.assertIn('Subscribed', subscription)
def test_post_scenario_custom_repo_check(self): """This is post-upgrade scenario test to verify if we can alter the created custom repository and satellite will be able to sync back the repo. :id: postupgrade-5c793577-e573-46a7-abbf-b6fd1f20b06e :steps: 1. Remove old and add new package into custom repo. 2. Sync repo , publish the new version of cv. 3. Try to install new package on client. :expectedresults: Content host should able to pull the new rpm. """ entity_data = get_entity_data(self.__class__.__name__) client = entity_data.get('rhel_client') client_container_id = list(client.values())[0] content_view_name = entity_data.get('content_view_name') lce_id = entity_data.get('lce_id') lce_name = entity_data.get('lce_name') org_label = entity_data.get('org_label') prod_label = entity_data.get('prod_label') repo_name = entity_data.get('repo_name') self._create_repo(post_upgrade=True) repo = entities.Repository(name=repo_name).search()[0] repo.sync() content_view = entities.ContentView(name=content_view_name).search()[0] content_view.publish() content_view = entities.ContentView(name=content_view_name).search()[0] promote(content_view.version[-1], lce_id) result = ssh.command( 'ls /var/lib/pulp/published/yum/https/repos/{}/{}/{}/custom/{}/{}/' 'Packages/c/| grep {}'.format(org_label, lce_name, content_view.label, prod_label, repo.label, self.rpm2_name)) self.assertEqual(result.return_code, 0) self.assertGreaterEqual(len(result.stdout), 1) self._install_package(client_container_id, self.rpm2_name)
def test_post_puppet_class_parameter_data_and_type(self): """Puppet Class Parameters value and type is intact post upgrade :steps: Postupgrade, Verify the value and type of updated parameters :expectedresults: The puppet class parameters data and type should be intact post upgrade """ for count in range(1, 10): with self.subTest(count): data = _valid_sc_parameters_data()[count-1] sc_param = entities.SmartClassParameters().search(query={ 'search': 'parameter="api_classparameters_scp_00{}"'.format( count)})[0] self.assertEqual(sc_param.parameter_type, data['sc_type']) self._validate_value(data, sc_param) puppet_class = get_entity_data(self.__class__.__name__)['puppet_class'] delete_puppet_class(puppet_class)
def test_post_scenario_remoteexecution_satellite(self): """Run a REX job on pre-upgrade created client registered with Satellite. :id: postupgrade-ad3b1564-d3e6-4ada-9337-3a6ee6863bae :steps: 1. Run a REX job on content host. :expectedresults: 1. The job should successfully executed on pre-upgrade created client. """ client_name = get_entity_data(self.__class__.__name__)['client_name'] job = entities.JobInvocation().run(data={ 'job_template_id': 89, 'inputs': {'command': "ls"}, 'targeting_type': 'static_query', 'search_query': "name = {0}".format(client_name)}) self.assertEqual(job['output']['success_count'], 1) self._vm_cleanup(hostname=client_name)
def test_post_scenario_remoteexecution_external_capsule(self): """Run a REX job on pre-upgrade created client registered with external capsule. :id: postupgrade-00ed2a25-b0bd-446f-a3fc-09149c57fe94 :steps: 1. Run a REX job on content host. :expectedresults: 1. The job should successfully executed on pre-upgrade created client. """ client_name = get_entity_data(self.__class__.__name__)['client_name'] job = entities.JobInvocation().run(data={ 'job_template_id': 89, 'inputs': {'command': "ls"}, 'targeting_type': 'static_query', 'search_query': "name = {0}".format(client_name)}) self.assertEqual(job['output']['success_count'], 1) self._vm_cleanup(hostname=client_name)
def test_post_scenario_yum_plugins_count(self, default_org): """Upgrade katello agent on pre-upgrade content host registered with Satellite. :id: postupgrade-45241ada-c2c4-409e-a6e2-92c2cf0ac16c :steps: 1. Create Product, custom tools repo and sync them. 2. Add in content-view and publish it. 3. Attach custom subscription to content host. 4. Install katello-host-tools, so enabled_repos_upload yum plugin is enabled. 4. Update katello-agent and Restart goferd. 5. Check yum plugins count. :expectedresults: 1. Loaded yum plugins should not load more than two times. """ entity_data = get_entity_data(self.__class__.__name__) client = entity_data.get('rhel_client') client_container_id = list(client.values())[0] client_container_name = list(client.keys())[0] cv = entities.ContentView(id=entity_data.get('cv_id')).read() product = entities.Product(organization=default_org).create() tools_repo = self._create_custom_tools_repos(product) product.sync() cv.repository.pop() cv.repository.append(tools_repo) cv = cv.update(['repository']) call_entity_method_with_timeout(cv.publish, timeout=3400) attach_custom_product_subscription(prod_name=product.name, host_name=client_container_name) install_or_update_package(client_hostname=client_container_id, update=True, package='katello-host-tools') install_or_update_package(client_hostname=client_container_id, update=True, package='katello-agent') run_goferd(client_hostname=client_container_id) self._check_yum_plugins_count(client_container_id)
def test_post_repository_scenario_upstream_authorization(self): """Verify upstream username for pre-upgrade created repository. :id: postupgrade-11c5ceee-bfe0-4ce9-8f7b-67a835baf522 :steps: 1. Verify upstream username for pre-upgrade created repository using foreman-rake. :expectedresults: 1. upstream username should not exists on same repository. :BZ: 1641785 """ repo_id = get_entity_data(self.__class__.__name__)['repo_id'] rake_repo = f'repo = Katello::RootRepository.find_by_id({repo_id})' rake_username = '******' result = run(f"echo '{rake_repo}{rake_username}'|foreman-rake console") assert UPSTREAM_USERNAME not in result
def test_post_repository_scenario_upstream_authorization(self): """ Verify upstream username for pre-upgrade created repository. :id: postupgrade-11c5ceee-bfe0-4ce9-8f7b-67a835baf522 :steps: 1. Verify upstream username for pre-upgrade created repository using foreman-rake. :expectedresults: 1. upstream username should not exists on same repository. :BZ: 1641785 """ repo_id = get_entity_data(self.__class__.__name__)['repo_id'] rake_repo = 'repo = Katello::RootRepository.find_by_id({0})'.format(repo_id) rake_username = '******' result = run("echo '{0}{1}'|foreman-rake console".format(rake_repo, rake_username)) self.assertNotIn(self.upstream_username, result)
def test_post_scenario_remoteexecution_satellite(self): """Run a REX job on pre-upgrade created client registered with Satellite. :id: postupgrade-ad3b1564-d3e6-4ada-9337-3a6ee6863bae :steps: 1. Run a REX job on content host. :expectedresults: 1. The job should successfully executed on pre-upgrade created client. """ client_name = get_entity_data(self.__class__.__name__)['client_name'] job = entities.JobInvocation().run( data={ 'job_template_id': 89, 'inputs': {'command': 'ls'}, 'targeting_type': 'static_query', 'search_query': f'name = {client_name}', } ) assert job['output']['success_count'] == 1
def test_post_repository_scenario_upstream_authorization(self): """ Verify upstream username for pre-upgrade created repository. :id: postupgrade-11c5ceee-bfe0-4ce9-8f7b-67a835baf522 :steps: 1. Verify upstream username for pre-upgrade created repository using foreman-rake. :expectedresults: 1. upstream username should not exists on same repository. :BZ: 1641785 """ repo_id = get_entity_data(self.__class__.__name__)['repo_id'] rake_repo = 'repo = Katello::RootRepository.find_by_id({0})'.format( repo_id) rake_username = '******' result = run("echo '{0}{1}'|foreman-rake console".format( rake_repo, rake_username)) self.assertNotIn(self.upstream_username, result)
def test_post_scenario_remoteexecution_external_capsule(self): """Run a REX job on pre-upgrade created client registered with external capsule. :id: postupgrade-00ed2a25-b0bd-446f-a3fc-09149c57fe94 :steps: 1. Run a REX job on content host. :expectedresults: 1. The job should successfully executed on pre-upgrade created client. """ client_name = get_entity_data(self.__class__.__name__)['client_name'] job = entities.JobInvocation().run( data={ 'job_template_id': 89, 'inputs': {'command': 'ls'}, 'targeting_type': 'static_query', 'search_query': f'name = {client_name}', } ) assert job['output']['success_count'] == 1
def test_post_create_gce_cr_and_host(self, arch_os_domain, delete_host): """""" arch, os, domain_name = arch_os_domain hostname = gen_string('alpha') self.__class__.fullhost = f'{hostname}.{domain_name}'.lower() preentities = get_entity_data(self.__class__.__name__) gce_cr = entities.GCEComputeResource().search( query={'search': f'name={preentities["cr_name"]}'})[0] org = entities.Organization().search( query={'search': f'name={preentities["org"]}'})[0] loc = entities.Location().search( query={'search': f'name={preentities["loc"]}'})[0] compute_attrs = { 'machine_type': 'g1-small', 'network': 'default', 'associate_external_ip': True, 'volumes_attributes': { '0': { 'size_gb': '10' } }, 'image_id': LATEST_RHEL7_GCE_IMG_UUID, } # Host Provisioning Tests try: skip_yum_update_during_provisioning( template='Kickstart default finish') gce_hst = entities.Host( name=hostname, organization=org, location=loc, root_pass=gen_string('alphanumeric'), architecture=arch, compute_resource=gce_cr, domain=entities.Domain().search( query={'search': f'name={domain_name}'})[0], compute_attributes=compute_attrs, operatingsystem=os, provision_method='image', ).create() finally: skip_yum_update_during_provisioning( template='Kickstart default finish', reverse=True) wait_for( lambda: entities.Host().search(query={ 'search': f'name={self.fullhost}' })[0].build_status_label == 'Installed', timeout=400, delay=15, silent_failure=True, handle_exception=True, ) assert gce_hst.name == self.fullhost gce_hst = entities.Host(id=gce_hst.id).read() assert gce_hst.build_status_label == 'Installed' # CR Manipulation Tests newgce_name = gen_string('alpha') newgce_zone = random.choice(VALID_GCE_ZONES) gce_cr.name = newgce_name gce_cr.zone = newgce_zone gce_cr.update(['name', 'zone']) gce_cr = entities.GCEComputeResource(id=gce_cr.id).read() assert gce_cr.name == newgce_name assert gce_cr.zone == newgce_zone
def test_post_user_scenario_bug_1429201(self): """This is post-upgrade scenario test to verify if we can alter the created custom repository and satellite will be able to sync back the repo :id: 9415c3e5-4699-462f-81bc-4143d8b820f1 :steps: 1. Remove PackageFoo-1.0.rpm from RepoFoo 2. Add PackageFoo-2.0.rpm to RepoFoo 3. Sync RepoFoo 4. Publish version 2 of CVFoo 5. Delete version 1 of CVFoo 6. run /etc/cron.weekly/katello-remove-orphans 7. Subscribe ClientA to CVFoo 8. Try to install PackageFoo-1.0.rpm on ClientA 9. Notice that yum thinks it's there based on the repo metadata but then fails to download it with 404 10. Try to install PackageFoo-2.0.rpm :expectedresults: The clients is present after upgrade and deleted rpm is unable to be fetched, while new rpm is pulled and installed on client :BZ: 1429201 """ entity_data = get_entity_data(self.__class__.__name__) run('wget {0} -P {1}'.format(rpm2, self.file_path)) run('rm -rf {0}'.format(self.file_path + self.rpm1_name)) run('createrepo --update {0}'.format(self.file_path)) # get entities from pickle pkcl_ak_name = entity_data['ak_name'] container_ids = entity_data['container_ids'] repo_name = entity_data['repo_name'] prd_name = entity_data['prd_name'] cv_name, lc_name = hammer.hammer_determine_cv_and_env_from_ak( pkcl_ak_name, self.org_id) # Info on created entities to assert the test case using hammer info ak_info = hammer.hammer('"{0}" info --name "{1}" --organization-id ' '{2}'.format('activation-key', pkcl_ak_name, self.org_id)) print( hammer.hammer_repository_synchronize(repo_name, self.org_id, prd_name)) print(hammer.hammer_content_view_publish(cv_name, self.org_id)) latest_repo_version = hammer.get_latest_cv_version(cv_name) result = hammer.hammer('"{0}" info --name "{1}" --organization-id ' '{2}'.format('lifecycle-environment', lc_name, self.org_id)) lifecycle_id = hammer.get_attribute_value(result, lc_name, 'id') print( hammer.hammer_content_view_promote_version(cv_name, latest_repo_version, lifecycle_id, self.org_id)) hammer.hammer('content-view remove --content-view-version-ids {0}' ' --name "{1}" --organization-id {2}'.format( latest_repo_version, cv_name, self.org_id)) run('foreman-rake katello:delete_orphaned_content') execute(refresh_subscriptions_on_docker_clients, list(container_ids.values()), host=self.docker_vm) # Subscription manager needs time to register execute(docker_wait_until_repo_list, list(container_ids.values())[0], host=self.docker_vm) result_fail = execute(docker_execute_command, list(container_ids.values())[0], 'yum list {0} | grep {0}'.format( self.rpm1_name.split('-')[0]), quiet=True, host=self.docker_vm) # should be error result_pass = execute(docker_execute_command, list(container_ids.values())[0], 'yum install -y {0}'.format( self.rpm2_name.split('-')[0]), host=self.docker_vm) # should be successful self.assertEqual( pkcl_ak_name, hammer.get_attribute_value(ak_info, pkcl_ak_name, 'name')) self.assertIsNotNone(container_ids) self.assertIn('Error', list(result_fail.values())[0]) self.assertIn('Complete', list(result_pass.values())[0])
def test_post_scenario_errata_count_installation(self): """Post-upgrade scenario that installs the package on pre-upgrade client remotely and then verifies if the package installed. :id: 88fd28e6-b4df-46c0-91d6-784859fd1c21 :steps: 1. Recovered pre_upgrade data for post_upgrade verification 2. Verifying errata count has not changed on satellite 3. Update Katello-agent and Restart goferd 4. Verifying the errata_ids 5. Verifying installation errata passes successfully 6. Verifying that package installation passed successfully by remote docker exec :expectedresults: 1. errata count, erratum list should same after satellite upgrade 2. Installation of errata should be pass successfully """ entity_data = get_entity_data(self.__class__.__name__) client = entity_data.get('rhel_client') client_container_id = list(client.values())[0] custom_repo_id = entity_data.get('custom_repo_id') product_id = entity_data.get('product_id') conten_view_id = entity_data.get('conten_view_id') product = entities.Product(id=product_id).read() content_view = entities.ContentView(id=conten_view_id).read() custom_yum_repo = entities.Repository(id=custom_repo_id).read() activation_key = entity_data.get('activation_key') host = entities.Host().search( query={'search': f'activation_key={activation_key}'})[0] installable_errata_count = host.content_facet_attributes[ 'errata_counts']['total'] tools_repo, rhel_repo = self._create_custom_rhel_tools_repos(product) call_entity_method_with_timeout(product.sync, timeout=1400) for repo in (tools_repo, rhel_repo): content_view.repository.append(repo) content_view = content_view.update(['repository']) content_view.publish() install_or_update_package(client_hostname=client_container_id, update=True, package="katello-agent") run_goferd(client_hostname=client_container_id) assert installable_errata_count > 1 erratum_list = entities.Errata(repository=custom_yum_repo).search( query={ 'order': 'updated ASC', 'per_page': 1000 }) errata_ids = [errata.errata_id for errata in erratum_list] assert sorted(errata_ids) == sorted(settings.repos.yum_9.errata) for errata in settings.repos.yum_9.errata: host.errata_apply(data={'errata_ids': [errata]}) installable_errata_count -= 1 # waiting for errata count to become 0, as profile uploading take some # amount of time wait_for( lambda: self._errata_count(ak=activation_key) == 0, timeout=400, delay=2, logger=logger, ) host = entities.Host().search( query={'search': f'activation_key={activation_key}'})[0] assert host.content_facet_attributes['errata_counts']['total'] == 0 for package in FAKE_9_YUM_UPDATED_PACKAGES: install_or_update_package(client_hostname=client_container_id, package=package)
def test_post_user_scenario_bug_1429201(self): """This is post-upgrade scenario test to verify if we can alter the created custom repository and satellite will be able to sync back the repo :id: 9415c3e5-4699-462f-81bc-4143d8b820f1 :steps: 1. Remove PackageFoo-1.0.rpm from RepoFoo 2. Add PackageFoo-2.0.rpm to RepoFoo 3. Sync RepoFoo 4. Publish version 2 of CVFoo 5. Delete version 1 of CVFoo 6. run /etc/cron.weekly/katello-remove-orphans 7. Subscribe ClientA to CVFoo 8. Try to install PackageFoo-1.0.rpm on ClientA 9. Notice that yum thinks it's there based on the repo metadata but then fails to download it with 404 10. Try to install PackageFoo-2.0.rpm :expectedresults: The clients is present after upgrade and deleted rpm is unable to be fetched, while new rpm is pulled and installed on client :BZ: 1429201 """ entity_data = get_entity_data(self.__class__.__name__) run('wget {0} -P {1}'.format(rpm2, self.file_path)) run('rm -rf {0}'.format(self.file_path + self.rpm1_name)) run('createrepo --update {0}'.format(self.file_path)) # get entities from pickle pkcl_ak_name = entity_data['ak_name'] container_ids = entity_data['container_ids'] repo_name = entity_data['repo_name'] prd_name = entity_data['prd_name'] cv_name, lc_name = hammer.hammer_determine_cv_and_env_from_ak( pkcl_ak_name, self.org_id ) # Info on created entities to assert the test case using hammer info ak_info = hammer.hammer( '"{0}" info --name "{1}" --organization-id ' '{2}'.format('activation-key', pkcl_ak_name, self.org_id) ) print(hammer.hammer_repository_synchronize( repo_name, self.org_id, prd_name )) print(hammer.hammer_content_view_publish(cv_name, self.org_id)) latest_repo_version = hammer.get_latest_cv_version(cv_name) result = hammer.hammer( '"{0}" info --name "{1}" --organization-id ' '{2}'.format('lifecycle-environment', lc_name, self.org_id) ) lifecycle_id = hammer.get_attribute_value(result, lc_name, 'id') print(hammer.hammer_content_view_promote_version( cv_name, latest_repo_version, lifecycle_id, self.org_id )) hammer.hammer( 'content-view remove --content-view-version-ids {0}' ' --name "{1}" --organization-id {2}'.format( latest_repo_version, cv_name, self.org_id ) ) run('foreman-rake katello:delete_orphaned_content') execute(refresh_subscriptions_on_docker_clients, list(container_ids.values()), host=self.docker_vm ) # Subscription manager needs time to register execute(docker_wait_until_repo_list, list(container_ids.values())[0], host=self.docker_vm) result_fail = execute( docker_execute_command, list(container_ids.values())[0], 'yum list {0} | grep {0}'.format(self.rpm1_name.split('-')[0]), quiet=True, host=self.docker_vm ) # should be error result_pass = execute( docker_execute_command, list(container_ids.values())[0], 'yum install -y {0}'.format(self.rpm2_name.split('-')[0]), host=self.docker_vm ) # should be successful self.assertEqual( pkcl_ak_name, hammer.get_attribute_value(ak_info, pkcl_ak_name, 'name') ) self.assertIsNotNone(container_ids) self.assertIn('Error', list(result_fail.values())[0]) self.assertIn('Complete', list(result_pass.values())[0])
def _cleanup(): puppet_class = get_entity_data( self.__class__.__name__)['puppet_class'] delete_puppet_class(puppet_class)
def test_post_scenario_containers_support_removal(self): """Post-upgrade scenario test to verify containers created and run before upgrade are still running after upgrade. :id: postupgrade-f6de07ae-14c7-4452-9cb1-cafe2aa648ae :steps: 1. Verify that upgrade procedure removed foreman_docker support 2. Verify container from dockerhub is still running 3. Verify container from external registry is still running :expectedresults: 1. Upgrade procedure removed support for foreman_docker 2. Container from dockerhub is still running 3. Container from external registry is still running """ entity_data = get_entity_data(self.__class__.__name__) rh_registry_available = entity_data.get('rh_registry_available') docker_host_hostname = entity_data.get('docker_host') dockerhub_container = entity_data.get('dockerhub_container') external_container = entity_data.get('external_container') try: extract_log_command = "sed -n '/{delimiter}/,/{delimiter}/p' {path}".format( delimiter="RemoveForemanDockerSupport", path="/var/log/foreman-installer/satellite.log") docker_log = ssh.command(extract_log_command, output_format='plain') self.assertEqual(docker_log.return_code, 0) docker_log = docker_log.stdout.split("\n") self.assertTrue( any("RemoveForemanDockerSupport: migrated" in line for line in docker_log)) self.assertTrue( any("remove_column(:containers, :capsule_id)" in line for line in docker_log)) removed_tables = ('docker_images', 'docker_tags', 'docker_container_wizard_states_images', 'containers') for table in removed_tables: self.assertTrue( any("table_exists?(:{})".format(table) in line for line in docker_log)) running_containers = ssh.command('docker ps', hostname=docker_host_hostname) self.assertEqual(running_containers.return_code, 0) self.assertTrue( any(dockerhub_container in line for line in running_containers.stdout)) if rh_registry_available: self.assertTrue( any(external_container in line for line in running_containers.stdout)) except Exception as exp: self._vm_cleanup(hostname=docker_host_hostname) raise Exception(exp) self._vm_cleanup(hostname=docker_host_hostname)
def test_post_scenario_errata_count_installtion(self): """Post-upgrade scenario that installs the package on pre-upgrade client remotely and then verifies if the package installed. :id: 88fd28e6-b4df-46c0-91d6-784859fd1c21 :steps: 1. Recovered pre_upgrade data for post_upgrade verification 2. Verifying errata count has not changed on satellite 3. Update Katello-agent and Restart goferd 4. Verifying the errata_ids 5. Verifying installation errata passes successfully 6. Verifying that package installation passed successfully by remote docker exec :expectedresults: 1. errata count, erratum list should same after satellite upgrade 2. Installation of errata should be pass successfully """ entity_data = get_entity_data(self.__class__.__name__) client = entity_data.get('rhel_client') client_container_id = list(client.values())[0] custom_repo_id = entity_data.get('custom_repo_id') product_id = entity_data.get('product_id') conten_view_id = entity_data.get('conten_view_id') product = entities.Product(id=product_id).read() content_view = entities.ContentView(id=conten_view_id).read() custom_yum_repo = entities.Repository(id=custom_repo_id).read() activation_key = entity_data.get('activation_key') host = entities.Host().search( query={'search': 'activation_key={0}'.format(activation_key)})[0] applicable_errata_count = host.content_facet_attributes[ 'errata_counts']['total'] tools_repo, rhel_repo = self._create_custom_rhel_tools_repos(product) product.sync() for repo in (tools_repo, rhel_repo): content_view.repository.append(repo) content_view = content_view.update(['repository']) content_view.publish() content_view = content_view.read() self._install_or_update_package(client_container_id, "katello-agent", update=True) self._run_goferd(client_container_id) self.assertGreater(applicable_errata_count, 1) erratum_list = entities.Errata(repository=custom_yum_repo).search( query={ 'order': 'updated ASC', 'per_page': 1000, }) errata_ids = [errata.errata_id for errata in erratum_list] self.assertEqual(sorted(errata_ids), sorted(FAKE_9_YUM_ERRATUM)) for errata in FAKE_9_YUM_ERRATUM: host.errata_apply(data={'errata_ids': [errata]}) applicable_errata_count -= 1 self.assertEqual( host.content_facet_attributes['errata_counts']['total'], 0) for package in FAKE_9_YUM_UPDATED_PACKAGES: self._check_package_installed(client_container_id, package)
def test_post_scenario_errata_count_installtion(self): """Post-upgrade scenario that installs the package on pre-upgrade client remotely and then verifies if the package installed. :id: 88fd28e6-b4df-46c0-91d6-784859fd1c21 :steps: 1. Recovered pre_upgrade data for post_upgrade verification 2. Verifying errata count has not changed on satellite 3. Update Katello-agent and Restart goferd 4. Verifying the errata_ids 5. Verifying installation errata passes successfully 6. Verifying that package installation passed successfully by remote docker exec :expectedresults: 1. errata count, erratum list should same after satellite upgrade 2. Installation of errata should be pass successfully """ entity_data = get_entity_data(self.__class__.__name__) client = entity_data.get('rhel_client') client_container_id = list(client.values())[0] custom_repo_id = entity_data.get('custom_repo_id') product_id = entity_data.get('product_id') conten_view_id = entity_data.get('conten_view_id') product = entities.Product(id=product_id).read() content_view = entities.ContentView(id=conten_view_id).read() custom_yum_repo = entities.Repository(id=custom_repo_id).read() activation_key = entity_data.get('activation_key') host = entities.Host().search(query={ 'search': 'activation_key={0}'.format(activation_key)})[0] installable_errata_count = host.content_facet_attributes[ 'errata_counts']['total'] tools_repo, rhel_repo = self._create_custom_rhel_tools_repos(product) product.sync() for repo in (tools_repo, rhel_repo): content_view.repository.append(repo) content_view = content_view.update(['repository']) content_view.publish() self._install_or_update_package(client_container_id, "katello-agent", update=True) self._run_goferd(client_container_id) self.assertGreater(installable_errata_count, 1) erratum_list = entities.Errata(repository=custom_yum_repo).search(query={ 'order': 'updated ASC', 'per_page': 1000, }) errata_ids = [errata.errata_id for errata in erratum_list] self.assertEqual(sorted(errata_ids), sorted(FAKE_9_YUM_ERRATUM)) for errata in FAKE_9_YUM_ERRATUM: host.errata_apply(data={'errata_ids': [errata]}) installable_errata_count -= 1 # waiting for errata count to become 0, as profile uploading take some amount of time wait_for( lambda: self._errata_count(ak=activation_key) == 0, timeout=200, delay=10, logger=self.logger ) self.assertEqual( host.content_facet_attributes['errata_counts']['total'], 0 ) for package in FAKE_9_YUM_UPDATED_PACKAGES: self._check_package_installed(client_container_id, package)