def setUpClass(cls):
"""Create class wide-variables."""
cls.cfg = config.get_config()
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).created_resources
cls.distribution = cls.distributions_api.read(created_resources[0])
def setUpClass(cls):
"""
Define APIs to use and pull images needed later in tests
"""
cfg = config.get_config()
cls.registry = cli.RegistryClient(cfg)
cls.registry.raise_if_unsupported(unittest.SkipTest,
"Tests require podman/docker")
cls.registry_name = urlparse(cfg.get_base_url()).netloc
admin_user, admin_password = cfg.pulp_auth
cls.user_admin = {"username": admin_user, "password": admin_password}
cls.user_creator = gen_user([
"container.add_containernamespace",
"container.add_containerdistribution"
])
cls.user_dist_collaborator = gen_user([])
cls.user_dist_consumer = gen_user([])
cls.user_namespace_collaborator = gen_user([])
cls.user_reader = gen_user([])
cls.user_helpless = gen_user([])
# View push repositories, distributions, and namespaces using user_creator.
api_client = gen_container_client()
api_client.configuration.username = cls.user_admin["username"]
api_client.configuration.password = cls.user_admin["password"]
cls.pushrepository_api = RepositoriesContainerPushApi(api_client)
cls.namespace_api = PulpContainerNamespacesApi(api_client)
cls._pull(f"{DOCKERHUB_PULP_FIXTURE_1}:manifest_a")
cls._pull(f"{DOCKERHUB_PULP_FIXTURE_1}:manifest_b")
cls._pull(f"{DOCKERHUB_PULP_FIXTURE_1}:manifest_c")
cls._pull(f"{DOCKERHUB_PULP_FIXTURE_1}:manifest_d")
def setUpClass(cls):
"""
Define APIs to use and pull images needed later in tests
"""
api_client = gen_container_client()
cls.pushrepository_api = RepositoriesContainerPushApi(api_client)
cls.namespace_api = PulpContainerNamespacesApi(api_client)
cls.repo_version_api = RepositoriesContainerVersionsApi(api_client)
cfg = config.get_config()
cls.registry = cli.RegistryClient(cfg)
cls.registry.raise_if_unsupported(unittest.SkipTest, "Tests require podman/docker")
cls.registry_name = urlparse(cfg.get_base_url()).netloc
admin_user, admin_password = cfg.pulp_auth
cls.user_admin = {"username": admin_user, "password": admin_password}
cls.user_creator = gen_user(
[
"container.add_containerdistribution",
"container.add_containernamespace",
]
)
cls.user_reader = gen_user(["container.view_containerpushrepository"])
cls.user_helpless = gen_user([])
# create a push repo
image_path = f"{DOCKERHUB_PULP_FIXTURE_1}:manifest_d"
cls._pull(image_path)
repo_name = "testrv/perms"
local_url = "/".join([cls.registry_name, f"{repo_name}:1.0"])
cls._push(image_path, local_url, cls.user_creator)
cls.repository = cls.pushrepository_api.list(name=repo_name).results[0]
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)
with self.assertRaises(PulpTaskError) as context:
monitor_task(sync_response.task)
self.assertIsNotNone(context.exception.task.error["description"])
def setUpClass(cls):
"""Sync a remote repository and create a new distribution pointing to the repository."""
client_api = gen_container_client()
cls.blobs_api = ContentBlobsApi(client_api)
cls.manifests_api = ContentManifestsApi(client_api)
cls.tags_api = ContentTagsApi(client_api)
cls.repo_api = RepositoriesContainerApi(client_api)
cls.remote_api = RemotesContainerApi(client_api)
cls.dist_api = DistributionsContainerApi(client_api)
cls.repo = cls.repo_api.create(gen_repo())
cls.remote = cls.remote_api.create(gen_container_remote())
body = ContainerRepositorySyncURL(remote=cls.remote.pulp_href)
response = cls.repo_api.sync(cls.repo.pulp_href, body)
monitor_task(response.task)
cls.repo = cls.repo_api.read(cls.repo.pulp_href)
response = cls.dist_api.create(
gen_distribution(repository=cls.repo.pulp_href))
cls.distro = cls.dist_api.read(
monitor_task(response.task).created_resources[0])
relative_path = os.path.join("v2/", f"{cls.distro.base_path}/")
cls.dist_url = urljoin(PULP_CONTENT_HOST_BASE_URL, relative_path)
def setUpClass(cls):
"""Define APIs to use and pull images needed later in tests."""
api_client = gen_container_client()
cls.tags_api = ContentTagsApi(api_client)
cls.manifests_api = ContentManifestsApi(api_client)
cls.repositories_api = RepositoriesContainerPushApi(api_client)
cfg = config.get_config()
cls.registry = cli.RegistryClient(cfg)
cls.registry.raise_if_unsupported(unittest.SkipTest,
"Tests require podman/docker")
cls.registry_name = urlparse(cfg.get_base_url()).netloc
cls.repository_name = "namespace/tags"
cls.registry_repository_name = f"{cls.registry_name}/{cls.repository_name}"
manifest_a = f"{DOCKERHUB_PULP_FIXTURE_1}:manifest_a"
tagged_registry_manifest_a = f"{cls.registry_repository_name}:manifest_a"
manifest_b = f"{DOCKERHUB_PULP_FIXTURE_1}:manifest_b"
tagged_registry_manifest_b = f"{cls.registry_repository_name}:manifest_b"
cls.registry.pull(manifest_a)
cls.registry.pull(manifest_b)
cls.registry.tag(manifest_a, tagged_registry_manifest_a)
cls.registry.tag(manifest_b, tagged_registry_manifest_b)
cls.registry.login("-u", "admin", "-p", "password", cls.registry_name)
cls.registry.push(tagged_registry_manifest_a)
cls.registry.push(tagged_registry_manifest_b)
cls.repository = cls.repositories_api.list(
name=cls.repository_name).results[0]
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 setUpClass(cls):
"""
Define APIs to use.
"""
api_client = gen_container_client()
cls.pushrepository_api = RepositoriesContainerPushApi(api_client)
cls.namespace_api = PulpContainerNamespacesApi(api_client)
cfg = config.get_config()
cls.registry = cli.RegistryClient(cfg)
cls.registry.raise_if_unsupported(unittest.SkipTest, "Tests require podman/docker")
cls.registry_name = urlparse(cfg.get_base_url()).netloc
cls.user_creator = gen_user(
model_roles=[
"container.containerdistribution_creator",
"container.containernamespace_creator",
]
)
cls.user_reader = gen_user(model_roles=["container.containerdistribution_consumer"])
cls.user_helpless = gen_user()
# create a push repo
image_path = f"{REGISTRY_V2_REPO_PULP}:manifest_d"
cls._pull(image_path)
repo_name = "test_push_repo/perms"
local_url = "/".join([cls.registry_name, f"{repo_name}:1.0"])
cls._push(image_path, local_url, cls.user_creator)
cls.repository = cls.pushrepository_api.list(name=repo_name).results[0]
def setUpClass(cls):
"""Create class-wide variable."""
delete_orphans()
cls.content_unit = {}
# FIXME: Instantiate APIs for all content types.
cls.container_content_api = ContentManifestsApi(gen_container_client())
cls.artifact = gen_artifact()
def setUpClass(cls):
"""Create class-wide variables."""
client_api = gen_container_client()
cls.repositories_api = RepositoriesContainerApi(client_api)
cls.remotes_api = RemotesContainerApi(client_api)
cls.tags_api = ContentTagsApi(client_api)
cls.versions_api = RepositoriesContainerVersionsApi(client_api)
cls.repository = None
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_container_remote()
del body["url"]
with self.assertRaises(ApiException):
RemotesContainerApi(gen_container_client()).create(body)
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 setUpClass(cls):
"""Create class-wide variables.
1. Create a repository.
2. Create a remote pointing to external registry.
3. Sync the repository using the remote and re-read the repo data.
4. Create a container distribution to serve the repository
This tests targets the following issue:
* `Pulp #4460 <https://pulp.plan.io/issues/4460>`_
"""
cls.cfg = config.get_config()
cls.registry_name = urlparse(cls.cfg.get_base_url()).netloc
cls.client = api.Client(cls.cfg, api.code_handler)
client_api = gen_container_client()
cls.repositories_api = RepositoriesContainerApi(client_api)
cls.remotes_api = RemotesContainerApi(client_api)
cls.distributions_api = DistributionsContainerApi(client_api)
with contextlib.ExitStack() as stack:
# ensure tearDownClass runs if an error occurs here
stack.callback(cls.tearDownClass)
# Step 1
_repo = cls.repositories_api.create(
ContainerContainerRepository(**gen_repo()))
# Step 2
cls.remote = cls.remotes_api.create(gen_container_remote())
# Step 3
sync_data = RepositorySyncURL(remote=cls.remote.pulp_href)
sync_response = cls.repositories_api.sync(_repo.pulp_href,
sync_data)
monitor_task(sync_response.task)
cls.repo = cls.repositories_api.read(_repo.pulp_href)
# Step 4.
distribution_response = cls.distributions_api.create(
ContainerContainerDistribution(
**gen_distribution(repository=cls.repo.pulp_href,
base_path="pulp_pre_upgrade_test")))
created_resources = monitor_task(
distribution_response.task).created_resources
distribution = cls.distributions_api.read(created_resources[0])
cls.distribution_with_repo = cls.distributions_api.read(
distribution.pulp_href)
# remove callback if everything goes well
stack.pop_all()
def setUpClass(cls):
"""Create class-wide variables."""
cls.client_api = gen_container_client()
cls.repository_api = RepositoriesContainerApi(cls.client_api)
cls.from_repo = cls.repository_api.create(
ContainerContainerRepository(**gen_repo()))
cls.remote_api = RemotesContainerApi(cls.client_api)
remote_data = gen_container_remote(upstream_name=PULP_FIXTURE_1)
cls.remote = cls.remote_api.create(remote_data)
delete_orphans()
def setUpClass(cls):
"""Create class wide-variables."""
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.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)
def setUpClass(cls):
"""
Define APIs to use and pull images needed later in tests
"""
api_client = gen_container_client()
cfg = config.get_config()
cls.repositories_api = RepositoriesContainerApi(api_client)
cls.repo_version_api = RepositoriesContainerVersionsApi(api_client)
cls.tags_api = ContentTagsApi(api_client)
cls.manifests_api = ContentManifestsApi(api_client)
admin_user, admin_password = cfg.pulp_auth
cls.user_admin = {"username": admin_user, "password": admin_password}
cls.user_creator = gen_user(
[
"container.add_containerrepository",
"container.add_containerremote",
]
)
cls.user_repov_remover = gen_user(
[
"container.delete_containerrepository_versions",
"container.view_containerrepository",
]
)
cls.user_repo_remover = gen_user(
[
"container.delete_containerrepository",
"container.view_containerrepository",
]
)
cls.user_reader = gen_user(["container.view_containerrepository"])
cls.user_helpless = gen_user([])
# sync a repo
cls.repository = cls.user_creator["repository_api"].create(
ContainerContainerRepository(**gen_repo())
)
cls.remote = cls.user_creator["remote_api"].create(
gen_container_remote(upstream_name=DOCKERHUB_PULP_FIXTURE_1)
)
sync_data = RepositorySyncURL(remote=cls.remote.pulp_href)
sync_response = cls.user_creator["repository_api"].sync(cls.repository.pulp_href, sync_data)
monitor_task(sync_response.task)
def setUpClass(cls):
"""
Define APIs to use and pull images needed later in tests
"""
api_client = gen_container_client()
cfg = config.get_config()
cls.repositories_api = RepositoriesContainerApi(api_client)
cls.repo_version_api = RepositoriesContainerVersionsApi(api_client)
cls.tags_api = ContentTagsApi(api_client)
cls.manifests_api = ContentManifestsApi(api_client)
admin_user, admin_password = cfg.pulp_auth
cls.user_admin = {"username": admin_user, "password": admin_password}
cls.user_creator = gen_user(
model_roles=[
"container.containerrepository_creator",
"container.containerremote_creator",
]
)
cls.user_repov_remover = gen_user(
model_roles=[
"container.containerrepository_content_manager",
]
)
# TODO: Not sure what is the right role for this user...
cls.user_repo_remover = gen_user(
model_roles=[
"container.containerrepository_owner",
]
)
cls.user_reader = gen_user(model_roles=["container.containerrepository_viewer"])
cls.user_helpless = gen_user()
# sync a repo
cls.repository = cls.user_creator["repository_api"].create(
ContainerContainerRepository(**gen_repo())
)
cls.remote = cls.user_creator["remote_api"].create(
gen_container_remote(upstream_name=PULP_FIXTURE_1)
)
sync_data = ContainerRepositorySyncURL(remote=cls.remote.pulp_href)
sync_response = cls.user_creator["repository_api"].sync(cls.repository.pulp_href, sync_data)
monitor_task(sync_response.task)
def setUpClass(cls):
"""Define class-wide variables and initialize a repository needed later in the tests."""
cfg = config.get_config()
cls.registry = cli.RegistryClient(cfg)
cls.registry.raise_if_unsupported(unittest.SkipTest,
"Tests require podman/docker")
cls.registry_name = urlparse(cfg.get_base_url()).netloc
admin_user, admin_password = cfg.pulp_auth
cls.user_admin = {"username": admin_user, "password": admin_password}
api_client = gen_container_client()
api_client.configuration.username = cls.user_admin["username"]
api_client.configuration.password = cls.user_admin["password"]
cls.repositories_api = RepositoriesContainerPushApi(api_client)
cls.versions_api = RepositoriesContainerVersionsApi(api_client)
cls.namespaces_api = PulpContainerNamespacesApi(api_client)
cls.manifests_api = ContentManifestsApi(api_client)
cls.distributions_api = DistributionsContainerApi(api_client)
# the image tagged as 'manifest_a' consists of 3 blobs, 1 manifest, and 1 tag
manifest_a_path = f"{REGISTRY_V2_REPO_PULP}:manifest_a"
cls._pull(manifest_a_path)
local_url = "/".join([cls.registry_name, "foo/bar:tag"])
cls._push(manifest_a_path, local_url, cls.user_admin)
cls.repo = cls.repositories_api.list(name="foo/bar").results[0]
cls.distribution = cls.distributions_api.list(
name="foo/bar").results[0]
cls.namespace = cls.namespaces_api.list(name="foo").results[0]
# create a new tag to test if all tags pointing to the same manifest will be removed
cls.manifest_a = cls.manifests_api.list().results[0]
tag_data = TagImage(tag="new_tag", digest=cls.manifest_a.digest)
tag_response = cls.repositories_api.tag(cls.repo.pulp_href, tag_data)
monitor_task(tag_response.task)
latest_version_href = cls.repositories_api.read(
cls.repo.pulp_href).latest_version_href
cls.content_to_remove = cls.versions_api.read(
latest_version_href).content_summary.present
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.remotes_api = RemotesContainerApi(api_client)
cls.tags_api = ContentTagsApi(api_client)
cls.versions_api = RepositoriesContainerVersionsApi(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 setUpClass(cls):
"""Create class wide-variables."""
api_client = gen_container_client()
cls.repositories_api = RepositoriesContainerApi(api_client)
cls.remotes_api = RemotesContainerApi(api_client)
cls.distributions_api = DistributionsContainerApi(api_client)
cls.namespaces_api = PulpContainerNamespacesApi(api_client)
cls.cfg = config.get_config()
cls.client = api.Client(cls.cfg, api.json_handler)
cls.repository = cls.repositories_api.create(
ContainerContainerRepository(**gen_repo()))
remote_data = gen_container_remote(upstream_name=PULP_FIXTURE_1)
cls.remote = cls.remotes_api.create(
ContainerContainerRemote(**remote_data))
sync_data = ContainerRepositorySyncURL(remote=cls.remote.pulp_href)
sync_response = cls.repositories_api.sync(cls.repository.pulp_href,
sync_data)
monitor_task(sync_response.task)
def setUpClass(cls):
"""Initialize class-wide variables and create a new repository by pushing content to it."""
cls.cfg = config.get_config()
cls.client = api.Client(cls.cfg, api.code_handler)
cls.registry = cli.RegistryClient(cls.cfg)
cls.registry.raise_if_unsupported(unittest.SkipTest, "Tests require podman/docker")
cls.registry_name = urlparse(cls.cfg.get_base_url()).netloc
admin_user, admin_password = cls.cfg.pulp_auth
cls.user_admin = {"username": admin_user, "password": admin_password}
api_client = gen_container_client()
api_client.configuration.username = cls.user_admin["username"]
api_client.configuration.password = cls.user_admin["password"]
cls.distributions_api = DistributionsContainerApi(api_client)
cls.pushrepository_api = RepositoriesContainerPushApi(api_client)
cls.repo_version_api = RepositoriesContainerVersionsApi(api_client)
cls.blobs_api = ContentBlobsApi(api_client)
cls._pull(f"{REGISTRY_V2_REPO_PULP}:manifest_a")
local_url = f"{cls.registry_name}/test-1:manifest_a"
image_path = f"{REGISTRY_V2_REPO_PULP}:manifest_a"
cls._push(image_path, local_url, cls.user_admin)
repository = cls.pushrepository_api.list(name="test-1").results[0]
cls.blobs = cls.blobs_api.list(repository_version=repository.latest_version_href).results
cls.distribution = cls.distributions_api.list(name="test-1").results[0]
cls.user_pull = gen_user(
object_roles=[("container.containernamespace_consumer", cls.distribution.namespace)]
)
cls.user_push = gen_user(
object_roles=[("container.containernamespace_collaborator", cls.distribution.namespace)]
)
cls.user_anon = gen_user()
def setUpClass(cls):
"""Create class-wide variables and delete orphans.
1. Create a repository.
2. Create a remote pointing to external registry with policy=on_demand.
3. Sync the repository using the remote and re-read the repo data.
4. Create a container distribution to serve the repository
5. Create another container distribution to the serve the repository version
This tests targets the following issue:
* `Pulp #4460 <https://pulp.plan.io/issues/4460>`_
"""
cls.cfg = config.get_config()
cls.registry_name = urlparse(cls.cfg.get_base_url()).netloc
client_api = gen_container_client()
cls.repositories_api = RepositoriesContainerApi(client_api)
cls.remotes_api = RemotesContainerApi(client_api)
cls.distributions_api = DistributionsContainerApi(client_api)
cls.teardown_cleanups = []
delete_orphans()
with contextlib.ExitStack() as stack:
# ensure tearDownClass runs if an error occurs here
stack.callback(cls.tearDownClass)
# Step 1
_repo = cls.repositories_api.create(
ContainerContainerRepository(**gen_repo()))
cls.teardown_cleanups.append(
(cls.repositories_api.delete, _repo.pulp_href))
# Step 2
cls.remote = cls.remotes_api.create(
gen_container_remote(policy="on_demand"))
cls.teardown_cleanups.append(
(cls.remotes_api.delete, cls.remote.pulp_href))
# Step 3
sync_data = RepositorySyncURL(remote=cls.remote.pulp_href)
sync_response = cls.repositories_api.sync(_repo.pulp_href,
sync_data)
monitor_task(sync_response.task)
cls.repo = cls.repositories_api.read(_repo.pulp_href)
cls.artifacts_api = ArtifactsApi(core_client)
cls.artifact_count = cls.artifacts_api.list().count
# Step 4.
distribution_response = cls.distributions_api.create(
ContainerContainerDistribution(**gen_distribution(
repository=cls.repo.pulp_href)))
created_resources = monitor_task(
distribution_response.task).created_resources
distribution = cls.distributions_api.read(created_resources[0])
cls.distribution_with_repo = cls.distributions_api.read(
distribution.pulp_href)
cls.teardown_cleanups.append(
(cls.distributions_api.delete,
cls.distribution_with_repo.pulp_href))
# Step 5.
distribution_response = cls.distributions_api.create(
ContainerContainerDistribution(**gen_distribution(
repository_version=cls.repo.latest_version_href)))
created_resources = monitor_task(
distribution_response.task).created_resources
distribution = cls.distributions_api.read(created_resources[0])
cls.distribution_with_repo_version = cls.distributions_api.read(
distribution.pulp_href)
cls.teardown_cleanups.append(
(cls.distributions_api.delete,
cls.distribution_with_repo_version.pulp_href))
# remove callback if everything goes well
stack.pop_all()
def setUpClass(cls):
"""Create class wide-variables."""
client_api = gen_container_client()
cls.distribution_api = DistributionsContainerApi(client_api)
cls.distribution = {}
def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
cls.client_api = gen_container_client()
def setUpClass(cls):
"""Initialize a new manifest list that will be pushed to the registry."""
cfg = config.get_config()
cls.registry = cli.RegistryClient(cfg)
cls.registry.raise_if_unsupported(unittest.SkipTest,
"Tests require podman/docker")
cls.registry_name = urlparse(cfg.get_base_url()).netloc
admin_user, admin_password = cfg.pulp_auth
cls.user_admin = {"username": admin_user, "password": admin_password}
api_client = gen_container_client()
api_client.configuration.username = cls.user_admin["username"]
api_client.configuration.password = cls.user_admin["password"]
cls.pushrepository_api = RepositoriesContainerPushApi(api_client)
cls.distributions_api = DistributionsContainerApi(api_client)
cls.manifests_api = ContentManifestsApi(api_client)
cls.tags_api = ContentTagsApi(api_client)
cls.manifest_a = f"{REGISTRY_V2_REPO_PULP}:manifest_a"
cls.manifest_b = f"{REGISTRY_V2_REPO_PULP}:manifest_b"
cls.manifest_c = f"{REGISTRY_V2_REPO_PULP}:manifest_c"
cls._pull(cls.manifest_a)
cls._pull(cls.manifest_b)
cls._pull(cls.manifest_c)
# get default manifests' digests for the further comparison
manifest_a_digest = cls.registry.inspect(cls.manifest_a)[0]["Digest"]
manifest_b_digest = cls.registry.inspect(cls.manifest_b)[0]["Digest"]
manifest_c_digest = cls.registry.inspect(cls.manifest_c)[0]["Digest"]
cls.manifests_v2s2_digests = sorted(
[manifest_a_digest, manifest_b_digest, manifest_c_digest])
# create a new manifest list composed of the pulled manifest images
cls.image_v2s2_tag = "manifest_list"
cls.image_v2s2_path = f"{REGISTRY_V2_REPO_PULP}:{cls.image_v2s2_tag}"
cls.local_v2s2_url = f"{cls.registry_name}/foo:{cls.image_v2s2_tag}"
cls.registry._dispatch_command("manifest", "create",
cls.image_v2s2_path)
cls.registry._dispatch_command("manifest", "add", cls.image_v2s2_path,
cls.manifest_a)
cls.registry._dispatch_command("manifest", "add", cls.image_v2s2_path,
cls.manifest_b)
cls.registry._dispatch_command("manifest", "add", cls.image_v2s2_path,
cls.manifest_c)
# get digests of manifests after converting images to the OCI format by reloading them
cls.registry._dispatch_command("save", cls.manifest_a, "--format",
"oci-dir", "-o", "manifest_a.tar")
cls.registry._dispatch_command("save", cls.manifest_b, "--format",
"oci-dir", "-o", "manifest_b.tar")
cls.registry._dispatch_command("save", cls.manifest_c, "--format",
"oci-dir", "-o", "manifest_c.tar")
cls.registry._dispatch_command("load", "-q", "-i", "manifest_a.tar")
cls.registry._dispatch_command("load", "-q", "-i", "manifest_b.tar")
cls.registry._dispatch_command("load", "-q", "-i", "manifest_c.tar")
manifest_a_digest = cls.registry.inspect("manifest_a.tar")[0]["Digest"]
manifest_b_digest = cls.registry.inspect("manifest_b.tar")[0]["Digest"]
manifest_c_digest = cls.registry.inspect("manifest_c.tar")[0]["Digest"]
cls.manifests_oci_digests = sorted(
[manifest_a_digest, manifest_b_digest, manifest_c_digest])
# create an empty manifest list
cls.empty_image_tag = "empty_manifest_list"
cls.empty_image_path = f"{REGISTRY_V2_REPO_PULP}:{cls.empty_image_tag}"
cls.empty_image_local_url = f"{cls.registry_name}/foo:{cls.empty_image_tag}"
cls.registry._dispatch_command("manifest", "create",
cls.empty_image_path)
def setUpClass(cls):
"""
Define APIs to use and pull images needed later in tests
"""
api_client = gen_container_client()
cfg = config.get_config()
cls.repository_api = RepositoriesContainerApi(api_client)
cls.pushrepository_api = RepositoriesContainerPushApi(api_client)
cls.tags_api = ContentTagsApi(api_client)
cls.namespace_api = PulpContainerNamespacesApi(api_client)
cls.registry = cli.RegistryClient(cfg)
cls.registry.raise_if_unsupported(unittest.SkipTest, "Tests require podman/docker")
cls.registry_name = urlparse(cfg.get_base_url()).netloc
admin_user, admin_password = cfg.pulp_auth
cls.user_admin = {"username": admin_user, "password": admin_password}
cls.user_creator = gen_user(
[
"container.add_containerrepository",
"container.add_containerremote",
"container.add_containernamespace",
"container.add_containerdistribution",
]
)
cls.user_creator2 = gen_user(
[
"container.add_containernamespace",
"container.add_containerdistribution",
]
)
cls.user_reader = gen_user(
[
"container.view_containerrepository",
"container.view_containerpushrepository",
]
)
cls.user_reader2 = gen_user(["container.view_containerrepository"])
cls.user_reader3 = gen_user(["container.view_containerpushrepository"])
cls.user_helpless = gen_user([])
# create a push repo with user_creator
image_path = f"{DOCKERHUB_PULP_FIXTURE_1}:manifest_a"
cls._pull(image_path)
repo_name = "testcontent/perms"
local_url = "/".join([cls.registry_name, f"{repo_name}:1.0"])
cls._push(image_path, local_url, cls.user_creator)
cls.push_repository = cls.pushrepository_api.list(name=repo_name).results[0]
# create a second push repo with user_creator2
image_path = f"{DOCKERHUB_PULP_FIXTURE_1}:manifest_b"
cls._pull(image_path)
repo_name = "testcontent2/perms"
local_url = "/".join([cls.registry_name, f"{repo_name}:1.0"])
cls._push(image_path, local_url, cls.user_creator2)
cls.push_repository2 = cls.pushrepository_api.list(name=repo_name).results[0]
# sync a repo with user_creator
cls.repository = cls.user_creator["repository_api"].create(
ContainerContainerRepository(**gen_repo())
)
cls.remote = cls.user_creator["remote_api"].create(
gen_container_remote(upstream_name=DOCKERHUB_PULP_FIXTURE_1)
)
sync_data = RepositorySyncURL(remote=cls.remote.pulp_href)
sync_response = cls.user_creator["repository_api"].sync(cls.repository.pulp_href, sync_data)
monitor_task(sync_response.task)
def setUpClass(cls):
"""Create class-wide variables."""
cls.remote_api = RemotesContainerApi(gen_container_client())
cls.remote = {}
cls.policies = ON_DEMAND_DOWNLOAD_POLICIES
cls.body = _gen_verbose_remote()
def setUpClass(cls):
"""Create class-wide variables."""
cls.remote_api = RemotesContainerApi(gen_container_client())
cls.remote = None
# coding=utf-8
"""Tests that verify that images can be pushed to Pulp."""
import unittest
from pulp_smash import cli, config, exceptions
from pulp_container.tests.functional.utils import gen_container_client
from pulpcore.client.pulp_container import RepositoriesContainerPushApi
cfg = config.get_config()
api_client = gen_container_client()
push_repositories_api = RepositoriesContainerPushApi(api_client)
registry = cli.RegistryClient(cfg)
class PushContentTestCase(unittest.TestCase):
"""Verify whether images can be pushed to pulp."""
def test_push_using_registry_client(self):
"""Test push with official registry client"""
registry.raise_if_unsupported(unittest.SkipTest,
"Test requires podman/docker")
# TODO better handling of the "http://"
registry_name = cfg.get_base_url()[7:]
local_url = "/".join([registry_name, "foo/bar:1.0"])
# Be sure to not being logged in
registry.logout(registry_name)
# Pull an image with large blobs
registry.pull("centos:7")
