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 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):
"""
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 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):
"""Create class wide-variables."""
super().setUpClass()
distribution_data = gen_distribution(
repository=cls.repository.pulp_href, private=True)
distribution_response = cls.distributions_api.create(
ContainerContainerDistribution(**distribution_data))
created_resources = monitor_task(
distribution_response.task).created_resources
cls.distribution1 = cls.distributions_api.read(created_resources[0])
cls.namespace1 = cls.namespaces_api.read(cls.distribution1.namespace)
distribution_data = gen_distribution(
repository=cls.repository.pulp_href, private=True)
distribution_response = cls.distributions_api.create(
ContainerContainerDistribution(**distribution_data))
created_resources = monitor_task(
distribution_response.task).created_resources
cls.distribution2 = cls.distributions_api.read(created_resources[0])
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.distribution3 = cls.distributions_api.read(created_resources[0])
cls.user_none = gen_user()
cls.user_all = gen_user(model_roles=[
"container.containerdistribution_consumer",
"container.containernamespace_consumer",
])
cls.user_only_dist1 = gen_user(object_roles=[
("container.containerdistribution_consumer",
cls.distribution1.pulp_href),
("container.containernamespace_consumer",
cls.namespace1.pulp_href),
])
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):
"""
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 and prepare api users."""
cls.user1 = gen_user(["container.add_containerrepository"])
cls.user2 = gen_user(["container.view_containerrepository"])
cls.user3 = gen_user([])
cls.repository = None