def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
client = gen_file_client()
cls.repo_api = RepositoriesFileApi(client)
cls.remote_api = RemotesFileApi(client)
cls.publications = PublicationsFileApi(client)
def set_distribution_base_path_and_download_a_content_unit_with_cert(
file_distribution_href,
base_path,
file_repository_href,
cert_path,
content_path=None,
url_encode=True):
"""
Set the base path on the `distribution, read the cert, urlencode it, and then request one unit.
If `content_path` is set, that path will be requested, otherwise a random, valid content unit
path will be selected from the FileRepository at `file_repository_href`.
1. Set the distribution referred to by `file_distribution_href` base_path to `base_path`.
2. Read the cert from the filesystem and urlencode it.
3. Make a request to `content_path` if specified, or to a random content item present in the
`file_repository_href` repository. The urlencoded cert is submitted as the `X-CLIENT-CERT`
header when requesting content.
Args:
file_distribution_href: The distribution href that is to be updated. This must refer to a
distribution of type `FileDistribution`.
base_path: The base path to set on the `distribution`.
file_repository_href: The repository href that will have
cert_path: The file system path to the certificate to be used in the content request. This
will be read from the filesystem and urlencoded before being submitted as the
`X-CLIENT-CERT` header when downloading content.
content_path: The path to the specific content unit to be fetched. This is the portion of
the url after the distribution URL. It's optional, and if unspecified a random, valid
content unit will be selected instead from the repository.
url_encode: If true, the certificate data read will be urlencoded, otherwise it won't be.
This is an optional param, and defaults to True.
Returns:
The downloaded data.
"""
distribution = set_distribution_base_path(file_distribution_href, base_path)
if content_path is None:
file_client = gen_file_client()
file_repos_api = RepositoriesFileApi(file_client)
repo = file_repos_api.read(file_repository_href)
content_path = choice(get_file_content_paths(repo.to_dict()))
if url_encode:
cert_data = read_cert_and_urlencode(cert_path)
else:
cert_data = read_cert(cert_path)
return download_content_unit(
config.get_config(),
distribution.to_dict(),
content_path,
headers={'X-CLIENT-CERT': cert_data}
)
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_file_remote()
del body["url"]
with self.assertRaises(ApiException):
RemotesFileApi(gen_file_client()).create(body)
def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
cls.client = gen_file_client()
cls.content_api = ContentFilesApi(cls.client)
cls.repo_api = RepositoriesFileApi(cls.client)
cls.remote_api = RemotesFileApi(cls.client)
cls.publications_api = PublicationsFileApi(cls.client)
cls.distributions_api = DistributionsFileApi(cls.client)
cls.CUSTOM_MANIFEST = "TEST_MANIFEST"
def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
cls.client = api.Client(cls.cfg, api.json_handler)
cls.core_client = CoreApiClient(configuration=cls.cfg.get_bindings_config())
cls.file_client = gen_file_client()
cls.repo_api = RepositoriesFileApi(cls.file_client)
cls.remote_api = RemotesFileApi(cls.file_client)
cls.exporter_api = ExportersPulpApi(cls.core_client)
cls.exports_api = ExportersCoreExportsApi(cls.core_client)
(cls.repos, cls.remotes) = cls._setup_repositories()
def setUpClass(cls):
"""
Initialize Pulp to make authorization assertions using client certificates.
0. Create a FileRepository
1. Create a FileRemote
2. Sync in a few units we can use to fetch with
3. Create a Publication
4. Create a CertGuard with the CA cert used to sign all client certificates
5. Create a Distribution for the publication that is protected by the CertGuard
"""
cls.teardown_cleanups = []
cls.cfg = config.get_config()
file_client = gen_file_client()
repo_api = RepositoriesFileApi(file_client)
remote_api = RemotesFileApi(file_client)
publications = PublicationsFileApi(file_client)
cls.distributions_api = DistributionsFileApi(file_client)
cls.repo = repo_api.create(gen_repo())
cls.teardown_cleanups.append((repo_api.delete, cls.repo.pulp_href))
body = gen_file_remote(policy="immediate")
remote = remote_api.create(body)
cls.teardown_cleanups.append((remote_api.delete, remote.pulp_href))
# Sync a Repository
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(cls.repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
cls.repo = repo_api.read(cls.repo.pulp_href)
# Create a publication.
publish_data = FileFilePublication(repository=cls.repo.pulp_href)
publish_response = publications.create(publish_data)
created_resources = monitor_task(publish_response.task)
publication_href = created_resources[0]
cls.teardown_cleanups.append((publications.delete, publication_href))
content_guard_href = cls._setup_content_guard()
# Create a distribution.
body = gen_distribution()
body["publication"] = publication_href
body["content_guard"] = content_guard_href
distribution_response = cls.distributions_api.create(body)
created_resources = monitor_task(distribution_response.task)
cls.distribution = cls.distributions_api.read(created_resources[0])
cls.teardown_cleanups.append((cls.distributions_api.delete, cls.distribution.pulp_href))
def test_negative_create_file_remote_with_invalid_parameter(self):
"""Attempt to create file remote passing invalid parameter.
Assert response returns an error 400 including ["Unexpected field"].
This test targets the following issue:
* `Pulp Smash #1085 <https://github.com/pulp/pulp-smash/issues/1085>`_
"""
with self.assertRaises(ApiException) as exc:
RemotesFileApi(gen_file_client()).create(
gen_file_remote(foo="bar"))
assert exc.exception.status == 400
assert json.loads(exc.exception.body)["foo"] == ["Unexpected field"]
def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
cls.client = api.Client(cls.cfg, api.json_handler)
cls.file_client = gen_file_client()
cls.content_api = ContentFilesApi(cls.file_client)
cls.repo_api = RepositoriesFileApi(cls.file_client)
cls.versions_api = RepositoriesFileVersionsApi(cls.file_client)
cls.remote_api = RemotesFileApi(cls.file_client)
cls.publication_api = PublicationsFileApi(cls.file_client)
cls.exporter_api = ExportersFilesystemApi(cls.file_client)
cls.exports_api = ExportersFileExportsApi(cls.file_client)
cls.repos, cls.remotes, cls.publications = cls._setup_repositories()
def set_distribution_base_path(file_distribution_href, base_path):
"""
Set the base path of a FileDistribution and return the updated representation.
Args:
file_distribution_href: The distribution href that is to be updated. This must refer to a
distribution of type `FileDistribution`.
base_path: The base path to set on the `distribution`.
Returns:
The bindings object representing the updated FileDistribution.
"""
file_client = gen_file_client()
distributions_api = DistributionsFileApi(file_client)
update_response = distributions_api.partial_update(
file_distribution_href, {"base_path": base_path})
monitor_task(update_response.task)
return distributions_api.read(file_distribution_href)
def test_all(self):
"""Perform a lazy sync and change to immeditae to force download."""
# delete orphans to assure that no content units are present on the
# file system
delete_orphans()
client = gen_file_client()
artifacts_api = ArtifactsApi(core_client)
repo_api = RepositoriesFileApi(client)
remote_api = RemotesFileApi(client)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
body = gen_file_remote(policy=choice(ON_DEMAND_DOWNLOAD_POLICIES))
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
# Sync the repository using a lazy download policy
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
artifacts = artifacts_api.list().to_dict()["results"]
self.assertEqual(len(artifacts), 0, artifacts)
# Update the policy to immediate
response = remote_api.partial_update(remote.pulp_href,
{"policy": "immediate"})
monitor_task(response.task)
remote = remote_api.read(remote.pulp_href)
self.assertEqual(remote.policy, "immediate")
# Sync using immediate download policy
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
# Assert that missing artifacts are downloaded
artifacts = artifacts_api.list().to_dict()["results"]
self.assertEqual(len(artifacts), FILE_FIXTURE_COUNT, artifacts)
def setUpClass(cls):
"""Create class-wide variables."""
cls.client = gen_file_client()
cls.DP_ON_DEMAND = "on_demand" in ON_DEMAND_DOWNLOAD_POLICIES
cls.DP_STREAMED = "streamed" in ON_DEMAND_DOWNLOAD_POLICIES
def file_client():
return gen_file_client()
def setUpClass(cls):
"""Create class-wide variable."""
delete_orphans()
cls.content_unit = {}
cls.file_content_api = ContentFilesApi(gen_file_client())
cls.artifact = gen_artifact()
def setUpClass(cls):
"""Create class-wide variables."""
cls.client = gen_file_client()
def setUpClass(cls):
"""Create class-wide variables."""
cls.file_content_api = ContentFilesApi(gen_file_client())
def test_all(self):
"""Test whether a particular repository version can be published.
1. Create a repository with at least 2 repository versions.
2. Create a publication by supplying the latest ``repository_version``.
3. Assert that the publication ``repository_version`` attribute points
to the latest repository version.
4. Create a publication by supplying the non-latest ``repository_version``.
5. Assert that the publication ``repository_version`` attribute points
to the supplied repository version.
6. Assert that an exception is raised when providing two different
repository versions to be published at same time.
"""
cfg = config.get_config()
client = gen_file_client()
repo_api = RepositoriesFileApi(client)
remote_api = RemotesFileApi(client)
publications = PublicationsFileApi(client)
body = gen_file_remote()
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
# Step 1
repo = repo_api.read(repo.pulp_href)
for file_content in get_content(repo.to_dict())[FILE_CONTENT_NAME]:
modify_repo(cfg, repo.to_dict(), remove_units=[file_content])
version_hrefs = tuple(ver["pulp_href"]
for ver in get_versions(repo.to_dict()))
non_latest = choice(version_hrefs[:-1])
# Step 2
publish_data = FileFilePublication(repository=repo.pulp_href)
publish_response = publications.create(publish_data)
created_resources = monitor_task(publish_response.task)
publication_href = created_resources[0]
self.addCleanup(publications.delete, publication_href)
publication = publications.read(publication_href)
# Step 3
self.assertEqual(publication.repository_version, version_hrefs[-1])
# Step 4
publish_data = FileFilePublication(repository_version=non_latest)
publish_response = publications.create(publish_data)
created_resources = monitor_task(publish_response.task)
publication_href = created_resources[0]
publication = publications.read(publication_href)
# Step 5
self.assertEqual(publication.repository_version, non_latest)
# Step 6
with self.assertRaises(ApiException):
body = {
"repository": repo.pulp_href,
"repository_version": non_latest
}
publications.create(body)
def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
cls.client = gen_file_client()
def do_test(self, policy):
"""Verify whether content served by pulp can be downloaded.
The process of publishing content is more involved in Pulp 3 than it
was under Pulp 2. Given a repository, the process is as follows:
1. Create a publication from the repository. (The latest repository
version is selected if no version is specified.) A publication is a
repository version plus metadata.
2. Create a distribution from the publication. The distribution defines
at which URLs a publication is available, e.g.
``http://example.com/content/foo/`` and
``http://example.com/content/bar/``.
Do the following:
1. Create, populate, publish, and distribute a repository.
2. Select a random content unit in the distribution. Download that
content unit from Pulp, and verify that the content unit has the
same checksum when fetched directly from Pulp-Fixtures.
This test targets the following issues:
* `Pulp #2895 <https://pulp.plan.io/issues/2895>`_
* `Pulp Smash #872 <https://github.com/pulp/pulp-smash/issues/872>`_
"""
cfg = config.get_config()
client = gen_file_client()
repo_api = RepositoriesFileApi(client)
remote_api = RemotesFileApi(client)
publications = PublicationsFileApi(client)
distributions = DistributionsFileApi(client)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
body = gen_file_remote(policy=policy)
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
# Sync a Repository
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
# Create a publication.
publish_data = FileFilePublication(repository=repo.pulp_href)
publish_response = publications.create(publish_data)
created_resources = monitor_task(publish_response.task)
publication_href = created_resources[0]
self.addCleanup(publications.delete, publication_href)
# Create a distribution.
body = gen_distribution()
body["publication"] = publication_href
distribution_response = distributions.create(body)
created_resources = monitor_task(distribution_response.task)
distribution = distributions.read(created_resources[0])
self.addCleanup(distributions.delete, distribution.pulp_href)
# Pick a file, and download it from both Pulp Fixtures…
unit_path = choice(get_file_content_paths(repo.to_dict()))
fixtures_hash = hashlib.sha256(
utils.http_get(urljoin(FILE_FIXTURE_URL, unit_path))).hexdigest()
# …and Pulp.
content = download_content_unit(cfg, distribution.to_dict(), unit_path)
pulp_hash = hashlib.sha256(content).hexdigest()
self.assertEqual(fixtures_hash, pulp_hash)
def setUpClass(cls):
"""Create class-wide variables."""
cls.remote_api = RemotesFileApi(gen_file_client())
cls.remote = {}
cls.policies = ON_DEMAND_DOWNLOAD_POLICIES
cls.body = _gen_verbose_remote()
def setUpClass(cls):
"""Define class-wide variable."""
cls.client = gen_file_client()
def setUpClass(cls):
"""Create class-wide variables."""
cls.remote_api = RemotesFileApi(gen_file_client())
