def test_05_delete(self): """Delete a distribution.""" delete_response = self.distribution_api.delete( self.distribution["pulp_href"]) monitor_task(delete_response.task) with self.assertRaises(ApiException): self.distribution_api.read(self.distribution["pulp_href"])
def test_repository_only(self): """Passing only a repository does not create a new version.""" add_response = self.repositories_api.add(self.to_repo.pulp_href, {}) monitor_task(add_response.task) latest_version_href = self.repositories_api.read(self.to_repo.pulp_href).latest_version_href self.assertEqual(latest_version_href, self.to_repo.latest_version_href)
def test_copy_multiple_manifests_by_digest(self): """Specify digests to copy.""" ml_i_href = ( self.tags_api.list(name="ml_i", repository_version=self.latest_from_version) .results[0] .tagged_manifest ) ml_i_digest = self.manifests_api.read(ml_i_href).digest ml_ii_href = ( self.tags_api.list(name="ml_ii", repository_version=self.latest_from_version) .results[0] .tagged_manifest ) ml_ii_digest = self.manifests_api.read(ml_ii_href).digest copy_response = self.repositories_api.copy_manifests( self.to_repo.pulp_href, { "source_repository": self.from_repo.pulp_href, "digests": [ml_i_digest, ml_ii_digest], }, ) monitor_task(copy_response.task) to_repo = self.repositories_api.read(self.to_repo.pulp_href) to_repo_content = self.versions_api.read( to_repo.latest_version_href ).content_summary.present self.assertFalse("container.tag" in to_repo_content) # each manifest list is a manifest and references 2 other manifests self.assertEqual(to_repo_content["container.manifest"]["count"], 6) # each referenced manifest has 2 blobs self.assertEqual(to_repo_content["container.blob"]["count"], 8)
def test_cannot_remove_tagged_manifest(self): """ Try to remove a manifest (without removing tag). Creates a new version, but nothing removed. """ manifest_a_tag = self.tags_api.list( name="manifest_a", repository_version=self.latest_from_version).results[0] add_response = self.repositories_api.add( self.to_repo.pulp_href, {"content_units": [manifest_a_tag.pulp_href]}) monitor_task(add_response.task) latest_version_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) self.assertEqual( latest.content_summary.added["container.tag"]["count"], 1) self.assertEqual( latest.content_summary.added["container.manifest"]["count"], 1) self.assertEqual( latest.content_summary.added["container.blob"]["count"], 2) remove_respone = self.repositories_api.remove( self.to_repo.pulp_href, {"content_units": [manifest_a_tag.tagged_manifest]}) monitor_task(remove_respone.task) latest_version_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) for content_type in [ "container.tag", "container.manifest", "container.blob" ]: self.assertFalse(content_type in latest.content_summary.removed, msg=content_type)
def test_remove_everything(self): """Add a manifest and its related blobs.""" manifest_a = (self.tags_api.list( name="manifest_a", repository_version=self.latest_from_version). results[0].tagged_manifest) add_response = self.repositories_api.add( self.to_repo.pulp_href, {"content_units": [manifest_a]}) monitor_task(add_response.task) latest_version_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) # Ensure test begins in the correct state self.assertFalse("container.tag" in latest.content_summary.added) self.assertEqual( latest.content_summary.added["container.manifest"]["count"], 1) self.assertEqual( latest.content_summary.added["container.blob"]["count"], 2) # Actual test remove_response = self.repositories_api.remove( self.to_repo.pulp_href, {"content_units": ["*"]}) monitor_task(remove_response.task) latest_version_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) self.assertEqual(latest.content_summary.present, {}) self.assertEqual( latest.content_summary.removed["container.blob"]["count"], 2) self.assertEqual( latest.content_summary.removed["container.manifest"]["count"], 1)
def test_manifest_list_recursion(self): """Add a Manifest List, related manifests, and related blobs.""" ml_i = (self.tags_api.list(name="ml_i", repository_version=self.latest_from_version ).results[0].tagged_manifest) add_response = self.repositories_api.add(self.to_repo.pulp_href, {"content_units": [ml_i]}) monitor_task(add_response.task) latest_version_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) # Ensure test begins in the correct state self.assertFalse("container.tag" in latest.content_summary.added) self.assertEqual( latest.content_summary.added["container.manifest"]["count"], 3) self.assertEqual( latest.content_summary.added["container.blob"]["count"], 4) # Actual test remove_response = self.repositories_api.remove( self.to_repo.pulp_href, {"content_units": [ml_i]}) monitor_task(remove_response.task) latest_version_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) self.assertFalse("container.tag" in latest.content_summary.removed) self.assertEqual( latest.content_summary.removed["container.manifest"]["count"], 3) self.assertEqual( latest.content_summary.removed["container.blob"]["count"], 4)
def test_tagged_manifest_recursion(self): """Add a tagged manifest and its related blobs.""" manifest_a_tag = (self.tags_api.list( name="manifest_a", repository_version=self.latest_from_version).results[0].pulp_href) add_response = self.repositories_api.add( self.to_repo.pulp_href, {"content_units": [manifest_a_tag]}) monitor_task(add_response.task) latest_version_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) # Ensure valid starting state self.assertEqual( latest.content_summary.added["container.tag"]["count"], 1) self.assertEqual( latest.content_summary.added["container.manifest"]["count"], 1) self.assertEqual( latest.content_summary.added["container.blob"]["count"], 2) # Actual test remove_response = self.repositories_api.remove( self.to_repo.pulp_href, {"content_units": [manifest_a_tag]}) monitor_task(remove_response.task) latest_version_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) self.assertEqual( latest.content_summary.removed["container.tag"]["count"], 1) self.assertEqual( latest.content_summary.removed["container.manifest"]["count"], 1) self.assertEqual( latest.content_summary.removed["container.blob"]["count"], 2)
def test_tag_replacement(self): """Add a tagged manifest to a repo with a tag of that name already in place.""" manifest_a_tag = (self.tags_api.list( name="manifest_a", repository_version=self.latest_from_version).results[0].pulp_href) # Add manifest_b to the repo manifest_b = (self.tags_api.list( name="manifest_b", repository_version=self.latest_from_version). results[0].tagged_manifest) manifest_b_digest = self.manifests_api.read(manifest_b).digest add_response = self.repositories_api.add( self.to_repo.pulp_href, {"content_units": [manifest_b]}) monitor_task(add_response.task) # Tag manifest_b as `manifest_a` params = {"tag": "manifest_a", "digest": manifest_b_digest} self.repositories_api.tag(self.to_repo.pulp_href, params) # Now add original manifest_a tag to the repo, which should remove the # new manifest_a tag, but leave the tagged manifest (manifest_b) add_response = self.repositories_api.add( self.to_repo.pulp_href, {"content_units": [manifest_a_tag]}) monitor_task(add_response.task) latest_version_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) self.assertEqual( latest.content_summary.added["container.tag"]["count"], 1) self.assertEqual( latest.content_summary.removed["container.tag"]["count"], 1) self.assertFalse( "container.manifest" in latest.content_summary.removed) self.assertFalse("container.blob" in latest.content_summary.removed)
def setUpClass(cls): """Create class wide-variables.""" cls.cfg = config.get_config() gen_token_signing_keys(cls.cfg) cls.client = api.Client(cls.cfg, api.page_handler) api_client = gen_container_client() cls.repositories_api = RepositoriesContainerApi(api_client) cls.remotes_api = RemotesContainerApi(api_client) cls.distributions_api = DistributionsContainerApi(api_client) cls.repository = cls.repositories_api.create( ContainerContainerRepository(**gen_repo())) remote_data = gen_container_remote( upstream_name=DOCKERHUB_PULP_FIXTURE_1) cls.remote = cls.remotes_api.create( ContainerContainerRemote(**remote_data)) sync_data = RepositorySyncURL(remote=cls.remote.pulp_href) sync_response = cls.repositories_api.sync(cls.repository.pulp_href, sync_data) monitor_task(sync_response.task) distribution_data = gen_distribution( repository=cls.repository.pulp_href) distribution_response = cls.distributions_api.create( ContainerContainerDistribution(**distribution_data)) created_resources = monitor_task(distribution_response.task) cls.distribution = cls.distributions_api.read(created_resources[0])
def test_many_tagged_manifest_lists(self): """Add several Manifest List, related manifests, and related blobs.""" ml_i_tag = ( self.tags_api.list(name="ml_i", repository_version=self.latest_from_version) .results[0] .pulp_href ) ml_ii_tag = ( self.tags_api.list(name="ml_ii", repository_version=self.latest_from_version) .results[0] .pulp_href ) ml_iii_tag = ( self.tags_api.list(name="ml_iii", repository_version=self.latest_from_version) .results[0] .pulp_href ) ml_iv_tag = ( self.tags_api.list(name="ml_iv", repository_version=self.latest_from_version) .results[0] .pulp_href ) add_response = self.repositories_api.add( self.to_repo.pulp_href, {"content_units": [ml_i_tag, ml_ii_tag, ml_iii_tag, ml_iv_tag]}, ) monitor_task(add_response.task) latest_version_href = self.repositories_api.read(self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) self.assertEqual(latest.content_summary.added["container.tag"]["count"], 4) self.assertEqual(latest.content_summary.added["container.manifest"]["count"], 9) self.assertEqual(latest.content_summary.added["container.blob"]["count"], 10)
def test_copy_manifest_by_digest_and_media_type(self): """Specify a single manifest by digest to copy.""" manifest_a_href = ( self.tags_api.list(name="manifest_a", repository_version=self.latest_from_version) .results[0] .tagged_manifest ) manifest_a_digest = self.manifests_api.read(manifest_a_href).digest copy_response = self.repositories_api.copy_manifests( self.to_repo.pulp_href, { "source_repository": self.from_repo.pulp_href, "digests": [manifest_a_digest], "media_types": [MEDIA_TYPE.MANIFEST_V2], }, ) monitor_task(copy_response.task) to_repo = self.repositories_api.read(self.to_repo.pulp_href) to_repo_content = self.versions_api.read( to_repo.latest_version_href ).content_summary.present self.assertFalse("container.tag" in to_repo_content) self.assertEqual(to_repo_content["container.manifest"]["count"], 1) # manifest_a has 2 blobs self.assertEqual(to_repo_content["container.blob"]["count"], 2)
def test_copy_tags_by_name_empty_list(self): """Passing an empty list of names copies nothing.""" copy_response = self.repositories_api.copy_tags( self.to_repo.pulp_href, {"source_repository": self.from_repo.pulp_href, "names": []}, ) monitor_task(copy_response.task) latest_to_repo_href = self.repositories_api.read(self.to_repo.pulp_href).latest_version_href # Assert a new version was not created self.assertEqual(latest_to_repo_href, f"{self.to_repo.pulp_href}versions/0/")
def test_04_fully_update(self): """Update a remote using HTTP PUT.""" body = _gen_verbose_remote() response = self.remote_api.update(self.remote.pulp_href, body) monitor_task(response.task) for key in ("username", "password"): del body[key] type(self).remote = self.remote_api.read(self.remote.pulp_href) for key, val in body.items(): with self.subTest(key=key): self.assertEqual(self.remote.to_dict()[key], val, key)
def test_02_change_policy(self): """Verify ability to change policy to value other than the default. Update the remote policy to a valid value other than `immedaite` and verify the new set value. """ changed_policy = choice( [item for item in self.policies if item != "immediate"]) response = self.remote_api.partial_update(self.remote["pulp_href"], {"policy": changed_policy}) monitor_task(response.task) self.remote.update( self.remote_api.read(self.remote["pulp_href"]).to_dict()) self.assertEqual(self.remote["policy"], changed_policy, self.remote)
def test_all(self): """ Sync a repository using a Remote url that does not exist. Test that we get a task failure. """ client_api = gen_container_client() repository_api = RepositoriesContainerApi(client_api) repository = repository_api.create( ContainerContainerRepository(**gen_repo())) self.addCleanup(repository_api.delete, repository.pulp_href) remote_api = RemotesContainerApi(client_api) remote_data = gen_container_remote( url="http://i-am-an-invalid-url.com/invalid/") remote = remote_api.create(ContainerContainerRemote(**remote_data)) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = repository_api.sync(repository.pulp_href, repository_sync_data) task = monitor_task(sync_response.task) if isinstance(task, dict): self.assertIsNotNone(task["error"]["description"]) else: self.assertFalse("Sync with an invalid remote URL was successful")
def test_04_fully_update(self): """Update a distribution using HTTP PUT.""" body = gen_distribution() distribution_data = ContainerContainerDistribution(**body) distribution_response = self.distribution_api.update( self.distribution["pulp_href"], distribution_data) monitor_task(distribution_response.task) distribution_obj = self.distribution_api.read( self.distribution["pulp_href"]) self.distribution.clear() self.distribution.update(distribution_obj.to_dict()) for key, val in body.items(): with self.subTest(key=key): self.assertEqual(self.distribution[key], val)
def test_copy_tags_by_name(self): """Copy tags in destination repo that match name.""" copy_response = self.repositories_api.copy_tags( self.to_repo.pulp_href, {"source_repository": self.from_repo.pulp_href, "names": ["ml_i", "manifest_c"]}, ) monitor_task(copy_response.task) to_repo = self.repositories_api.read(self.to_repo.pulp_href) to_repo_content = self.versions_api.read( to_repo.latest_version_href ).content_summary.present self.assertEqual(to_repo_content["container.tag"]["count"], 2) # ml_i has 1 manifest list, 2 manifests, manifest_c has 1 manifest self.assertEqual(to_repo_content["container.manifest"]["count"], 4) # each manifest (not manifest list) has 2 blobs self.assertEqual(to_repo_content["container.blob"]["count"], 6)
def test_copy_all_manifest_lists_by_media_type(self): """Specify the media_type, to copy all manifest lists.""" copy_response = self.repositories_api.copy_manifests( self.to_repo.pulp_href, { "source_repository": self.from_repo.pulp_href, "media_types": [MEDIA_TYPE.MANIFEST_LIST] }) monitor_task(copy_response.task) to_repo = self.repositories_api.read(self.to_repo.pulp_href) to_repo_content = self.versions_api.read( to_repo.latest_version_href).content_summary.present self.assertFalse("container.tag" in to_repo_content) # Fixture has 4 manifest lists, which combined reference 5 manifests self.assertEqual(to_repo_content["container.manifest"]["count"], "9") # each manifest (non-list) has 2 blobs self.assertEqual(to_repo_content["container.blob"]["count"], "10")
def test_manifest_list_recursion(self): """Add a Manifest List, related manifests, and related blobs.""" ml_i = ( self.tags_api.list(name="ml_i", repository_version=self.latest_from_version,) .results[0] .tagged_manifest ) add_response = self.repositories_api.add(self.to_repo.pulp_href, {"content_units": [ml_i]}) monitor_task(add_response.task) latest_version_href = self.repositories_api.read(self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) # No tags added self.assertFalse("container.tag" in latest.content_summary.added) # 1 manifest list 2 manifests self.assertEqual(latest.content_summary.added["container.manifest"]["count"], 3)
def test_tagged_manifest_list_recursion(self): """Add a tagged manifest list, and its related manifests and blobs.""" ml_i_tag = ( self.tags_api.list(name="ml_i", repository_version=self.latest_from_version) .results[0] .pulp_href ) add_response = self.repositories_api.add( self.to_repo.pulp_href, {"content_units": [ml_i_tag]} ) monitor_task(add_response.task) latest_version_href = self.repositories_api.read(self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) self.assertEqual(latest.content_summary.added["container.tag"]["count"], 1) # 1 manifest list 2 manifests self.assertEqual(latest.content_summary.added["container.manifest"]["count"], 3) self.assertEqual(latest.content_summary.added["container.blob"]["count"], 4)
def test_sync_idempotency(self): """Ensure that sync does not create orphan tags https://pulp.plan.io/issues/5252 .""" sync_data = RepositorySyncURL(remote=self.remote.pulp_href) sync_response = self.repository_api.sync(self.from_repo.pulp_href, sync_data) monitor_task(sync_response.task) tags_api = ContentTagsApi(self.client_api) first_sync_tags_named_a = tags_api.list(name="manifest_a") sync_response = self.repository_api.sync(self.from_repo.pulp_href, sync_data) monitor_task(sync_response.task) second_sync_tags_named_a = tags_api.list(name="manifest_a") self.assertEqual(first_sync_tags_named_a.count, 1) self.assertEqual(second_sync_tags_named_a.count, 1)
def test_copy_all_manifests_from_version(self): """Passing only source version copies all manifests.""" latest_from = self.repositories_api.read(self.from_repo.pulp_href) copy_response = self.repositories_api.copy_manifests( self.to_repo.pulp_href, { "source_repository_version": latest_from.latest_version_href, }) monitor_task(copy_response.task) latest_to = self.repositories_api.read(self.to_repo.pulp_href) to_repo_content = self.versions_api.read( latest_to.latest_version_href).content_summary.present from_repo_content = self.versions_api.read( latest_from.latest_version_href).content_summary.present for container_type in ["container.manifest", "container.blob"]: self.assertEqual(to_repo_content[container_type]["count"], from_repo_content[container_type]["count"]) self.assertFalse("container.tag" in to_repo_content)
def test_sync(self): """Sync repositories with the container plugin. In order to sync a repository a remote has to be associated within this repository. When a repository is created this version field is set as None. After a sync the repository version is updated. Do the following: 1. Create a repository, and a remote. 2. Assert that repository version is None. 3. Sync the remote. 4. Assert that repository version is not None. 5. Sync the remote one more time. 6. Assert that repository version is the same from the previous one. """ repository_api = RepositoriesContainerApi(self.client_api) repository = repository_api.create( ContainerContainerRepository(**gen_repo())) self.addCleanup(repository_api.delete, repository.pulp_href) remote_api = RemotesContainerApi(self.client_api) remote = remote_api.create(gen_container_remote()) self.addCleanup(remote_api.delete, remote.pulp_href) self.assertEqual(repository.latest_version_href, f"{repository.pulp_href}versions/0/") repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) # Sync the repository. sync_response = repository_api.sync(repository.pulp_href, repository_sync_data) monitor_task(sync_response.task) repository = repository_api.read(repository.pulp_href) self.assertIsNotNone(repository.latest_version_href) # Sync the repository again. latest_version_href = repository.latest_version_href sync_response = repository_api.sync(repository.pulp_href, repository_sync_data) monitor_task(sync_response.task) repository = repository_api.read(repository.pulp_href) self.assertEqual(latest_version_href, repository.latest_version_href)
def test_copy_by_digest_with_incorrect_media_type(self): """Ensure invalid media type will raise a 400.""" ml_i_href = self.tags_api.list( name="ml_i", repository_version=self.latest_from_version ).results[0].tagged_manifest ml_i_digest = self.manifests_api.read(ml_i_href).digest copy_response = self.repositories_api.copy_manifests( self.to_repo.pulp_href, { "source_repository": self.from_repo.pulp_href, "digests": [ml_i_digest], "media_types": [MEDIA_TYPE.MANIFEST_V2] }) monitor_task(copy_response.task) latest_to_repo_href = self.repositories_api.read( self.to_repo.pulp_href).latest_version_href # Assert no version created self.assertEqual(latest_to_repo_href, f"{self.to_repo.pulp_href}versions/0/")
def sync_repository_with_whitelisted_tags(self, whitelist_tags): """Sync a new repository with the whitelisted tags passed as an argument.""" self.repository = self.repositories_api.create( ContainerContainerRepository(**gen_repo())) self.addCleanup(self.repositories_api.delete, self.repository.pulp_href) remote_data = gen_container_remote( upstream_name=DOCKERHUB_PULP_FIXTURE_1, whitelist_tags=whitelist_tags) remote = self.remotes_api.create(remote_data) self.addCleanup(self.remotes_api.delete, remote.pulp_href) repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = self.repositories_api.sync(self.repository.pulp_href, repository_sync_data) monitor_task(sync_response.task) repository = self.repositories_api.read(self.repository.pulp_href) self.assertIsNotNone(repository.latest_version_href)
def test_manifest_recursion(self): """Add a manifest and its related blobs.""" manifest_a = ( self.tags_api.list(name="manifest_a", repository_version=self.latest_from_version) .results[0] .tagged_manifest ) add_response = self.repositories_api.add( self.to_repo.pulp_href, {"content_units": [manifest_a]} ) monitor_task(add_response.task) latest_version_href = self.repositories_api.read(self.to_repo.pulp_href).latest_version_href latest = self.versions_api.read(latest_version_href) # No tags added self.assertFalse("container.manifest-tag" in latest.content_summary.added) # manifest a has 2 blobs self.assertEqual(latest.content_summary.added["container.manifest"]["count"], 1) self.assertEqual(latest.content_summary.added["container.blob"]["count"], 2)
def setUpClass(cls): """Sync pulp/test-fixture-1 so we can copy content from it.""" api_client = gen_container_client() cls.repositories_api = RepositoriesContainerApi(api_client) cls.versions_api = RepositoriesContainerVersionsApi(api_client) cls.remotes_api = RemotesContainerApi(api_client) cls.tags_api = ContentTagsApi(api_client) cls.manifests_api = ContentManifestsApi(api_client) cls.from_repo = cls.repositories_api.create(ContainerContainerRepository(**gen_repo())) remote_data = gen_container_remote(upstream_name=DOCKERHUB_PULP_FIXTURE_1) cls.remote = cls.remotes_api.create(ContainerContainerRemote(**remote_data)) sync_data = RepositorySyncURL(remote=cls.remote.pulp_href) sync_response = cls.repositories_api.sync(cls.from_repo.pulp_href, sync_data) monitor_task(sync_response.task) cls.latest_from_version = cls.repositories_api.read( cls.from_repo.pulp_href ).latest_version_href
def test_01_create_distribution(self): """Create a distribution.""" body = gen_distribution() distribution_data = ContainerContainerDistribution(**body) distribution_response = self.distribution_api.create(distribution_data) created_resources = monitor_task(distribution_response.task) distribution_obj = self.distribution_api.read(created_resources[0]) self.distribution.update(distribution_obj.to_dict()) for key, val in body.items(): with self.subTest(key=key): self.assertEqual(self.distribution[key], val)
def setUpClass(cls): """Create class-wide variables.""" client_api = gen_container_client() cls.distribution_api = DistributionsContainerApi(client_api) body = gen_distribution() body["base_path"] = body["base_path"].replace("-", "/") distribution_data = ContainerContainerDistribution(**body) distribution_response = cls.distribution_api.create(distribution_data) created_resources = monitor_task(distribution_response.task) cls.distribution = cls.distribution_api.read(created_resources[0])
def test_copy_all_tags_from_version(self): """Passing only source version and destination repositories copies all tags.""" latest_from_repo_href = self.repositories_api.read( self.from_repo.pulp_href ).latest_version_href copy_response = self.repositories_api.copy_tags( self.to_repo.pulp_href, {"source_repository_version": latest_from_repo_href}, ) monitor_task(copy_response.task) to_repo = self.repositories_api.read(self.to_repo.pulp_href) to_repo_content = self.versions_api.read( to_repo.latest_version_href ).content_summary.present from_repo_content = self.versions_api.read(latest_from_repo_href).content_summary.present for container_type in ["container.tag", "container.manifest", "container.blob"]: self.assertEqual( to_repo_content[container_type]["count"], from_repo_content[container_type]["count"], msg=container_type, )