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