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. Create distribution. 6. Assert that the publication ``repository_version`` attribute points to the supplied repository version. 7. Assert that an exception is raised when providing two different repository versions to be published at same time. """ # Step 1 for file_content in get_content( self.repo.to_dict())[FILE_CONTENT_NAME]: modify_repo(self.cfg, self.repo.to_dict(), remove_units=[file_content]) version_hrefs = tuple(ver["pulp_href"] for ver in get_versions(self.repo.to_dict())) non_latest = choice(version_hrefs[:-1]) # Step 2 publish_data = FileFilePublication(repository=self.repo.pulp_href) publication = self.create_publication(publish_data) # Step 3 self.assertEqual(publication.repository_version, version_hrefs[-1]) # Step 4 publish_data = FileFilePublication(repository_version=non_latest) publication = self.create_publication(publish_data) # Step 5 body = gen_distribution() body["base_path"] = "pulp_post_upgrade_test" body["publication"] = publication.pulp_href distribution_response = self.distributions.create(body) created_resources = monitor_task( distribution_response.task).created_resources distribution = self.distributions.read(created_resources[0]) # Step 6 self.assertEqual(publication.repository_version, non_latest) # Step 7 with self.assertRaises(ApiException): body = { "repository": self.repo.pulp_href, "repository_version": non_latest } self.publications.create(body) # Step 8 url = self.cfg.get_content_host_base_url( ) + "/pulp/content/pulp_post_upgrade_test/" self.assertEqual(url, distribution.base_url, url)
def test_custom_manifest(self): """Test whether a repository version can be published with a specified manifest.""" publish_data = FileFilePublication(repository=self.repo.pulp_href) publication = self.create_publication(publish_data) self.assertEqual(publication.manifest, "PULP_MANIFEST") publish_data = FileFilePublication(repository=self.repo.pulp_href, manifest="listing") publication = self.create_publication(publish_data) self.assertEqual(publication.manifest, "listing")
def _repo_sync_distribute(self, policy="immediate"): """Helper to create & populate a repository and distribute it.""" repo = self.repo_api.create(gen_repo()) self.addCleanup(self.repo_api.delete, repo.pulp_href) # sync the repository with passed in policy body = gen_file_remote(**{"policy": policy}) remote = self.remote_api.create(body) self.addCleanup(self.remote_api.delete, remote.pulp_href) # sync repo repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = self.repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo = self.repo_api.read(repo.pulp_href) # Publication publication_data = FileFilePublication(repository=repo.pulp_href) publication_response = self.publication_api.create(publication_data) task_response = monitor_task(publication_response.task) publication = self.publication_api.read( task_response.created_resources[0]) self.addCleanup(self.publication_api.delete, publication.pulp_href) # Distribution body = gen_distribution() body["publication"] = publication.pulp_href distribution_response = self.distributions_api.create(body) created_resources = monitor_task( distribution_response.task).created_resources distribution = self.distributions_api.read(created_resources[0]) self.addCleanup(self.distributions_api.delete, distribution.pulp_href) return repo, distribution
def _setup_repositories(cls): """Create and sync a number of repositories to be exported.""" # create and remember a set of repo repos = [] remotes = [] publications = [] for r in range(NUM_REPOS): repo = cls.repo_api.create(gen_repo()) remote = cls.remote_api.create(gen_file_remote()) repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = cls.repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo = cls.repo_api.read(file_file_repository_href=repo.pulp_href) publish_data = FileFilePublication(repository=repo.pulp_href) publish_response = cls.publication_api.create(publish_data) created_resources = monitor_task( publish_response.task).created_resources publication_href = created_resources[0] publication = cls.publication_api.read(publication_href) repos.append(repo) remotes.append(remote) publications.append(publication) return repos, remotes, publications
def do_publish(self, download_policy): """Publish repository synced with lazy download policy.""" repo_api = RepositoriesFileApi(self.client) remote_api = RemotesFileApi(self.client) publications = PublicationsFileApi(self.client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_file_remote(policy=download_policy) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RepositorySyncURL(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) publish_data = FileFilePublication(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) self.assertIsNotNone(publication.repository_version, publication)
def setup_download_test(self, policy, url=None, publish=True): # Create a repository self.repo = self.repo_api.create(gen_repo()) self.addCleanup(self.repo_api.delete, self.repo.pulp_href) # Create a remote remote_options = {"policy": policy} if url: remote_options["url"] = url self.remote = self.remote_api.create(gen_file_remote(**remote_options)) self.addCleanup(self.remote_api.delete, self.remote.pulp_href) # Sync the repository. repository_sync_data = RepositorySyncURL(remote=self.remote.pulp_href) sync_response = self.repo_api.sync(self.repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) if publish: # Create a publication. publish_data = FileFilePublication(repository=self.repo.pulp_href) publish_response = self.publications_api.create(publish_data) publication_href = monitor_task(publish_response.task).created_resources[0] self.addCleanup(self.publications_api.delete, publication_href) serve, served_href = "publication", publication_href else: serve, served_href = "repository", self.repo.pulp_href # Create a distribution. response = self.distributions_api.create(gen_distribution(**{serve: served_href})) distribution_href = monitor_task(response.task).created_resources[0] self.distribution = self.distributions_api.read(distribution_href) self.addCleanup(self.distributions_api.delete, self.distribution.pulp_href)
def setUpClass(cls): """Sets up class""" client = gen_file_client() cls.cont_api = ContentFilesApi(client) cls.repo_api = RepositoriesFileApi(client) cls.remote_api = RemotesFileApi(client) cls.pub_api = PublicationsFileApi(client) cls.dis_api = DistributionsFileApi(client) cls.repo = cls.repo_api.create(gen_repo(autopublish=True)) cls.remote = cls.remote_api.create(gen_file_remote()) body = RepositorySyncURL(remote=cls.remote.pulp_href) created = monitor_task( cls.repo_api.sync(cls.repo.pulp_href, body).task).created_resources cls.repo = cls.repo_api.read(cls.repo.pulp_href) cls.pub1 = cls.pub_api.read(created[1]) body = FileFilePublication(repository=cls.repo.pulp_href) cls.pub2 = cls.pub_api.read( monitor_task(cls.pub_api.create(body).task).created_resources[0]) cls.pub3 = [] response = cls.dis_api.create( gen_distribution(repository=cls.repo.pulp_href)) cls.distro = cls.dis_api.read( monitor_task(response.task).created_resources[0]) cls.distro2 = [] cls.url = urljoin(PULP_CONTENT_BASE_URL, f"{cls.distro.base_path}/")
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. """ # Step 1 for file_content in get_content( self.repo.to_dict())[FILE_CONTENT_NAME]: modify_repo(self.cfg, self.repo.to_dict(), remove_units=[file_content]) version_hrefs = tuple(ver["pulp_href"] for ver in get_versions(self.repo.to_dict())) non_latest = choice(version_hrefs[:-1]) # Step 2 publish_data = FileFilePublication(repository=self.repo.pulp_href) publication = self.create_publication(publish_data) # Step 3 self.assertEqual(publication.repository_version, version_hrefs[-1]) # Step 4 publish_data = FileFilePublication(repository_version=non_latest) publication = self.create_publication(publish_data) # Step 5 self.assertEqual(publication.repository_version, non_latest) # Step 6 with self.assertRaises(ApiException): body = { "repository": self.repo.pulp_href, "repository_version": non_latest } self.publications.create(body)
def setUpClass(cls): """ Initialize Pulp to make authorization assertions using client certificates. 0. Create a FileRepository 1. Create a FileRemote 2. Sync in a few units we can use to fetch with 3. Create a Publication 4. Create a CertGuard with the CA cert used to sign all client certificates 5. Create a Distribution for the publication that is protected by the CertGuard """ cls.teardown_cleanups = [] cls.cfg = config.get_config() file_client = gen_file_client() repo_api = RepositoriesFileApi(file_client) remote_api = RemotesFileApi(file_client) publications = PublicationsFileApi(file_client) cls.distributions_api = DistributionsFileApi(file_client) cls.repo = repo_api.create(gen_repo()) cls.teardown_cleanups.append((repo_api.delete, cls.repo.pulp_href)) body = gen_file_remote(policy="immediate") remote = remote_api.create(body) cls.teardown_cleanups.append((remote_api.delete, remote.pulp_href)) # Sync a Repository repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(cls.repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) cls.repo = repo_api.read(cls.repo.pulp_href) # Create a publication. publish_data = FileFilePublication(repository=cls.repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task(publish_response.task) publication_href = created_resources[0] cls.teardown_cleanups.append((publications.delete, publication_href)) content_guard_href = cls._setup_content_guard() # Create a distribution. body = gen_distribution() body["publication"] = publication_href body["content_guard"] = content_guard_href distribution_response = cls.distributions_api.create(body) created_resources = monitor_task(distribution_response.task) cls.distribution = cls.distributions_api.read(created_resources[0]) cls.teardown_cleanups.append((cls.distributions_api.delete, cls.distribution.pulp_href))
def test_access_error(self): """HTTP error is not raised when accessing published data.""" repo_api = RepositoriesFileApi(self.client) remote_api = RemotesFileApi(self.client) publications = PublicationsFileApi(self.client) distributions = DistributionsFileApi(self.client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) remote = remote_api.create(gen_file_remote()) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RepositorySyncURL(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) publish_data = FileFilePublication(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) 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) pulp_manifest = parse_pulp_manifest( self.download_pulp_manifest(distribution.to_dict(), "PULP_MANIFEST")) self.assertEqual(len(pulp_manifest), FILE_FIXTURE_COUNT, pulp_manifest)
def test_all(self): """Create two publications and check view filter.""" repo = self.repo_api.create(gen_repo()) self.addCleanup(self.repo_api.delete, repo.pulp_href) remote = self.remote_api.create(gen_file_remote()) self.addCleanup(self.remote_api.delete, remote.pulp_href) # Sync and update repository data. repo_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = self.repo_api.sync(repo.pulp_href, repo_sync_data) monitor_task(sync_response.task) repo = self.repo_api.read(repo.pulp_href) # Test content doesn't exists. non_existant_content_href = ( "/pulp/api/v3/content/file/files/c4ed74cf-a806-490d-a25f-94c3c3dd2dd7/" ) with self.assertRaises(ApiException) as ctx: self.publication_api.list(content=non_existant_content_href) self.assertEqual(ctx.exception.status, 400) # Test not published content. content_href = get_content( repo.to_dict())[FILE_CONTENT_NAME][0]["pulp_href"] self.assertEqual( self.publication_api.list(content=content_href).to_dict()["count"], 0) # Publication publication_data = FileFilePublication(repository=repo.pulp_href) publication_response = self.publication_api.create(publication_data) task_response = monitor_task(publication_response.task) publication = self.publication_api.read( task_response.created_resources[0]) self.addCleanup(self.publication_api.delete, publication.pulp_href) # Second publication repo_second = self.repo_api.create(gen_repo()) self.addCleanup(self.repo_api.delete, repo_second.pulp_href) body = gen_file_remote(url=FILE_MANY_FIXTURE_MANIFEST_URL) remote_second = self.remote_api.create(body) self.addCleanup(self.remote_api.delete, remote_second.pulp_href) repo_second_sync_data = RepositorySyncURL( remote=remote_second.pulp_href) sync_response = self.repo_api.sync(repo_second.pulp_href, repo_second_sync_data) monitor_task(sync_response.task) repo_second = self.repo_api.read(repo_second.pulp_href) publication_data = FileFilePublication( repository=repo_second.pulp_href) publication_response = self.publication_api.create(publication_data) task_response = monitor_task(publication_response.task) publication_second = self.publication_api.read( task_response.created_resources[0]) self.addCleanup(self.publication_api.delete, publication_second.pulp_href) # Test there are two publications self.assertEqual(self.publication_api.list().count, 2) # Test content match publication self.assertEqual( self.publication_api.list(content=content_href).count, 1) self.assertEqual( self.publication_api.list( content=content_href).results[0].repository_version, repo.latest_version_href, )
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_file_client() repo_api = RepositoriesFileApi(client) remote_api = RemotesFileApi(client) publications = PublicationsFileApi(client) body = gen_file_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 = RepositorySyncURL(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 file_content in get_content(repo.to_dict())[FILE_CONTENT_NAME]: modify_repo(cfg, repo.to_dict(), remove_units=[file_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 = FileFilePublication(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) # Step 3 self.assertEqual(publication.repository_version, version_hrefs[-1]) # Step 4 publish_data = FileFilePublication(repository_version=non_latest) publish_response = publications.create(publish_data) created_resources = monitor_task(publish_response.task) 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)
# Create a FileContent from the artifact filecontent_response = filecontent.create(relative_path="foo.tar.gz", artifact=artifact.pulp_href) created_resources = monitor_task(filecontent_response.task) # Add the new FileContent to a repository version repo_version_data = {"add_content_units": [created_resources[0]]} repo_version_response = filerepositories.modify(repository.pulp_href, repo_version_data) # Monitor the repo version creation task created_resources = monitor_task(repo_version_response.task) repository_version_2 = filerepoversions.read(created_resources[0]) pprint(repository_version_2) # List all the repository versions filerepoversions.list(repository.pulp_href) # Create a publication from the latest version of the repository publish_data = FileFilePublication(repository=repository.pulp_href) publish_response = filepublications.create(publish_data) # Monitor the publish task created_resources = monitor_task(publish_response.task) publication_href = created_resources[0] distribution_data = FileFileDistribution( name="baz25", base_path="foo25", publication=publication_href ) distribution = filedistributions.create(distribution_data) pprint(distribution)
def do_test(self, policy): """Verify whether content served by pulp can be downloaded. 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. Select a random content unit in the distribution. Download that content unit from Pulp, and verify that the content unit has the same checksum when fetched directly from Pulp-Fixtures. This test targets the following issues: * `Pulp #2895 <https://pulp.plan.io/issues/2895>`_ * `Pulp Smash #872 <https://github.com/pulp/pulp-smash/issues/872>`_ """ cfg = config.get_config() client = gen_file_client() repo_api = RepositoriesFileApi(client) remote_api = RemotesFileApi(client) publications = PublicationsFileApi(client) distributions = DistributionsFileApi(client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_file_remote(policy=policy) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) # Sync a Repository repository_sync_data = RepositorySyncURL(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 = FileFilePublication(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) # 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) # Pick a file, and download it from both Pulp Fixtures… unit_path = choice(get_file_content_paths(repo.to_dict())) fixtures_hash = hashlib.sha256( utils.http_get(urljoin(FILE_FIXTURE_URL, unit_path))).hexdigest() # …and Pulp. content = download_content_unit(cfg, distribution.to_dict(), unit_path) pulp_hash = hashlib.sha256(content).hexdigest() self.assertEqual(fixtures_hash, pulp_hash)