def test_all(self): """Test of mirror mode.""" client = gen_rpm_client() repo_api = RepositoriesRpmApi(client) remote_api = RemotesRpmApi(client) # 1. create repo, remote and sync them repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_rpm_remote(url=SRPM_UNSIGNED_FIXTURE_URL) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) # 2. create another remote and re-sync body = gen_rpm_remote(url=RPM_SIGNED_FIXTURE_URL) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href, mirror=True) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) # 3. Check that only new content is present repo = repo_api.read(repo.pulp_href) self.assertDictEqual(RPM_FIXTURE_SUMMARY, get_content_summary(repo.to_dict()))
def do_test(self, url): """Sync a repository given ``url`` on the remote.""" repo_api = RepositoriesRpmApi(self.client) remote_api = RemotesRpmApi(self.client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_rpm_remote(url=url) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) return monitor_task(sync_response.task)
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) delete_orphans(cls.cfg)
def setUpClass(cls): """ Create all the client instances needed to communicate with Pulp. """ configuration = Configuration(**BINDINGS_CONFIGURATION) rpm_client = RpmApiClient(configuration) migration_client = MigrationApiClient(configuration) # Create api clients for all resource types cls.rpm_repo_api = RepositoriesRpmApi(rpm_client) cls.rpm_repo_versions_api = RepositoriesRpmVersionsApi(rpm_client) cls.rpm_remote_api = RemotesRpmApi(rpm_client) cls.rpm_distribution_api = DistributionsRpmApi(rpm_client) cls.rpm_publication_api = PublicationsRpmApi(rpm_client) cls.rpm_content_apis = { "advisory": ContentAdvisoriesApi(rpm_client), "disttree": ContentDistributionTreesApi(rpm_client), "modulemd": ContentModulemdsApi(rpm_client), "modulemd-defaults": ContentModulemdDefaultsApi(rpm_client), "category": ContentPackagecategoriesApi(rpm_client), "environment": ContentPackageenvironmentsApi(rpm_client), "group": ContentPackagegroupsApi(rpm_client), "langpack": ContentPackagelangpacksApi(rpm_client), "package": ContentPackagesApi(rpm_client), } cls.migration_plans_api = MigrationPlansApi(migration_client) cls.pulp2content_api = Pulp2ContentApi(migration_client) cls.pulp2repositories_api = Pulp2RepositoriesApi(migration_client)
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(gen_rpm_client()) cls.publications = PublicationsRpmApi(cls.client)
def setUpClass(cls): """Create class-wide variables.""" cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) cls.advisory_api = ContentAdvisoriesApi(cls.client) delete_orphans() def _sync(url=None): repo = cls.repo_api.create(gen_repo()) remote = cls.remote_api.create(gen_rpm_remote(url)) repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = cls.repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) return cls.repo_api.read(repo.pulp_href) # sync repos to get two conflicting advisories to use later in tests cls.repo_rpm_unsigned = _sync(url=RPM_UNSIGNED_FIXTURE_URL) cls.repo_rpm_advisory_diffpkgs = _sync(url=RPM_ADVISORY_DIFFERENT_PKGLIST_URL) cls.advisory_rpm_unsigned_href = ( cls.advisory_api.list( repository_version=cls.repo_rpm_unsigned.latest_version_href, id=RPM_ADVISORY_TEST_ID, ) .results[0] .pulp_href ) cls.advisory_rpm_advisory_diffpkgs_href = ( cls.advisory_api.list( repository_version=cls.repo_rpm_advisory_diffpkgs.latest_version_href, id=RPM_ADVISORY_TEST_ID, ) .results[0] .pulp_href )
def setUpClass(cls): """ Create all the client instances needed to communicate with Pulp. """ configuration = Configuration(**BINDINGS_CONFIGURATION) rpm_client = RpmApiClient(configuration) migration_client = MigrationApiClient(configuration) # Create api clients for all resource types cls.rpm_repo_api = RepositoriesRpmApi(rpm_client) cls.rpm_repo_versions_api = RepositoriesRpmVersionsApi(rpm_client) cls.rpm_remote_api = RemotesRpmApi(rpm_client) cls.rpm_distribution_api = DistributionsRpmApi(rpm_client) cls.rpm_publication_api = PublicationsRpmApi(rpm_client) cls.rpm_content_apis = { 'advisory': ContentAdvisoriesApi(rpm_client), # skip until https://pulp.plan.io/issues/8050 is fixed # 'disttree': ContentDistributionTreesApi(rpm_client), 'modulemd': ContentModulemdsApi(rpm_client), 'modulemd-defaults': ContentModulemdDefaultsApi(rpm_client), 'category': ContentPackagecategoriesApi(rpm_client), 'environment': ContentPackageenvironmentsApi(rpm_client), 'group': ContentPackagegroupsApi(rpm_client), 'langpack': ContentPackagelangpacksApi(rpm_client), 'package': ContentPackagesApi(rpm_client), } cls.migration_plans_api = MigrationPlansApi(migration_client)
def setUpClass(cls): """Create class-wide variable.""" delete_orphans() cls.client = gen_rpm_client() cls.cfg = Configuration(cls.client) cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client)
def setUpClass(cls): """Create class-wide variables.""" cls.client = gen_rpm_client() cls.dist_tree_api = ContentDistributionTreesApi(cls.client) cls.packages_api = ContentPackagesApi(cls.client) cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) delete_orphans()
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_rpm_client() cls.content_api = ContentPackagesApi(cls.client) cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) cls.publications_api = PublicationsRpmApi(cls.client) cls.distributions_api = DistributionsRpmApi(cls.client)
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_rpm_client() cls.cli_client = cli.Client(cls.cfg) cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) delete_orphans(cls.cfg) cls.md5_allowed = "md5" in get_pulp_setting( cls.cli_client, "ALLOWED_CONTENT_CHECKSUMS")
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) cls.rpm_content_api = ContentPackagesApi(cls.client) cls.test_package = "whale" cls.test_package_dependencies = ["shark", "stork"] delete_orphans(cls.cfg)
def test_all(self): """Sync/publish a repo that ``updateinfo.xml`` contains references. This test targets the following issue: `Pulp #3998 <https://pulp.plan.io/issues/3998>`_. """ client = gen_rpm_client() repo_api = RepositoriesRpmApi(client) remote_api = RemotesRpmApi(client) publications = PublicationsRpmApi(client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_rpm_remote(RPM_REFERENCES_UPDATEINFO_URL) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) # Sync the repository. self.assertEqual(repo.latest_version_href, f"{repo.pulp_href}versions/0/") repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo = repo_api.read(repo.pulp_href) self.assertIsNotNone(repo.latest_version_href) content_summary = get_content_summary(repo.to_dict()) self.assertDictEqual(content_summary, RPM_FIXTURE_SUMMARY, content_summary) publish_data = RpmRpmPublication(repository=repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task( publish_response.task).created_resources publication_href = created_resources[0] self.assertIsNotNone(publication_href) self.addCleanup(publications.delete, publication_href)
def test_all(self): """Verify whether is possible to create a remote without a URL. This test targets the following issues: * `Pulp #3395 <https://pulp.plan.io/issues/3395>`_ * `Pulp Smash #984 <https://github.com/pulp/pulp-smash/issues/984>`_ """ body = gen_rpm_remote() del body["url"] with self.assertRaises(ApiException): RemotesRpmApi(gen_rpm_client()).create(body)
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) cls.rpm_package_content_api = ContentPackagesApi(cls.client) cls.rpm_advisory_content_api = ContentAdvisoriesApi(cls.client) cls.test_advisory = "RHEA-2012:0055" cls.test_advisory_dependencies = ["walrus", "penguin", "shark"] delete_orphans(cls.cfg)
def test_all(self): """Test of addtive mode.""" client = gen_rpm_client() repo_api = RepositoriesRpmApi(client) remote_api = RemotesRpmApi(client) # 1. create repo, remote and sync them repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_rpm_remote(url=RPM_UNSIGNED_FIXTURE_URL) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) # 2. create another remote and re-sync body = gen_rpm_remote(url=SRPM_UNSIGNED_FIXTURE_URL) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) # 3. Check content counts repo = repo_api.read(repo.pulp_href) present_package_count = len( get_content(repo.to_dict())[PULP_TYPE_PACKAGE]) present_advisory_count = len( get_content(repo.to_dict())[PULP_TYPE_ADVISORY]) self.assertEqual( RPM_PACKAGE_COUNT + SRPM_UNSIGNED_FIXTURE_PACKAGE_COUNT, present_package_count) self.assertEqual( RPM_ADVISORY_COUNT + SRPM_UNSIGNED_FIXTURE_ADVISORY_COUNT, present_advisory_count)
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) cls.rpm_advisory_content_api = ContentAdvisoriesApi(cls.client) cls.rpm_modulemd_content_api = ContentModulemdsApi(cls.client) cls.rpm_package_content_api = ContentPackagesApi(cls.client) cls.test_advisory = "FEDORA-2019-0329090518" # these dependencies have same name for dependent packages as dependant modules cls.test_advisory_dependencies = ["postgresql", "nodejs"] delete_orphans()
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = api.Client(cls.cfg, api.json_handler) cls.core_client = CoreApiClient(configuration=cls.cfg.get_bindings_config()) cls.rpm_client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.rpm_client) cls.remote_api = RemotesRpmApi(cls.rpm_client) cls.exporter_api = ExportersPulpApi(cls.core_client) cls.exports_api = ExportersCoreExportsApi(cls.core_client) (cls.repo, cls.remote) = cls._setup_repositories()
def setUpClass(cls): """Verify whether dnf or yum are present.""" cls.cfg = config.get_config() configuration = cls.cfg.get_bindings_config() core_client = CoreApiClient(configuration) cls.artifacts_api = ArtifactsApi(core_client) cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) cls.publications = PublicationsRpmApi(cls.client) cls.distributions = DistributionsRpmApi(cls.client) cls.before_consumption_artifact_count = 0 cls.pkg_mgr = cli.PackageManager(cls.cfg) cls.pkg_mgr.raise_if_unsupported(unittest.SkipTest, "This test requires dnf or yum.")
def test_file_decriptors(self): """Test whether file descriptors are closed properly. This test targets the following issue: `Pulp #4073 <https://pulp.plan.io/issues/4073>`_ Do the following: 1. Check if 'lsof' is installed. If it is not, skip this test. 2. Create and sync a repo. 3. Run the 'lsof' command to verify that files in the path ``/var/lib/pulp/`` are closed after the sync. 4. Assert that issued command returns `0` opened files. """ cli_client = cli.Client(self.cfg, cli.echo_handler) # check if 'lsof' is available if cli_client.run(("which", "lsof")).returncode != 0: raise unittest.SkipTest("lsof package is not present") repo_api = RepositoriesRpmApi(self.client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) remote_api = RemotesRpmApi(self.client) remote = remote_api.create(gen_rpm_remote()) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) cmd = "lsof -t +D {}".format(MEDIA_PATH).split() response = cli_client.run(cmd).stdout self.assertEqual(len(response), 0, response)
def setUpClass(cls): """Create class-wide variables.""" cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) cls.repometadatafiles = ContentRepoMetadataFilesApi(cls.client) delete_orphans() # Certificates processing cls.cdn_client_cert = False if (os.environ["CDN_CLIENT_CERT"] and os.environ["CDN_CLIENT_KEY"] and os.environ["CDN_CA_CERT"]): # strings have escaped newlines from environmental variable cls.cdn_client_cert = os.environ["CDN_CLIENT_CERT"].replace( "\\n", "\n") cls.cdn_client_key = os.environ["CDN_CLIENT_KEY"].replace( "\\n", "\n") cls.cdn_ca_cert = os.environ["CDN_CA_CERT"].replace("\\n", "\n")
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(cls.client) cls.repometadatafiles = ContentRepoMetadataFilesApi(cls.client) delete_orphans(cls.cfg) # Certificates processing cls.cdn_client_cert = False if os.environ['CDN_CLIENT_CERT'] \ and os.environ['CDN_CLIENT_KEY'] \ and os.environ['CDN_CA_CERT']: # strings have escaped newlines from environmental variable cls.cdn_client_cert = os.environ['CDN_CLIENT_CERT'].replace( '\\n', '\n') cls.cdn_client_key = os.environ['CDN_CLIENT_KEY'].replace( '\\n', '\n') cls.cdn_ca_cert = os.environ['CDN_CA_CERT'].replace('\\n', '\n')
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.client) cls.remote_api = RemotesRpmApi(gen_rpm_client()) cls.publications = PublicationsRpmApi(cls.client) cls.distributions = DistributionsRpmApi(cls.client) if ( os.environ.get("CDN_CLIENT_CERT", None) and os.environ.get("CDN_CLIENT_KEY", None) and os.environ.get("CDN_CA_CERT", None) ): # strings have escaped newlines from environmental variable cls.cdn_client_cert = os.environ["CDN_CLIENT_CERT"].replace("\\n", "\n") cls.cdn_client_key = os.environ["CDN_CLIENT_KEY"].replace("\\n", "\n") cls.cdn_ca_cert = os.environ["CDN_CA_CERT"].replace("\\n", "\n") else: cls.cdn_client_cert = None
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = api.Client(cls.cfg, api.json_handler) cls.core_client = CoreApiClient(configuration=cls.cfg.get_bindings_config()) cls.rpm_client = gen_rpm_client() cls.repo_api = RepositoriesRpmApi(cls.rpm_client) cls.remote_api = RemotesRpmApi(cls.rpm_client) cls.exporter_api = ExportersPulpApi(cls.core_client) cls.exports_api = ExportersPulpExportsApi(cls.core_client) cls.importer_api = ImportersPulpApi(cls.core_client) cls.imports_api = ImportersPulpImportsApi(cls.core_client) cls.dist_tree_api = ContentDistributionTreesApi(cls.rpm_client) cls.import_repos, cls.export_repos, cls.remotes = cls._setup_repositories( RPM_UNSIGNED_FIXTURE_URL ) cls.exporter = cls._create_exporter() cls.export = cls._create_export()
def setUpClass(cls): """ Create all the client instances needed to communicate with Pulp. """ configuration = Configuration(**BINDINGS_CONFIGURATION) file_client = FileApiClient(configuration) rpm_client = RpmApiClient(configuration) migration_client = MigrationApiClient(configuration) # Create api clients for File cls.file_repo_api = RepositoriesFileApi(file_client) cls.file_repo_versions_api = RepositoriesFileVersionsApi(file_client) cls.file_remote_api = RemotesFileApi(file_client) cls.file_distribution_api = DistributionsFileApi(file_client) cls.file_publication_api = PublicationsFileApi(file_client) cls.file_content_api = ContentFilesApi(file_client) # Create api clients for RPM cls.rpm_repo_api = RepositoriesRpmApi(rpm_client) cls.rpm_repo_versions_api = RepositoriesRpmVersionsApi(rpm_client) cls.rpm_remote_api = RemotesRpmApi(rpm_client) cls.rpm_distribution_api = DistributionsRpmApi(rpm_client) cls.rpm_publication_api = PublicationsRpmApi(rpm_client) cls.rpm_content_apis = { 'advisory': ContentAdvisoriesApi(rpm_client), 'disttree': ContentDistributionTreesApi(rpm_client), 'modulemd': ContentModulemdsApi(rpm_client), 'modulemd-defaults': ContentModulemdDefaultsApi(rpm_client), 'category': ContentPackagecategoriesApi(rpm_client), 'environment': ContentPackageenvironmentsApi(rpm_client), 'group': ContentPackagegroupsApi(rpm_client), 'langpack': ContentPackagelangpacksApi(rpm_client), 'package': ContentPackagesApi(rpm_client), } # Create api clients for Migration cls.migration_plans_api = MigrationPlansApi(migration_client) cls.pulp2content_api = Pulp2ContentApi(migration_client) cls.pulp2repositories_api = Pulp2RepositoriesApi(migration_client)
def do_test(self, url, policy="on_demand"): """Verify whether content served by pulp can be synced. The process of publishing content is more involved in Pulp 3 than it was under Pulp 2. Given a repository, the process is as follows: 1. Create a publication from the repository. (The latest repository version is selected if no version is specified.) A publication is a repository version plus metadata. 2. Create a distribution from the publication. The distribution defines at which URLs a publication is available, e.g. ``http://example.com/content/foo/`` and ``http://example.com/content/bar/``. Do the following: 1. Create, populate, publish, and distribute a repository. 2. Sync other repository using as remote url, the distribution base_url from the previous repository. """ client = gen_rpm_client() repo_api = RepositoriesRpmApi(client) remote_api = RemotesRpmApi(client) publications = PublicationsRpmApi(client) distributions = DistributionsRpmApi(client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_rpm_remote(url=url, policy=policy) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) # Sync a Repository repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) sync_task = tasks.read(sync_response.task) task_duration = sync_task.finished_at - sync_task.started_at waiting_time = sync_task.started_at - sync_task.pulp_created print( "\n-> Sync => Waiting time (s): {wait} | Service time (s): {service}".format( wait=waiting_time.total_seconds(), service=task_duration.total_seconds() ) ) repo = repo_api.read(repo.pulp_href) # Create a publication. publish_data = RpmRpmPublication(repository=repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task(publish_response.task).created_resources publication_href = created_resources[0] self.addCleanup(publications.delete, publication_href) # Create a distribution. body = gen_distribution() body["publication"] = publication_href distribution_response = distributions.create(body) created_resources = monitor_task(distribution_response.task).created_resources distribution = distributions.read(created_resources[0]) self.addCleanup(distributions.delete, distribution.pulp_href) # Create another repo pointing to distribution base_url repo2 = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo2.pulp_href) body = gen_rpm_remote(url=distribution.base_url, policy=policy) remote2 = remote_api.create(body) self.addCleanup(remote_api.delete, remote2.pulp_href) # Sync a Repository repository_sync_data = RpmRepositorySyncURL(remote=remote2.pulp_href) sync_response = repo_api.sync(repo2.pulp_href, repository_sync_data) monitor_task(sync_response.task) sync_task = tasks.read(sync_response.task) task_duration = sync_task.finished_at - sync_task.started_at waiting_time = sync_task.started_at - sync_task.pulp_created print( "\n-> Sync => Waiting time (s): {wait} | Service time (s): {service}".format( wait=waiting_time.total_seconds(), service=task_duration.total_seconds() ) ) repo2 = repo_api.read(repo2.pulp_href) summary = get_content_summary(repo.to_dict()) summary2 = get_content_summary(repo2.to_dict()) self.assertDictEqual(summary, summary2) added = get_added_content_summary(repo.to_dict()) added2 = get_added_content_summary(repo2.to_dict()) self.assertDictEqual(added, added2)
def do_test(self, policy): """Verify whether content served by pulp can be synced. The process of publishing content is more involved in Pulp 3 than it was under Pulp 2. Given a repository, the process is as follows: 1. Create a publication from the repository. (The latest repository version is selected if no version is specified.) A publication is a repository version plus metadata. 2. Create a distribution from the publication. The distribution defines at which URLs a publication is available, e.g. ``http://example.com/content/foo/`` and ``http://example.com/content/bar/``. Do the following: 1. Create, populate, publish, and distribute a repository. 2. Sync other repository using as remote url, the distribution base_url from the previous repository. """ client = gen_rpm_client() repo_api = RepositoriesRpmApi(client) remote_api = RemotesRpmApi(client) publications = PublicationsRpmApi(client) distributions = DistributionsRpmApi(client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_rpm_remote(url=RPM_KICKSTART_FIXTURE_URL, policy=policy) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) # Sync a Repository repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo = repo_api.read(repo.pulp_href) # Create a publication. publish_data = RpmRpmPublication( repository=repo.pulp_href, metadata_checksum_type="sha1", package_checksum_type="sha224", ) publish_response = publications.create(publish_data) created_resources = monitor_task(publish_response.task) publication_href = created_resources[0] self.addCleanup(publications.delete, publication_href) # Create a distribution. body = gen_distribution() body["publication"] = publication_href distribution_response = distributions.create(body) created_resources = monitor_task(distribution_response.task) distribution = distributions.read(created_resources[0]) self.addCleanup(distributions.delete, distribution.pulp_href) # Create another repo pointing to distribution base_url repo2 = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo2.pulp_href) body = gen_rpm_remote(url=distribution.base_url, policy=policy) remote2 = remote_api.create(body) self.addCleanup(remote_api.delete, remote2.pulp_href) # Sync a Repository repository_sync_data = RpmRepositorySyncURL(remote=remote2.pulp_href) sync_response = repo_api.sync(repo2.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo2 = repo_api.read(repo2.pulp_href) summary = get_content_summary(repo.to_dict()) summary2 = get_content_summary(repo2.to_dict()) self.assertDictEqual(summary, summary2) added = get_added_content_summary(repo.to_dict()) added2 = get_added_content_summary(repo2.to_dict()) self.assertDictEqual(added, added2)
def rpm_rpmremote_api(rpm_client): """Fixture for RPM remote API.""" return RemotesRpmApi(rpm_client)
def do_test(self, download_policy): """Sync repositories with the different ``download_policy``. Do the following: 1. Create a repository, and a remote. 2. Sync the remote. 3. Assert that repository version is not None. 4. Assert that the correct number of possible units to be downloaded were shown. 5. Sync the remote one more time in order to create another repository version. 6. Assert that repository version is different from the previous one. 7. Assert that the same number of units are shown, and after the second sync no extra units should be shown, since the same remote was synced again. 8. Publish repository synced with lazy ``download_policy``. """ repo_api = RepositoriesRpmApi(self.client) remote_api = RemotesRpmApi(self.client) publications = PublicationsRpmApi(self.client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_rpm_remote(**{"policy": download_policy}) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) # Sync the repository. self.assertEqual(repo.latest_version_href, f"{repo.pulp_href}versions/0/") repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo = repo_api.read(repo.pulp_href) self.assertDictEqual(get_content_summary(repo.to_dict()), RPM_FIXTURE_SUMMARY) self.assertDictEqual(get_added_content_summary(repo.to_dict()), RPM_FIXTURE_SUMMARY) # Sync the repository again. latest_version_href = repo.latest_version_href sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo = repo_api.read(repo.pulp_href) self.assertEqual(latest_version_href, repo.latest_version_href) self.assertDictEqual(get_content_summary(repo.to_dict()), RPM_FIXTURE_SUMMARY) # Publish publish_data = RpmRpmPublication(repository=repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task(publish_response.task) publication_href = created_resources[0] self.addCleanup(publications.delete, publication_href) publication = publications.read(publication_href) self.assertIsNotNone(publication.repository) self.assertIsNotNone(publication.repository_version)
def test_all(self): """Test whether a particular repository version can be published. 1. Create a repository with at least 2 repository versions. 2. Create a publication by supplying the latest ``repository_version``. 3. Assert that the publication ``repository_version`` attribute points to the latest repository version. 4. Create a publication by supplying the non-latest ``repository_version``. 5. Assert that the publication ``repository_version`` attribute points to the supplied repository version. 6. Assert that an exception is raised when providing two different repository versions to be published at same time. """ cfg = config.get_config() client = gen_rpm_client() repo_api = RepositoriesRpmApi(client) remote_api = RemotesRpmApi(client) publications = PublicationsRpmApi(client) body = gen_rpm_remote() remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) repository_sync_data = RpmRepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) # Step 1 repo = repo_api.read(repo.pulp_href) for rpm_content in get_content( repo.to_dict())[RPM_PACKAGE_CONTENT_NAME]: modify_repo(cfg, repo.to_dict(), add_units=[rpm_content]) version_hrefs = tuple(ver["pulp_href"] for ver in get_versions(repo.to_dict())) non_latest = choice(version_hrefs[:-1]) # Step 2 publish_data = RpmRpmPublication(repository=repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task( publish_response.task).created_resources publication_href = created_resources[0] self.addCleanup(publications.delete, publication_href) publication = publications.read(publication_href) # Step 3 self.assertEqual(publication.repository_version, version_hrefs[-1]) # Step 4 publish_data.repository_version = non_latest publish_data.repository = None publish_response = publications.create(publish_data) created_resources = monitor_task( publish_response.task).created_resources publication_href = created_resources[0] publication = publications.read(publication_href) # Step 5 self.assertEqual(publication.repository_version, non_latest) # Step 6 with self.assertRaises(ApiException): body = { "repository": repo.pulp_href, "repository_version": non_latest } publications.create(body)