def test_redhat_sync_1(self): """@Test: Sync RedHat Repository. @Feature: Repositories @Assert: Repository synced should fetch the data successfully. """ cloned_manifest_path = manifests.clone() org_id = entities.Organization().create()['id'] repo = "Red Hat Enterprise Linux 6 Server - RH Common RPMs x86_64 6.3" task = entities.Organization( id=org_id).upload_manifest(path=cloned_manifest_path) self.assertEqual( u'success', task['result'], task['humanized']['errors'] ) repo_id = utils.enable_rhrepo_and_fetchid( "x86_64", org_id, "Red Hat Enterprise Linux Server", repo, "Red Hat Enterprise Linux 6 Server - RH Common (RPMs)", "6.3", ) task_result = entities.Repository(id=repo_id).sync()['result'] self.assertEqual( task_result, u'success', u"Sync for repository '{0}' failed.".format(repo))
def test_positive_delete_bz1225588(self, org_name): """@test: Create Organization with valid values and upload manifest. Then try to delete that organization. @feature: Organization Positive Delete Test. @assert: Organization is deleted successfully. """ org = entities.Organization(name=org_name).create() with open(manifests.clone(), 'rb') as manifest: upload_manifest(org.id, manifest) with Session(self.browser) as session: make_lifecycle_environment(session, org_name, name='DEV') make_lifecycle_environment( session, org_name, name='QE', prior='DEV' ) # Org cannot be deleted when selected, # So switching to Default Org and then deleting. session.nav.go_to_select_org('Default Organization') self.org.remove(org_name) status = self.org.search(org_name) if bz_bug_is_open(1251926): # Check for at max Five times, the org is deleted for _ in range(5): status = self.org.search(org_name) if status is None: break self.assertIsNone(status)
def test_sync_rhrepos(self): """@Test: Create Content RedHat Sync with two repos. @Feature: Content RedHat Sync - Positive Create @Assert: Whether Syncing RedHat Repos is successful """ repos = self.sync.create_repos_tree(RHCT) alert_loc = common_locators['alert.success'] path = clone() # upload_file function should take care of uploading to sauce labs. upload_file(path, remote_file=path) with Session(self.browser) as session: session.nav.go_to_select_org(self.org_name) session.nav.go_to_red_hat_subscriptions() self.subscriptions.upload(path) success_ele = session.nav.wait_until_element(alert_loc) self.assertTrue(success_ele) session.nav.go_to_red_hat_repositories() self.sync.enable_rh_repos(repos) session.nav.go_to_sync_status() sync = self.sync.sync_rh_repos(repos) # syn.sync_rh_repos returns boolean values and not objects self.assertTrue(sync)
def test_redhat_sync_1(self): """@Test: Sync RedHat Repository. @Feature: Repositories @Assert: Repository synced should fetch the data successfully. """ cloned_manifest_path = manifests.clone() org_id = entities.Organization().create()['id'] repo = "Red Hat Enterprise Linux 6 Server - RH Common RPMs x86_64 6.3" task = entities.Organization(id=org_id).upload_manifest( path=cloned_manifest_path) self.assertEqual(u'success', task['result'], task['humanized']['errors']) repo_id = utils.enable_rhrepo_and_fetchid( "x86_64", org_id, "Red Hat Enterprise Linux Server", repo, "Red Hat Enterprise Linux 6 Server - RH Common (RPMs)", "6.3", ) task_result = entities.Repository(id=repo_id).sync()['result'] self.assertEqual(task_result, u'success', u"Sync for repository '{0}' failed.".format(repo))
def test_repositoryset_disable_by_id(self): """@Test: Disable repo from reposet by IDs of reposet, org and product @Feature: Repository-set @Assert: Repository was disabled """ org = make_org() manifest = manifests.clone() upload_file(manifest, remote_file=manifest) result = Subscription.upload({ u'file': manifest, u'organization-id': org['id'], }) self.assertEqual(result.return_code, 0) product_id = Product.info({ u'name': PRDS['rhel'], u'organization-id': org['id'], }).stdout['id'] reposet_id = RepositorySet.info({ u'name': REPOSET['rhva6'], u'organization-id': org['id'], u'product-id': product_id, }).stdout['id'] result = RepositorySet.enable({ u'id': reposet_id, u'organization-id': org['id'], u'product-id': product_id, u'releasever': '6Server', u'basearch': 'x86_64', }) self.assertEqual(result.return_code, 0) result = RepositorySet.disable({ u'id': reposet_id, u'organization-id': org['id'], u'product-id': product_id, u'releasever': '6Server', u'basearch': 'x86_64', }) self.assertEqual(result.return_code, 0) result = RepositorySet.available_repositories({ u'id': reposet_id, u'organization-id': org['id'], u'product-id': product_id, }) self.assertEqual(result.return_code, 0) enabled = [ repo['enabled'] for repo in result.stdout if repo['arch'] == 'x86_64' and repo['release'] == '6Server' ][0] self.assertEqual(enabled, 'false')
def test_positive_create_1(self): """@Test: Upload a manifest. @Assert: Manifest is uploaded successfully @Feature: Subscriptions """ org = entities.Organization().create() with open(manifests.clone(), 'rb') as manifest: upload_manifest(org.id, manifest)
def test_positive_create_1(self): """@Test: Upload a manifest. @Assert: Manifest is uploaded successfully @Feature: Subscriptions """ cloned_manifest_path = manifests.clone() org_id = entities.Organization().create_json()['id'] entities.Organization(id=org_id).upload_manifest( path=cloned_manifest_path )
def test_positive_create_1(self): """@Test: Upload a manifest. @Assert: Manifest is uploaded successfully @Feature: Subscriptions """ cloned_manifest_path = manifests.clone() org_id = entities.Organization().create()['id'] task_result = entities.Organization(id=org_id).upload_manifest( path=cloned_manifest_path )['result'] self.assertEqual(u'success', task_result)
def test_positive_create_1(self): """@Test: Upload a manifest. @Assert: Manifest is uploaded successfully @Feature: Subscriptions """ cloned_manifest_path = manifests.clone() org_id = entities.Organization().create()['id'] task = entities.Organization(id=org_id).upload_manifest( path=cloned_manifest_path) self.assertEqual(u'success', task['result'], task['humanized']['errors'])
def test_negative_create_1(self): """@Test: Upload the same manifest to two organizations. @Assert: The manifest is not uploaded to the second organization. @Feature: Subscriptions """ orgs = [entities.Organization().create() for _ in range(2)] with open(manifests.clone(), 'rb') as manifest: upload_manifest(orgs[0].id, manifest) with self.assertRaises(TaskFailedError): upload_manifest(orgs[1].id, manifest) self.assertEqual( len(entities.Subscription(organization=orgs[1]).search()), 0)
def test_positive_delete_1(self): """@Test: Delete an Uploaded manifest. @Assert: Manifest is Deleted successfully @Feature: Subscriptions """ org = entities.Organization().create() sub = entities.Subscription(organization=org) with open(manifests.clone(), 'rb') as manifest: upload_manifest(org.id, manifest) self.assertGreater(len(sub.search()), 0) sub.delete_manifest(data={'organization_id': org.id}) self.assertEqual(len(sub.search()), 0)
def setup_to_create_cv(self, session, cv_name, repo_name=None, repo_url=None, repo_type=None, rh_repo=None): """Create product/repo and sync it and create CV""" cv_name = cv_name or gen_string("alpha", 8) if not rh_repo: repo_name = repo_name or gen_string("alpha", 8) # Creates new custom product via API's product_attrs = entities.Product( organization=self.org_id ).create() # Creates new custom repository via API's repo_attrs = entities.Repository( name=repo_name, url=(repo_url or FAKE_1_YUM_REPO), content_type=(repo_type or REPO_TYPE['yum']), product=product_attrs['id'], ).create() repo_id = repo_attrs['id'] elif rh_repo: # Clone the manifest and fetch it's path. manifest_path = manifests.clone() # Uploads the manifest and returns the result. task_result = entities.Organization( id=self.org_id ).upload_manifest(path=manifest_path)['result'] self.assertEqual(u'success', task_result) # Enables the RedHat repo and fetches it's Id. repo_id = utils.enable_rhrepo_and_fetchid( rh_repo['basearch'], str(self.org_id), # Org Id is passed as data in API hence str rh_repo['product'], rh_repo['name'], rh_repo['reposet'], rh_repo['releasever']) repo_name = rh_repo['name'] # Sync repository task_result = entities.Repository(id=repo_id).sync()['result'] self.assertEqual( task_result, u'success', u"Sync for repository {0} failed.".format(repo_name)) make_contentview(session, org=self.org_name, name=cv_name) self.assertIsNotNone(self.content_views.search(cv_name))
def setUpClass(cls): # noqa """Set up organization, product and repositories for tests.""" super(CVRedHatContent, cls).setUpClass() cls.org = entities.Organization().create() with open(manifests.clone(), "rb") as manifest: entities.Subscription().upload(data={"organization_id": cls.org.id}, files={"content": manifest}) repo_id = enable_rhrepo_and_fetchid( basearch="x86_64", org_id=cls.org.id, product=PRDS["rhel"], repo=REPOS["rhst7"]["name"], reposet=REPOSET["rhst7"], releasever=None, ) cls.repo = entities.Repository(id=repo_id) cls.repo.sync()
def test_import_orgs_manifests(self, test_data): """@test: Import all organizations from the default data set (predefined source) and upload manifests for each of them @feature: Import Organizations including Manifests @assert: 3 Organizations are created with 3 manifests uploaded """ files = dict(self.default_dataset[1]) files['users'] = update_csv_values( files['users'], u'organization_id', test_data, self.default_dataset[0] ) csv_records = csv_to_dataset([files['users']]) # create number of manifests corresponding to the number of orgs manifest_list = [] man_dir = ssh.command( u'mktemp -d -p {}'.format(self.default_dataset[0]) ).stdout[0] for org in set([rec['organization'] for rec in csv_records]): for char in [' ', '.', '#']: org = org.replace(char, '_') man_file = manifests.clone() ssh.upload_file(man_file, u'{0}/{1}.zip'.format(man_dir, org)) manifest_list.append(u'{0}/{1}.zip'.format(man_dir, org)) os.remove(man_file) ssh_import = Import.organization({ 'csv-file': files['users'], 'upload-manifests-from': man_dir, }) # now to check whether the orgs from csv appeared in satellite orgs = set(org['name'] for org in Org.list().stdout) imp_orgs = set( org['organization'] for org in csv_to_dataset([files['users']]) ) self.assertEqual(ssh_import.return_code, 0) self.assertTrue(imp_orgs.issubset(orgs)) for org in imp_orgs: manifest_history = Subscription.manifest_history( {'organization': org} ).stdout[3] self.assertIn('SUCCESS', manifest_history)
def setup_to_create_cv(self, repo_name=None, repo_url=None, repo_type=None, rh_repo=None, org_id=None): """Create product/repo and sync it""" if not rh_repo: repo_name = repo_name or gen_string("alpha", 8) # Creates new custom product via API's product_attrs = entities.Product( organization=org_id or self.org_id).create() # Creates new custom repository via API's repo_attrs = entities.Repository( name=repo_name, url=(repo_url or FAKE_1_YUM_REPO), content_type=(repo_type or REPO_TYPE['yum']), product=product_attrs['id'], ).create() repo_id = repo_attrs['id'] elif rh_repo: # Clone the manifest and fetch it's path. manifest_path = manifests.clone() # Uploads the manifest and returns the result. task = entities.Organization(id=org_id).upload_manifest( path=manifest_path) self.assertEqual(u'success', task['result'], task['humanized']['errors']) # Enables the RedHat repo and fetches it's Id. repo_id = utils.enable_rhrepo_and_fetchid( rh_repo['basearch'], str(org_id), # Org Id is passed as data in API hence str rh_repo['product'], rh_repo['name'], rh_repo['reposet'], rh_repo['releasever']) repo_name = rh_repo['name'] # Sync repository task_result = entities.Repository(id=repo_id).sync()['result'] self.assertEqual(task_result, u'success', u"Sync for repository {0} failed.".format(repo_name))
def test_positive_delete_1(self): """@Test: Delete an Uploaded manifest. @Assert: Manifest is Deleted successfully @Feature: Subscriptions """ cloned_manifest_path = clone() org_id = entities.Organization().create()['id'] task_id = entities.Organization(id=org_id).upload_manifest( path=cloned_manifest_path ) task_result = entities.ForemanTask(id=task_id).poll()['result'] self.assertEqual(u'success', task_result) task_id = entities.Organization(id=org_id).delete_manifest() task_result = entities.ForemanTask(id=task_id).poll()['result'] self.assertEqual(u'success', task_result)
def test_positive_upload_1(self): """@Test: Upload a manifest with minimal input parameters @Feature: Manifest/Subscription - Positive Create @Assert: Manifest is uploaded """ alert_loc = common_locators['alert.success'] manifest_path = manifests.clone() # upload_file function should take care of uploading to sauce labs. upload_file(manifest_path, remote_file=manifest_path) with Session(self.browser) as session: session.nav.go_to_select_org(self.org_name) session.nav.go_to_red_hat_subscriptions() self.subscriptions.upload(manifest_path) success_ele = self.subscriptions.wait_until_element(alert_loc) self.assertTrue(success_ele)
def test_sync_rh_repos(self): """@Test: Create Content RedHat Sync with two repos. @Feature: Content RedHat Sync - Positive Create @Assert: Whether Syncing RedHat Repos is successful """ repos = self.sync.create_repos_tree(RHCT) with open(manifests.clone(), "rb") as manifest: upload_manifest(self.organization.id, manifest) with Session(self.browser) as session: session.nav.go_to_select_org(self.organization.name) session.nav.go_to_red_hat_repositories() self.sync.enable_rh_repos(repos) session.nav.go_to_sync_status() sync = self.sync.sync_rh_repos(repos) # syn.sync_rh_repos returns boolean values and not objects self.assertTrue(sync)
def test_negative_create_1(self): """@Test: Upload same manifest to 2 different Organizations. @Assert: Manifest is not uploaded in the second Organization. @Feature: Subscriptions """ cloned_manifest_path = manifests.clone() orgid_one = entities.Organization().create()['id'] orgid_two = entities.Organization().create()['id'] task_result1 = entities.Organization( id=orgid_one ).upload_manifest(path=cloned_manifest_path)['result'] self.assertEqual(u'success', task_result1) task_result2 = entities.Organization( id=orgid_two ).upload_manifest(path=cloned_manifest_path)['result'] self.assertNotEqual(u'success', task_result2)
def test_negative_create_1(self): """@Test: Upload the same manifest to two organizations. @Assert: The manifest is not uploaded to the second organization. @Feature: Subscriptions """ manifest_path = manifests.clone() # Upload the manifest to one organization. org_id = entities.Organization().create_json()['id'] entities.Organization(id=org_id).upload_manifest(manifest_path) # Upload the manifest to a second organization. org = entities.Organization() org.id = org.create_json()['id'] org.upload_manifest(manifest_path) self.assertEqual([], org.subscriptions())
def test_add_subscription(self): """@Test: Test that subscription can be added to activation key @Feature: Activation key - Host @Steps: 1. Create Activation key 2. Upload manifest and add subscription 3. Associate the activation key to subscription @Assert: Subscription successfully added to activation key """ manifest = manifests.clone() upload_file(manifest, remote_file=manifest) try: org = make_org(cached=True) activation_key = self._make_activation_key({ u'organization-id': org['id'], }) result = Subscription.upload({ 'file': manifest, 'organization-id': self.org['id'], }) except CLIFactoryError as err: self.fail(err) subs_id = Subscription.list( {'organization-id': self.org['id']}, per_page=False) result = ActivationKey.add_subscription({ u'id': activation_key['id'], u'subscription-id': subs_id.stdout[0]['id'], }) self.assertEqual(result.return_code, 0, "return code must be 0, instead got {0}" ''.format(result.return_code)) self.assertEqual( len(result.stderr), 0, 'There should not be an error here') self.assertIn("Subscription added to activation key", result.stdout)
def test_positive_delete_1(self): """@Test: Upload a manifest and delete the manifest. @Feature: Manifest/Subscription - Positive Delete @Assert: Manifest is Deleted successfully """ alert_loc = common_locators["alert.success"] manifest_path = manifests.clone() # upload_file function should take care of uploading to sauce labs. upload_file(manifest_path, remote_file=manifest_path) with Session(self.browser) as session: session.nav.go_to_select_org(self.org_name) session.nav.go_to_red_hat_subscriptions() self.subscriptions.upload(manifest_path) self.subscriptions.delete() success_ele = self.subscriptions.wait_until_element(alert_loc) self.assertTrue(success_ele)
def test_negative_create_1(self): """@Test: Upload the same manifest to two organizations. @Assert: The manifest is not uploaded to the second organization. @Feature: Subscriptions """ manifest_path = manifests.clone() # Upload the manifest to one organization. org_id = entities.Organization().create_json()['id'] task = entities.Organization(id=org_id).upload_manifest(manifest_path) self.assertEqual('success', task['result'], task['humanized']['errors']) # Upload the manifest to a second organization. org = entities.Organization() org.id = org.create_json()['id'] self.assertNotEqual('success', org.upload_manifest(manifest_path)['result']) self.assertEqual([], org.subscriptions())
def test_assert_delete_button(self): """@Test: Upload and delete a manifest @Feature: Manifest/Subscription - Positive Delete @Assert: Manifest is Deleted. Delete button is asserted . Subscriptions is asserted """ alert_loc = common_locators["alert.success"] del_mf = locators["subs.delete_manifest"] manifest_path = manifests.clone() # upload_file function should take care of uploading to sauce labs. upload_file(manifest_path, remote_file=manifest_path) with Session(self.browser) as session: session.nav.go_to_select_org(self.org_name) session.nav.go_to_red_hat_subscriptions() self.subscriptions.upload(manifest_path) self.subscriptions.delete() self.assertTrue(self.subscriptions.wait_until_element(alert_loc)) self.assertTrue(self.subscriptions.wait_until_element(del_mf)) self.assertIsNone(self.subscriptions.search(DEFAULT_SUBSCRIPTION_NAME))
def test_repositoryset_enable(self): """@Test: Enable repo from reposet @Feature: Repository-set @Assert: Repository was enabled """ org = entities.Organization().create() with open(manifests.clone(), "rb") as manifest: upload_manifest(org.id, manifest) product = entities.Product(name=PRDS["rhel"], organization=org).search()[0] reposet = entities.RepositorySet(name=REPOSET["rhva6"], product=product).search()[0] reposet.enable(data={"basearch": "x86_64", "releasever": "6Server"}) repositories = reposet.available_repositories()["results"] self.assertTrue( [ repo["enabled"] for repo in repositories if (repo["substitutions"]["basearch"] == "x86_64" and repo["substitutions"]["releasever"] == "6Server") ][0] )
def setup_to_create_cv(self, repo_name=None, repo_url=None, repo_type=None, rh_repo=None, org_id=None): """Create product/repo and sync it""" if not rh_repo: repo_name = repo_name or gen_string("alpha", 8) # Creates new custom product via API's product_attrs = entities.Product( organization=org_id or self.org_id ).create_json() # Creates new custom repository via API's repo_attrs = entities.Repository( name=repo_name, url=(repo_url or FAKE_1_YUM_REPO), content_type=(repo_type or REPO_TYPE['yum']), product=product_attrs['id'], ).create_json() repo_id = repo_attrs['id'] elif rh_repo: # Clone the manifest and fetch it's path. manifest_path = manifests.clone() # Uploads the manifest and returns the result. entities.Organization(id=org_id).upload_manifest( path=manifest_path ) # Enables the RedHat repo and fetches it's Id. repo_id = utils.enable_rhrepo_and_fetchid( rh_repo['basearch'], str(org_id), # Org Id is passed as data in API hence str rh_repo['product'], rh_repo['name'], rh_repo['reposet'], rh_repo['releasever']) repo_name = rh_repo['name'] # Sync repository entities.Repository(id=repo_id).sync()
def test_repositoryset_enable_by_label(self): """@Test: Enable repo from reposet by org label, reposet and product names @Feature: Repository-set @Assert: Repository was enabled """ org = make_org() manifest = manifests.clone() upload_file(manifest, remote_file=manifest) result = Subscription.upload({ u'file': manifest, u'organization-id': org['id'], }) self.assertEqual(result.return_code, 0) result = RepositorySet.enable({ u'name': REPOSET['rhva6'], u'organization-label': org['label'], u'product': PRDS['rhel'], u'releasever': '6Server', u'basearch': 'x86_64', }) self.assertEqual(result.return_code, 0) result = RepositorySet.available_repositories({ u'name': REPOSET['rhva6'], u'organization-label': org['label'], u'product': PRDS['rhel'], }) self.assertEqual(result.return_code, 0) enabled = [ repo['enabled'] for repo in result.stdout if repo['arch'] == 'x86_64' and repo['release'] == '6Server' ][0] self.assertEqual(enabled, 'true')
def test_assert_delete_button(self): """@Test: Upload and delete a manifest @Feature: Manifest/Subscription - Positive Delete @Assert: Manifest is Deleted. Delete button is asserted . Subscriptions is asserted """ alert_loc = common_locators['alert.success'] del_mf = locators['subs.delete_manifest'] manifest_path = manifests.clone() # upload_file function should take care of uploading to sauce labs. upload_file(manifest_path, remote_file=manifest_path) with Session(self.browser) as session: session.nav.go_to_select_org(self.org_name) session.nav.go_to_red_hat_subscriptions() self.subscriptions.upload(manifest_path) self.subscriptions.delete() self.assertTrue(self.subscriptions.wait_until_element(alert_loc)) self.assertTrue(self.subscriptions.wait_until_element(del_mf)) self.assertIsNone( self.subscriptions.search("Red Hat Employee Subscription"))
def test_sync_rh_repos(self): """@Test: Create Content RedHat Sync with two repos. @Feature: Content RedHat Sync - Positive Create @Assert: Whether Syncing RedHat Repos is successful """ repos = self.sync.create_repos_tree(RHCT) manifest_path = manifests.clone() # upload_file function should take care of uploading to sauce labs. upload_file(manifest_path, remote_file=manifest_path) with Session(self.browser) as session: session.nav.go_to_select_org(self.org_name) session.nav.go_to_red_hat_subscriptions() self.subscriptions.upload(manifest_path) session.nav.go_to_red_hat_repositories() self.sync.enable_rh_repos(repos) session.nav.go_to_sync_status() sync = self.sync.sync_rh_repos(repos) # syn.sync_rh_repos returns boolean values and not objects self.assertTrue(sync)
def test_redhat_sync_1(self): """@Test: Sync RedHat Repository. @Feature: Repositories @Assert: Repository synced should fetch the data successfully. """ cloned_manifest_path = manifests.clone() org_id = entities.Organization().create_json()['id'] repo = "Red Hat Enterprise Linux 6 Server - RH Common RPMs x86_64 6.3" entities.Organization(id=org_id).upload_manifest( path=cloned_manifest_path ) repo_id = utils.enable_rhrepo_and_fetchid( "x86_64", org_id, "Red Hat Enterprise Linux Server", repo, "Red Hat Enterprise Linux 6 Server - RH Common (RPMs)", "6.3", ) entities.Repository(id=repo_id).sync()
def test_end_to_end(self): """@Test: Perform end to end smoke tests using RH repos. 1. Create new organization and environment 2. Upload manifest 3. Sync a RedHat repository 4. Create content-view 5. Add repository to contet-view 6. Promote/publish content-view 7. Create an activation-key 8. Add product to activation-key 9. Create new virtualmachine 10. Pull rpm from Foreman server and install on client 11. Register client with foreman server using activation-key 12. Install rpm on client @Feature: Smoke test @Assert: All tests should succeed and Content should be successfully fetched by client """ # Product, RepoSet and repository variables rhel_product_name = 'Red Hat Enterprise Linux Server' rhel_repo_set = ( 'Red Hat Enterprise Virtualization Agents ' 'for RHEL 6 Server (RPMs)' ) rhel_repo_name = ( 'Red Hat Enterprise Virtualization Agents ' 'for RHEL 6 Server ' 'RPMs x86_64 6Server' ) org_name = random.choice(generate_strings_list()) # Create new org and environment new_org = make_org({u'name': org_name}) new_env = make_lifecycle_environment({ u'organization-id': new_org['id'], u'name': gen_alphanumeric(), }) # Clone manifest and upload it manifest = manifests.clone() upload_file(manifest, remote_file=manifest) result = Subscription.upload({ u'file': manifest, u'organization-id': new_org['id'], }) self.assertEqual( result.return_code, 0, "Failed to upload manifest: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Enable repo from Repository Set result = RepositorySet.enable({ u'name': rhel_repo_set, u'organization-id': new_org['id'], u'product': rhel_product_name, u'releasever': '6Server', u'basearch': 'x86_64', }) self.assertEqual( result.return_code, 0, "Repo was not enabled: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Fetch repository info result = Repository.info({ u'name': rhel_repo_name, u'product': rhel_product_name, u'organization-id': new_org['id'], }) rhel_repo = result.stdout # Synchronize the repository result = Repository.synchronize({ u'name': rhel_repo_name, u'organization-id': new_org['id'], u'product': rhel_product_name, }) self.assertEqual( result.return_code, 0, "Repo was not synchronized: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Create CV and associate repo to it new_cv = make_content_view({u'organization-id': new_org['id']}) result = ContentView.add_repository({ u'id': new_cv['id'], u'repository-id': rhel_repo['id'], u'organization-id': new_org['id'], }) self.assertEqual( result.return_code, 0, "Failed repository association: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Publish a version1 of CV result = ContentView.publish({u'id': new_cv['id']}) self.assertEqual( result.return_code, 0, "Version1 publishing failed: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Get the CV info result = ContentView.info({u'id': new_cv['id']}) self.assertEqual( result.return_code, 0, "ContentView was not found: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Store the version1 id version1_id = result.stdout['versions'][0]['id'] # Promotion of version1 to next env result = ContentView.version_promote({ u'id': version1_id, u'to-lifecycle-environment-id': new_env['id'], }) self.assertEqual( result.return_code, 0, "version1 promotion failed: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Create activation key activation_key = make_activation_key({ u'name': gen_alphanumeric(), u'lifecycle-environment-id': new_env['id'], u'organization-id': new_org['id'], u'content-view': new_cv['name'], }) # List the subscriptions in given org result = Subscription.list( {u'organization-id': new_org['id']}, per_page=False ) self.assertEqual( result.return_code, 0, "Failed to list subscriptions: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Get the subscription ID from subscriptions list for subscription in result.stdout: if subscription['name'] == "Red Hat Employee Subscription": subscription_id = subscription['id'] subscription_quantity = int(subscription['quantity']) self.assertGreater( int(subscription_quantity), 0, 'Unexpected subscription quantity {0}' .format(subscription_quantity) ) # Add the subscriptions to activation-key result = ActivationKey.add_subscription({ u'id': activation_key['id'], u'subscription-id': subscription_id, u'quantity': 1, }) self.assertEqual( result.return_code, 0, "Failed to add subscription: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Create VM package_name = "python-kitchen" server_name = conf.properties['main.server.hostname'] with VirtualMachine(distro='rhel66') as vm: # Download and Install rpm result = vm.run( "wget -nd -r -l1 --no-parent -A '*.noarch.rpm' http://{0}/pub/" .format(server_name) ) self.assertEqual( result.return_code, 0, "failed to fetch katello-ca rpm: {0}, return code: {1}" .format(result.stderr, result.return_code) ) result = vm.run( 'rpm -i katello-ca-consumer*.noarch.rpm' ) self.assertEqual( result.return_code, 0, "failed to install katello-ca rpm: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Register client with foreman server using activation-key result = vm.run( u'subscription-manager register --activationkey {0} ' '--org {1} --force' .format(activation_key['name'], new_org['label']) ) self.assertEqual( result.return_code, 0, "failed to register client:: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Enable Red Hat Enterprise Virtualization Agents repo via cli # As the below repo is disabled by default under ak's prd-content result = vm.run( 'subscription-manager repos --enable ' 'rhel-6-server-rhev-agent-rpms' ) self.assertEqual( result.return_code, 0, "Enabling repo failed: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Install contents from sat6 server result = vm.run('yum install -y {0}'.format(package_name)) self.assertEqual( result.return_code, 0, "Package install failed: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Verify if package is installed by query it result = vm.run('rpm -q {0}'.format(package_name)) self.assertIn(package_name, result.stdout[0])
def test_puppet_install(self): """@Test: Perform puppet end to end smoke tests using RH repos. @Feature: Smoke test puppet install and configure on client @Assert: Client should get configured by puppet-module. """ activation_key_name = gen_string('alpha') cloned_manifest_path = manifests.clone() cv_name = gen_string('alpha') env_name = gen_string('alpha') org_name = gen_string('alpha') product_name = gen_string('alpha') puppet_module = 'motd' puppet_repository_name = gen_string('alpha') repos = self.sync.create_repos_tree(SAT6_TOOLS_TREE) rhel_prd = DEFAULT_SUBSCRIPTION_NAME rhel6_repo = conf.properties['clients.rhel6_repo'] upload_file(cloned_manifest_path) with Session(self.browser) as session: # Create New organization make_org(session, org_name=org_name) self.assertIsNotNone(self.org.search(org_name)) # Create New Lifecycle environment make_lifecycle_environment(session, org=org_name, name=env_name) strategy, value = locators['content_env.select_name'] self.assertIsNotNone(self.contentenv.wait_until_element( (strategy, value % env_name) )) session.nav.go_to_red_hat_subscriptions() # Upload manifest from webui self.subscriptions.upload(cloned_manifest_path) self.assertTrue(session.nav.wait_until_element( common_locators['alert.success'] )) session.nav.go_to_red_hat_repositories() # List of dictionary passed to enable the redhat repos # It selects Product->Reposet-> Repo self.sync.enable_rh_repos(repos) session.nav.go_to_sync_status() # Sync the repos # syn.sync_rh_repos returns boolean values and not objects self.assertTrue(self.sync.sync_noversion_rh_repos( PRDS['rhel'], [REPOS['rhst6']['name']] )) # Create custom product make_product(session, org=org_name, name=product_name) self.assertIsNotNone(self.products.search(product_name)) # Create a puppet Repository make_repository( session, org=org_name, name=puppet_repository_name, product=product_name, url=FAKE_6_PUPPET_REPO, repo_type=REPO_TYPE['puppet'] ) self.assertIsNotNone(self.repository.search( puppet_repository_name )) # Sync the repos # syn.sync_rh_repos returns boolean values and not objects session.nav.go_to_sync_status() self.assertIsNotNone(self.sync.sync_custom_repos( product_name, [puppet_repository_name] )) # Create new content-view make_contentview(session, org=org_name, name=cv_name) self.assertIsNotNone(self.content_views.search(cv_name)) # Add YUM repository to content-view self.content_views.add_remove_repos( cv_name, [REPOS['rhst6']['name']], ) if not bz_bug_is_open(1191422): self.assertIsNotNone(self.content_views.wait_until_element( common_locators['alert.success'] )) # Add puppet-module to content-view self.content_views.add_puppet_module( cv_name, puppet_module, filter_term='Latest') # Publish content-view self.content_views.publish(cv_name) if not bz_bug_is_open(1191422): self.assertIsNotNone(self.content_views.wait_until_element( common_locators['alert.success'] )) # Promote content-view to life-cycle environment. self.content_views.promote( cv_name, version='Version 1', env=env_name) if not bz_bug_is_open(1191422): self.assertIsNotNone(self.content_views.wait_until_element( common_locators['alert.success'] )) # Create Activation-Key make_activationkey( session, org=org_name, name=activation_key_name, env=env_name, content_view=cv_name ) self.activationkey.associate_product( activation_key_name, [product_name, rhel_prd]) self.activationkey.enable_repos( activation_key_name, [REPOSET['rhst6']] ) if not bz_bug_is_open(1191541): self.assertIsNotNone(self.activationkey.wait_until_element( common_locators['alert.success'] )) # Create VM with VirtualMachine(distro='rhel67') as vm: vm.install_katello_cert() vm.register_contenthost(activation_key_name, org_name) vm.configure_puppet(rhel6_repo) host = vm.fetch_hostname() session.nav.go_to_hosts() set_context(session, org=ANY_CONTEXT['org']) self.hosts.update_host_bulkactions(host=host, org=org_name) self.hosts.update( name=host, lifecycle_env=env_name, cv=cv_name, reset_puppetenv=True, ) session.nav.go_to_hosts() self.hosts.update( name=host, reset_puppetenv=False, puppet_module=puppet_module ) vm.run(u'puppet agent -t') result = vm.run(u'cat /etc/motd | grep FQDN') self.assertEqual(result.return_code, 0)
def test_end_to_end(self): """@Test: Perform end to end smoke tests using RH repos. @Feature: Smoke test @Assert: All tests should succeed and Content should be successfully fetched by client """ org_name = gen_string('alpha', 6) cv_name = gen_string('alpha', 6) activation_key_name = gen_string('alpha', 6) env_name = gen_string('alpha', 6) repos = self.sync.create_repos_tree(RHVA_REPO_TREE) cloned_manifest_path = manifests.clone() # upload_file function should take care of uploading to sauce labs. upload_file(cloned_manifest_path) with Session(self.browser) as session: # Create New organization make_org(session, org_name=org_name) self.assertIsNotNone(self.org.search(org_name)) # Create New Lifecycle environment make_lifecycle_environment(session, org=org_name, name=env_name) strategy, value = locators['content_env.select_name'] self.assertIsNotNone(self.contentenv.wait_until_element( (strategy, value % env_name) )) # Navigate UI to select org and redhat subscription page session.nav.go_to_select_org(org_name) session.nav.go_to_red_hat_subscriptions() # Upload manifest from webui self.subscriptions.upload(cloned_manifest_path) self.assertTrue(session.nav.wait_until_element( common_locators['alert.success'] )) session.nav.go_to_red_hat_repositories() # List of dictionary passed to enable the redhat repos # It selects Product->Reposet-> Repo self.sync.enable_rh_repos(repos) session.nav.go_to_sync_status() # Sync the repos # syn.sync_rh_repos returns boolean values and not objects self.assertTrue(self.sync.sync_rh_repos(repos)) # Create new content-view make_contentview(session, org=org_name, name=cv_name) self.assertIsNotNone(self.content_views.search(cv_name)) # Add YUM repository to content-view self.content_views.add_remove_repos( cv_name, [REPOS['rhva65']['name'], REPOS['rhva6']['name']] ) if not bz_bug_is_open(1191422): self.assertIsNotNone(self.content_views.wait_until_element( common_locators['alert.success'] )) # Publish content-view self.content_views.publish(cv_name) if not bz_bug_is_open(1191422): self.assertIsNotNone(self.content_views.wait_until_element( common_locators['alert.success'] )) # Promote content-view to life-cycle environment 1 self.content_views.promote( cv_name, version='Version 1', env=env_name) if not bz_bug_is_open(1191422): self.assertIsNotNone(self.content_views.wait_until_element( common_locators['alert.success'] )) # Create Activation-Key make_activationkey( session, org=org_name, name=activation_key_name, env=env_name, content_view=cv_name ) self.activationkey.associate_product( activation_key_name, [DEFAULT_SUBSCRIPTION_NAME]) self.activationkey.enable_repos( activation_key_name, [REPOSET['rhva6']]) if not bz_bug_is_open(1191541): self.assertIsNotNone(self.activationkey.wait_until_element( common_locators['alert.success'] )) # Create VM with VirtualMachine(distro='rhel66') as vm: vm.install_katello_cert() result = vm.register_contenthost(activation_key_name, org_name) self.assertEqual(result.return_code, 0) # Install contents from sat6 server package_name = 'python-kitchen' result = vm.run(u'yum install -y {0}'.format(package_name)) self.assertEqual(result.return_code, 0) # Verify if package is installed by query it result = vm.run(u'rpm -q {0}'.format(package_name)) self.assertEqual(result.return_code, 0)
def setUp(self): # noqa """Tests for content-view via Hammer CLI""" super(TestSubscription, self).setUp() self.org = make_org(cached=True) self.manifest = manifests.clone()
def test_end_to_end(self): """@Test: Perform end to end smoke tests using RH repos. @Feature: Smoke test @Assert: All tests should succeed and Content should be successfully fetched by client """ org_name = gen_string("alpha", 6) cv_name = gen_string("alpha", 6) activation_key_name = gen_string("alpha", 6) env_name = gen_string("alpha", 6) product_name = "Red Hat Employee Subscription" repo_names = [ "Red Hat Enterprise Virtualization Agents for RHEL 6 Server " "RPMs x86_64 6.5", "Red Hat Enterprise Virtualization Agents for RHEL 6 Server " "RPMs x86_64 6Server", ] repos = self.sync.create_repos_tree(RHVA_REPO_TREE) package_name = "python-kitchen" cloned_manifest_path = manifests.clone() # upload_file function should take care of uploading to sauce labs. upload_file(cloned_manifest_path, remote_file=cloned_manifest_path) with Session(self.browser) as session: # Create New organization make_org(session, org_name=org_name) self.assertIsNotNone(self.org.search(org_name)) # Create New Lifecycle environment make_lifecycle_environment(session, org=org_name, name=env_name) strategy, value = locators["content_env.select_name"] self.assertIsNotNone( self.contentenv.wait_until_element( (strategy, value % env_name))) # Navigate UI to select org and redhat subscription page session.nav.go_to_select_org(org_name) session.nav.go_to_red_hat_subscriptions() # Upload manifest from webui self.subscriptions.upload(cloned_manifest_path) self.assertTrue( session.nav.wait_until_element( common_locators['alert.success'])) session.nav.go_to_red_hat_repositories() # List of dictionary passed to enable the redhat repos # It selects Product->Reposet-> Repo self.sync.enable_rh_repos(repos) session.nav.go_to_sync_status() # Sync the repos sync = self.sync.sync_rh_repos(repos) # syn.sync_rh_repos returns boolean values and not objects self.assertTrue(sync) # Create new content-view make_contentview(session, org=org_name, name=cv_name) self.assertIsNotNone(self.content_views.search(cv_name)) # Add YUM repository to content-view self.content_views.add_remove_repos(cv_name, repo_names) if not bz_bug_is_open(1191422): self.assertIsNotNone( self.content_views.wait_until_element( common_locators["alert.success"])) # Publish content-view self.content_views.publish(cv_name) if not bz_bug_is_open(1191422): self.assertIsNotNone( self.content_views.wait_until_element( common_locators["alert.success"])) # Promote content-view to life-cycle environment 1 self.content_views.promote(cv_name, version="Version 1", env=env_name) if not bz_bug_is_open(1191422): self.assertIsNotNone( self.content_views.wait_until_element( common_locators["alert.success"])) # Create Activation-Key make_activationkey(session, org=org_name, name=activation_key_name, env=env_name, content_view=cv_name) self.activationkey.associate_product(activation_key_name, [product_name]) self.activationkey.enable_repos(activation_key_name, [REPOSET['rhva6']]) if not bz_bug_is_open(1191541): self.assertIsNotNone( self.activationkey.wait_until_element( common_locators["alert.success"])) # Create VM with VirtualMachine(distro='rhel66') as vm: # Download and Install rpm result = vm.run( "wget -nd -r -l1 --no-parent -A '*.noarch.rpm' " "http://{0}/pub/".format(self.server_name)) self.assertEqual( result.return_code, 0, "failed to fetch katello-ca rpm: {0}, return code: {1}". format(result.stderr, result.return_code)) result = vm.run('rpm -i katello-ca-consumer*.noarch.rpm') self.assertEqual( result.return_code, 0, "failed to install katello-ca rpm: {0}, return code: {1}". format(result.stderr, result.return_code)) # Register client with foreman server using activation-key result = vm.run( 'subscription-manager register --activationkey {0} ' '--org {1} --force'.format(activation_key_name, org_name)) self.assertEqual( result.return_code, 0, "failed to register client:: {0} and return code: {1}". format(result.stderr, result.return_code)) # Install contents from sat6 server result = vm.run('yum install -y {0}'.format(package_name)) self.assertEqual( result.return_code, 0, "Package install failed: {0} and return code: {1}".format( result.stderr, result.return_code)) # Verify if package is installed by query it result = vm.run('rpm -q {0}'.format(package_name)) self.assertIn(package_name, result.stdout[0])
def test_end_to_end(self): """@Test: Perform end to end smoke tests using RH repos. 1. Create new organization and environment 2. Clone and upload manifest 3. Sync a RedHat repository 4. Create content-view 5. Add repository to contet-view 6. Promote/publish content-view 7. Create an activation-key 8. Add product to activation-key 9. Create new virtualmachine 10. Pull rpm from Foreman server and install on client 11. Register client with foreman server using activation-key 12. Install rpm on client @Feature: Smoke test @Assert: All tests should succeed and Content should be successfully fetched by client """ product = "Red Hat Enterprise Linux Server" reposet = ("Red Hat Enterprise Virtualization Agents " "for RHEL 6 Server (RPMs)") repo = ("Red Hat Enterprise Virtualization Agents for RHEL 6 Server " "RPMs x86_64 6Server") activation_key_name = gen_string('alpha') # step 1.1: Create a new organization org = entities.Organization().create() # step 1.2: Create new lifecycle environments lifecycle_env = entities.LifecycleEnvironment( organization=org['id'] ).create() # step 2: Upload manifest manifest_path = manifests.clone() task = entities.Organization( id=org['id'] ).upload_manifest(path=manifest_path) self.assertEqual( u'success', task['result'], task['humanized']['errors'] ) # step 3.1: Enable RH repo and fetch repository_id repo_id = utils.enable_rhrepo_and_fetchid( basearch="x86_64", org_id=org['id'], product=product, repo=repo, reposet=reposet, releasever="6Server", ) # step 3.2: sync repository task_result = entities.Repository(id=repo_id).sync()['result'] self.assertEqual( task_result, u'success', u" Error while syncing repository '{0}' and state is {1}." .format(repo, task_result)) # step 4: Create content view content_view = entities.ContentView(organization=org['id']).create() # step 5: Associate repository to new content view response = client.put( entities.ContentView(id=content_view['id']).path(), {u'repository_ids': [repo_id]}, auth=get_server_credentials(), verify=False, ) response.raise_for_status() # step 6.1: Publish content view task_status = entities.ContentView(id=content_view['id']).publish() self.assertEqual( task_status['result'], u'success', u"Error publishing content-view {0} and state is {1}." .format(content_view['name'], task_status['result'])) # step 6.2: Promote content view to lifecycle_env content_view = entities.ContentView(id=content_view['id']).read_json() self.assertEqual(len(content_view['versions']), 1) task_status = entities.ContentViewVersion( id=content_view['versions'][0]['id'] ).promote(lifecycle_env['id']) self.assertEqual( task_status['result'], u'success', u"Error promoting {0} to {1} and state is {2}." .format(content_view['name'], lifecycle_env['name'], task_status['result'])) # step 7: Create activation key ak_id = entities.ActivationKey( name=activation_key_name, environment=lifecycle_env['id'], organization=org['id'], content_view=content_view['id'], ).create_json()['id'] # Walk through the list of subscriptions. Find the "Red Hat Employee # Subscription" and attach it to the just-created activation key. for subscription in entities.Organization(id=org['id']).subscriptions(): if subscription['product_name'] == "Red Hat Employee Subscription": # 'quantity' must be 1, not subscription['quantity']. Greater # values produce this error: "RuntimeError: Error: Only pools # with multi-entitlement product subscriptions can be added to # the activation key with a quantity greater than one." entities.ActivationKey(id=ak_id).add_subscriptions({ 'quantity': 1, 'subscription_id': subscription['id'], }) break # Create VM package_name = "python-kitchen" with VirtualMachine(distro='rhel66') as vm: # Download and Install rpm result = vm.run( "wget -nd -r -l1 --no-parent -A '*.noarch.rpm' http://{0}/pub/" .format(conf.properties['main.server.hostname']) ) self.assertEqual( result.return_code, 0, "failed to fetch katello-ca rpm: {0}, return code: {1}" .format(result.stderr, result.return_code) ) result = vm.run( 'rpm -i katello-ca-consumer*.noarch.rpm' ) self.assertEqual( result.return_code, 0, "failed to install katello-ca rpm: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Register client with foreman server using activation-key result = vm.run( u'subscription-manager register --activationkey {0} ' '--org {1} --force' .format(activation_key_name, org['label']) ) self.assertEqual( result.return_code, 0, "failed to register client:: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Enable Red Hat Enterprise Virtualization Agents repo via cli # As the below repo is disabled by default under ak's prd-content result = vm.run( 'subscription-manager repos --enable ' 'rhel-6-server-rhev-agent-rpms' ) self.assertEqual( result.return_code, 0, "Enabling repo failed: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Install contents from sat6 server result = vm.run('yum install -y {0}'.format(package_name)) self.assertEqual( result.return_code, 0, "Package install failed: {0} and return code: {1}" .format(result.stderr, result.return_code) ) # Verify if package is installed by query it result = vm.run('rpm -q {0}'.format(package_name)) self.assertIn(package_name, result.stdout[0])
def create_cv(self, name, env_name, product_name=None, repo_name=None, repo_url=None, repo_type=None, rh_repo=None): """Create product/repo and sync it and promote to given env""" if not rh_repo: product_name = product_name or gen_string("alpha", 8) repo_name = repo_name or gen_string("alpha", 8) # Creates new product and repository via API's product_attrs = entities.Product( name=product_name, organization=self.org_id ).create() repo_attrs = entities.Repository( name=repo_name, url=repo_url or FAKE_1_YUM_REPO, content_type=repo_type or REPO_TYPE['yum'], product=product_attrs['id'], ).create() repo_id = repo_attrs['id'] else: # Upload manifest manifest_path = manifests.clone() task_result = entities.Organization( id=self.org_id ).upload_manifest(path=manifest_path)['result'] self.assertEqual(u'success', task_result) # Enable RH repo and fetch repository_id repo_id = utils.enable_rhrepo_and_fetchid( rh_repo['basearch'], self.org_id, rh_repo['product'], rh_repo['name'], rh_repo['reposet'], rh_repo['releasever']) repo_name = rh_repo['name'] # Sync repository task_result = entities.Repository(id=repo_id).sync()['result'] self.assertEqual( task_result, u'success', u"Sync for repository {0} failed.".format(repo_name)) # Create Life-Cycle content environment env_attrs = entities.LifecycleEnvironment( name=env_name, organization=self.org_id ).create() # Create content view(CV) content_view = entities.ContentView( name=name, organization=self.org_id ) content_view.id = content_view.create()['id'] # Associate YUM repo to created CV response = client.put( entities.ContentView(id=content_view.id).path(), auth=get_server_credentials(), verify=False, data={u'repository_ids': [repo_id]}) response.raise_for_status() # Publish content view self.assertEqual(u'success', content_view.publish()['result']) # Get the content view version's ID. response = client.get( entities.ContentViewVersion().path(), auth=get_server_credentials(), data={u'content_view_id': content_view.id}, verify=False, ) response.raise_for_status() results = response.json()['results'] self.assertEqual(len(results), 1) cv_version = entities.ContentViewVersion(id=results[0]['id']) # Promote the content view version. self.assertEqual( 'success', cv_version.promote(environment_id=env_attrs['id'])['result'] )
def test_associate_product_3(self): """@Test: Test that RH/Custom product can be associated to Activation keys @Feature: Activation key - Product @Steps: 1. Create Activation key 2. Associate RH product(s) to Activation Key 3. Associate custom product(s) to Activation Key @Assert: RH/Custom product is successfully associated to Activation key """ name = gen_string("alpha", 8) rh_repo = { 'name': ("Red Hat Enterprise Virtualization Agents for RHEL 6 " "Server RPMs x86_64 6Server"), 'product': "Red Hat Enterprise Linux Server", 'reposet': ("Red Hat Enterprise Virtualization Agents " "for RHEL 6 Server (RPMs)"), 'basearch': "x86_64", 'releasever': "6Server", } product_subscription = "Red Hat Employee Subscription" custom_product_name = gen_string("alpha", 8) repo_name = gen_string("alpha", 8) # Creates new product and repository via API's product_attrs = entities.Product( name=custom_product_name, organization=self.org_id ).create() repo_attrs = entities.Repository( name=repo_name, url=FAKE_1_YUM_REPO, content_type=REPO_TYPE['yum'], product=product_attrs['id'], ).create() custom_repo_id = repo_attrs['id'] # Upload manifest manifest_path = manifests.clone() task_result = entities.Organization( id=self.org_id ).upload_manifest(path=manifest_path)['result'] self.assertEqual(u'success', task_result) # Enable RH repo and fetch repository_id rhel_repo_id = utils.enable_rhrepo_and_fetchid( rh_repo['basearch'], self.org_id, rh_repo['product'], rh_repo['name'], rh_repo['reposet'], rh_repo['releasever'] ) # Sync repository for repo_id in [rhel_repo_id, custom_repo_id]: task_result = entities.Repository(id=repo_id).sync()['result'] self.assertEqual( task_result, u'success', u"Sync for repository {0} failed.".format(repo_name)) with Session(self.browser) as session: make_activationkey( session, org=self.org_name, name=name, env=ENVIRONMENT, content_view=DEFAULT_CV ) self.assertIsNotNone(self.activationkey.search_key(name)) self.activationkey.associate_product( name, [product_subscription, custom_product_name]) self.assertIsNotNone(self.activationkey.wait_until_element (common_locators["alert.success"]))
def test_repositoryset_available_repositories(self): """@Test: List available repositories for repository-set @Feature: Repository-set @Assert: List of available repositories is displayed, with valid amount of enabled repositories """ rhel_product_name = 'Red Hat Enterprise Linux Server' rhel_repo_set = ( 'Red Hat Enterprise Virtualization Agents ' 'for RHEL 6 Server (RPMs)' ) # Clone manifest and upload it org = make_org() manifest = manifests.clone() upload_file(manifest, remote_file=manifest) result = Subscription.upload({ u'file': manifest, u'organization-id': org['id'], }) self.assertEqual(result.return_code, 0) # No repos should be enabled by default result = RepositorySet.available_repositories({ u'name': rhel_repo_set, u'organization-id': org['id'], u'product': rhel_product_name, }) self.assertEqual(result.return_code, 0) self.assertEqual( sum(int(repo['enabled'] == u'true') for repo in result.stdout), 0 ) # Enable repo from Repository Set result = RepositorySet.enable({ u'name': rhel_repo_set, u'organization-id': org['id'], u'product': rhel_product_name, u'releasever': '6Server', u'basearch': 'x86_64', }) self.assertEqual(result.return_code, 0) # Only 1 repo should be enabled result = RepositorySet.available_repositories({ u'name': rhel_repo_set, u'organization': org['name'], u'product': rhel_product_name, }) self.assertEqual(result.return_code, 0) self.assertEqual( sum(int(repo['enabled'] == u'true') for repo in result.stdout), 1 ) # Enable one more repo result = RepositorySet.enable({ u'name': rhel_repo_set, u'organization-id': org['id'], u'product': rhel_product_name, u'releasever': '6Server', u'basearch': 'i386', }) self.assertEqual(result.return_code, 0) # 2 repos should be enabled result = RepositorySet.available_repositories({ u'name': rhel_repo_set, u'organization-label': org['label'], u'product': rhel_product_name, }) self.assertEqual(result.return_code, 0) self.assertEqual( sum(int(repo['enabled'] == u'true') for repo in result.stdout), 2 ) # Disable one repo result = RepositorySet.disable({ u'name': rhel_repo_set, u'organization-id': org['id'], u'product': rhel_product_name, u'releasever': '6Server', u'basearch': 'i386', }) self.assertEqual(result.return_code, 0) # There should remain only 1 enabled repo result = RepositorySet.available_repositories({ u'name': rhel_repo_set, u'organization-id': org['id'], u'product': rhel_product_name, }) self.assertEqual(result.return_code, 0) self.assertEqual( sum(int(repo['enabled'] == u'true') for repo in result.stdout), 1 ) # Disable the last enabled repo result = RepositorySet.disable({ u'name': rhel_repo_set, u'organization-id': org['id'], u'product': rhel_product_name, u'releasever': '6Server', u'basearch': 'x86_64', }) self.assertEqual(result.return_code, 0) # There should be no enabled repos result = RepositorySet.available_repositories({ u'name': rhel_repo_set, u'organization-id': org['id'], u'product': rhel_product_name, }) self.assertEqual(result.return_code, 0) self.assertEqual( sum(int(repo['enabled'] == u'true') for repo in result.stdout), 0 )