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,
)
