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_rpm_client()
repo_api = RepositoriesRpmApi(client)
remote_api = RemotesRpmApi(client)
publications = PublicationsRpmApi(client)
body = gen_rpm_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 = RpmRepositorySyncURL(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 rpm_content in get_content(
repo.to_dict())[RPM_PACKAGE_CONTENT_NAME]:
modify_repo(cfg, repo.to_dict(), add_units=[rpm_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 = RpmRpmPublication(repository=repo.pulp_href)
publish_response = publications.create(publish_data)
created_resources = monitor_task(
publish_response.task).created_resources
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.repository_version = non_latest
publish_data.repository = None
publish_response = publications.create(publish_data)
created_resources = monitor_task(
publish_response.task).created_resources
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 do_test(self, download_policy):
"""Sync repositories with the different ``download_policy``.
Do the following:
1. Create a repository, and a remote.
2. Sync the remote.
3. Assert that repository version is not None.
4. Assert that the correct number of possible units to be downloaded
were shown.
5. Sync the remote one more time in order to create another repository
version.
6. Assert that repository version is different from the previous one.
7. Assert that the same number of units are shown, and after the
second sync no extra units should be shown, since the same remote
was synced again.
8. Publish repository synced with lazy ``download_policy``.
"""
repo_api = RepositoriesRpmApi(self.client)
remote_api = RemotesRpmApi(self.client)
publications = PublicationsRpmApi(self.client)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
body = gen_rpm_remote(**{"policy": download_policy})
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
# Sync the repository.
self.assertEqual(repo.latest_version_href,
f"{repo.pulp_href}versions/0/")
repository_sync_data = RpmRepositorySyncURL(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)
self.assertDictEqual(get_content_summary(repo.to_dict()),
RPM_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo.to_dict()),
RPM_FIXTURE_SUMMARY)
# Sync the repository again.
latest_version_href = repo.latest_version_href
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
self.assertEqual(latest_version_href, repo.latest_version_href)
self.assertDictEqual(get_content_summary(repo.to_dict()),
RPM_FIXTURE_SUMMARY)
# Publish
publish_data = RpmRpmPublication(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)
self.assertIsNotNone(publication.repository)
self.assertIsNotNone(publication.repository_version)
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_rpm_client()
repo_api = RepositoriesRpmApi(client)
remote_api = RemotesRpmApi(client)
publications = PublicationsRpmApi(client)
distributions = DistributionsRpmApi(client)
body = gen_rpm_remote()
remote = remote_api.create(body)
repo = repo_api.create(gen_repo())
repository_sync_data = RpmRepositorySyncURL(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)
repo_content = get_content(
repo.to_dict())[RPM_PACKAGE_CONTENT_NAME][:-1]
for rpm_content in repo_content:
modify_repo(cfg, repo.to_dict(), remove_units=[rpm_content])
version_hrefs = tuple(ver["pulp_href"]
for ver in get_versions(repo.to_dict()))
non_latest = choice(version_hrefs[1:-1])
# Step 2
publish_data = RpmRpmPublication(repository=repo.pulp_href)
publish_response = publications.create(publish_data)
created_resources = monitor_task(
publish_response.task).created_resources
publication_href = created_resources[0]
publication = publications.read(publication_href)
# Step 3
self.assertEqual(publication.repository_version, version_hrefs[-1])
# Step 4
publish_data.repository_version = non_latest
publish_data.repository = None
publish_response = publications.create(publish_data)
created_resources = monitor_task(
publish_response.task).created_resources
publication_href = created_resources[0]
publication = publications.read(publication_href)
# Step 5
body = gen_distribution()
body["base_path"] = "pulp_pre_upgrade_test"
body["publication"] = publication.pulp_href
distribution_response = distributions.create(body)
created_resources = monitor_task(
distribution_response.task).created_resources
distribution = distributions.read(created_resources[0])
# Step 6
self.assertEqual(publication.repository_version, non_latest)
# Step 7
with self.assertRaises(ApiException):
body = {
"repository": repo.pulp_href,
"repository_version": non_latest
}
publications.create(body)
# Step 8
url = cfg.get_content_host_base_url(
) + "/pulp/content/pulp_pre_upgrade_test/"
self.assertEqual(url, distribution.base_url, url)