def test_all(self):
"""Test whether sync/publish for content already in Pulp."""
cfg = config.get_config()
client = api.Client(cfg, api.page_handler)
# step 1. delete orphans to assure that no content is present on disk,
# or database.
delete_orphans(cfg)
remote = client.post(
FILE_REMOTE_PATH,
gen_remote(FILE_FIXTURE_MANIFEST_URL)
)
self.addCleanup(client.delete, remote['_href'])
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
publisher = client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher['_href'])
for _ in range(2):
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
publish(cfg, publisher, repo)
def test_06_publication_create_order(self):
"""Assert that publications are ordered by created time.
This test targets the following issues:
* `Pulp Smash #954 <https://github.com/PulpQE/pulp-smash/issues/954>`_
* `Pulp #3576 <https://pulp.plan.io/issues/3576>`_
"""
# Create more 2 publications for the same repo
for _ in range(2):
publish(self.cfg, self.publisher, self.repo)
# Read publications
publications = self.client.get(
PUBLICATIONS_PATH,
params={'publisher': self.publisher['_href']}
)
self.assertEqual(len(publications), 3)
# Assert publications are ordered by _created field in descending order
for i, publication in enumerate(publications[:-1]):
self.assertGreater(
parse_date_from_string(publication['_created']), # Current
parse_date_from_string(publications[i + 1]['_created']) # Prev
)
def test_06_publication_create_order(self):
"""Assert that publications are ordered by created time.
This test targets the following issues:
* `Pulp Smash #954 <https://github.com/PulpQE/pulp-smash/issues/954>`_
* `Pulp #3576 <https://pulp.plan.io/issues/3576>`_
"""
# Create more 2 publications for the same repo
for _ in range(2):
publish(self.cfg, self.publisher, self.repo)
# Read publications
publications = self.client.get(
PUBLICATIONS_PATH,
params={'publisher': self.publisher['_href']}
)
self.assertEqual(len(publications), 3)
# Assert publications are ordered by _created field in descending order
for i, publication in enumerate(publications[:-1]):
self.assertGreater(
parse_date_from_string(publication['_created']), # Current
parse_date_from_string(publications[i + 1]['_created']) # Prev
)
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 = api.Client(cfg, api.json_handler)
body = gen_rpm_remote()
remote = client.post(RPM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
sync(cfg, remote, repo)
publisher = client.post(RPM_PUBLISHER_PATH, gen_rpm_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Step 1
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
for rpm_content in client.get(RPM_CONTENT_PATH)['results']:
client.post(
repo['_versions_href'],
{'add_content_units': [rpm_content['_href']]}
)
version_hrefs = tuple(ver['_href'] for ver in get_versions(repo))
non_latest = choice(version_hrefs[:-1])
# Step 2
publication = publish(cfg, publisher, repo)
# Step 3
self.assertEqual(publication['repository_version'], version_hrefs[-1])
# Step 4
publication = publish(cfg, publisher, repo, non_latest)
# Step 5
self.assertEqual(publication['repository_version'], non_latest)
# Step 6
with self.assertRaises(HTTPError):
body = {
'repository': repo['_href'],
'repository_version': non_latest
}
client.post(urljoin(publisher['_href'], 'publish/'), body)
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 = api.Client(cfg, api.json_handler)
body = gen_rpm_remote()
remote = client.post(RPM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
sync(cfg, remote, repo)
publisher = client.post(RPM_PUBLISHER_PATH, gen_rpm_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Step 1
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
for rpm_content in client.get(RPM_CONTENT_PATH)['results']:
client.post(
repo['_versions_href'],
{'add_content_units': [rpm_content['_href']]}
)
version_hrefs = tuple(ver['_href'] for ver in get_versions(repo))
non_latest = choice(version_hrefs[:-1])
# Step 2
publication = publish(cfg, publisher, repo)
# Step 3
self.assertEqual(publication['repository_version'], version_hrefs[-1])
# Step 4
publication = publish(cfg, publisher, repo, non_latest)
# Step 5
self.assertEqual(publication['repository_version'], non_latest)
# Step 6
with self.assertRaises(HTTPError):
body = {
'repository': repo['_href'],
'repository_version': non_latest
}
client.post(urljoin(publisher['_href'], 'publish/'), body)
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.
"""
body = gen_python_remote(PYTHON_FIXTURES_URL)
remote = self.client.post(PYTHON_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote['_href'])
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
sync(self.cfg, remote, repo)
publisher = self.client.post(PYTHON_PUBLISHER_PATH,
gen_python_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
# Step 1
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
for python_content in self.client.get(PYTHON_CONTENT_PATH)['results']:
self.client.post(repo['_versions_href'],
{'add_content_units': [python_content['_href']]})
versions = get_versions(repo)
non_latest = choice(versions[:-1])['_href']
# Step 2
publication = publish(self.cfg, publisher, repo)
# Step 3
self.assertEqual(publication['repository_version'],
versions[-1]['_href'])
# Step 4
publication = publish(self.cfg, publisher, repo, non_latest)
# Step 5
self.assertEqual(publication['repository_version'], non_latest)
# Step 6
with self.assertRaises(HTTPError):
body = {
'repository': repo['_href'],
'repository_version': non_latest
}
self.client.post(urljoin(publisher['_href'], 'publish/'), body)
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 = api.Client(cfg, api.json_handler)
body = gen_ansible_remote()
remote = client.post(ANSIBLE_REMOTE_PATH, body)
self.addCleanup(client.delete, remote["pulp_href"])
repo = client.post(ANSIBLE_REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo["pulp_href"])
sync(cfg, remote, repo)
publisher = client.post(ANSIBLE_PUBLISHER_PATH,
gen_ansible_publisher())
self.addCleanup(client.delete, publisher["pulp_href"])
# Step 1
repo = client.get(repo["pulp_href"])
for ansible_content in get_content(repo)[ANSIBLE_ROLE_NAME]:
client.post(repo["pulp_href"] + "modify/",
{"add_content_units": [ansible_content["pulp_href"]]})
version_hrefs = tuple(ver["pulp_href"] for ver in get_versions(repo))
non_latest = choice(version_hrefs[:-1])
# Step 2
publication = publish(cfg, publisher, repo)
# Step 3
self.assertEqual(publication["repository_version"], version_hrefs[-1])
# Step 4
publication = publish(cfg, publisher, repo, non_latest)
# Step 5
self.assertEqual(publication["repository_version"], non_latest)
# Step 6
with self.assertRaises(HTTPError):
body = {
"repository": repo["pulp_href"],
"repository_version": non_latest
}
client.post(urljoin(publisher["pulp_href"], "publish/"), body)
def test_all(self):
"""Sync/publish a repo that ``updateinfo.xml`` contains references.
This test targets the following issue:
`Pulp #3998 <https://pulp.plan.io/issues/3998>`_.
"""
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
body = gen_rpm_remote(url=RPM_REFERENCES_UPDATEINFO_URL)
remote = self.client.post(RPM_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote['_href'])
sync(self.cfg, remote, repo)
repo = self.client.get(repo['_href'])
self.assertIsNotNone(repo['_latest_version_href'])
content_summary = get_content_summary(repo)
self.assertDictEqual(content_summary, RPM_FIXTURE_SUMMARY,
content_summary)
publisher = self.client.post(RPM_PUBLISHER_PATH, gen_rpm_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
publication = publish(self.cfg, publisher, repo)
self.addCleanup(self.client.delete, publication['_href'])
def test_all(self):
"""Verify publisher and remote can be used with different repos.
This test explores the design choice stated in `Pulp #3341`_ that
remove the FK from publishers and remotes to repository.
Allowing remotes and publishers to be used with different
repositories.
.. _Pulp #3341: https://pulp.plan.io/issues/3341
Do the following:
1. Create a remote, and a publisher.
2. Create 2 repositories.
3. Sync both repositories using the same remote.
4. Assert that the two repositories have the same contents.
5. Publish both repositories using the same publisher.
6. Assert that each generated publication has the same publisher, but
are associated with different repositories.
"""
cfg = config.get_config()
# Create a remote and publisher.
client = api.Client(cfg, api.json_handler)
body = gen_file_remote()
remote = client.post(FILE_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
publisher = client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Create and sync repos.
repos = []
for _ in range(2):
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
sync(cfg, remote, repo)
repos.append(client.get(repo['_href']))
# Compare contents of repositories.
contents = []
for repo in repos:
contents.append(get_content(repo)[FILE_CONTENT_NAME])
self.assertEqual(
{content['_href'] for content in contents[0]},
{content['_href'] for content in contents[1]},
)
# Publish repositories.
publications = []
for repo in repos:
publications.append(publish(cfg, publisher, repo))
self.assertEqual(
publications[0]['publisher'],
publications[1]['publisher']
)
self.assertNotEqual(
publications[0]['repository_version'],
publications[1]['repository_version']
)
def test_all(self):
"""Verify the set up of parameters related to auto distribution.
This test targets the following issues:
* `Pulp #3295 <https://pulp.plan.io/issues/3295>`_
* `Pulp #3392 <https://pulp.plan.io/issues/3392>`_
* `Pulp #3394 <https://pulp.plan.io/issues/3394>`_
* `Pulp #3671 <https://pulp.plan.io/issues/3671>`_
* `Pulp Smash #883 <https://github.com/PulpQE/pulp-smash/issues/883>`_
* `Pulp Smash #917 <https://github.com/PulpQE/pulp-smash/issues/917>`_
"""
# Create a repository and a publisher.
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
publisher = self.client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
# Create a distribution.
self.try_create_distribution(publisher=publisher['_href'])
self.try_create_distribution(repository=repo['_href'])
body = gen_distribution()
body['publisher'] = publisher['_href']
body['repository'] = repo['_href']
response_dict = self.client.post(DISTRIBUTION_PATH, body)
dist_task = self.client.get(response_dict['task'])
distribution_href = dist_task['created_resources'][0]
distribution = self.client.get(distribution_href)
self.addCleanup(self.client.delete, distribution['_href'])
# Update the distribution.
self.try_update_distribution(distribution, publisher=None)
self.try_update_distribution(distribution, repository=None)
self.client.patch(distribution['_href'], {
'publisher': None,
'repository': None,
})
distribution = self.client.get(distribution['_href'])
self.assertIsNone(distribution['publisher'], distribution)
self.assertIsNone(distribution['repository'], distribution)
# Publish the repository. Assert that distribution does not point to
# the new publication (because publisher and repository are unset).
remote = self.client.post(
FILE_REMOTE_PATH,
gen_remote(FILE_FIXTURE_MANIFEST_URL),
)
self.addCleanup(self.client.delete, remote['_href'])
sync(self.cfg, remote, repo)
publication = publish(self.cfg, publisher, repo)
self.addCleanup(self.client.delete, publication['_href'])
distribution = self.client.get(distribution['_href'])
self.assertNotEqual(distribution['publication'], publication['_href'])
def test_publish_invalid_repo_version(self):
"""Repo version containing two units with the same name and version can't be published."""
cfg = config.get_config()
delete_orphans(cfg)
client = api.Client(cfg, api.json_handler)
# Create repo u1 and sync partially
repo_u1 = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo_u1["_href"])
body = gen_remote(fixture_u1.url,
cookbooks={fixture_u1.example1_name: ""})
remote_u1 = client.post(COOKBOOK_REMOTE_PATH, body)
self.addCleanup(client.delete, remote_u1["_href"])
sync(cfg, remote_u1, repo_u1, mirror=True)
repo_u1 = client.get(repo_u1["_href"])
# Create repo u1_diff_digest and sync partially
repo_u1_diff_digest = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo_u1_diff_digest["_href"])
body = gen_remote(fixture_u1_diff_digest.url,
cookbooks={fixture_u1.example1_name: ""})
remote_u1_diff_digest = client.post(COOKBOOK_REMOTE_PATH, body)
self.addCleanup(client.delete, remote_u1_diff_digest["_href"])
sync(cfg, remote_u1_diff_digest, repo_u1_diff_digest, mirror=True)
repo_u1_diff_digest = client.get(repo_u1_diff_digest["_href"])
# Add a content unit from u1_diff_digest to u1 (duplicate name&version)
content_u1_diff_digest = get_cookbook_content(repo_u1_diff_digest)
self.assertTrue(content_u1_diff_digest)
client.post(
repo_u1["_versions_href"],
{"add_content_units": [content_u1_diff_digest[0]["_href"]]})
publisher = client.post(COOKBOOK_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher["_href"])
with self.assertRaisesRegex(TaskReportError,
"would contain multiple versions"):
publish(cfg, publisher, repo_u1)
def test_all(self):
"""Verify the set up of parameters related to auto distribution.
This test targets the following issues:
* `Pulp #3295 <https://pulp.plan.io/issues/3295>`_
* `Pulp #3392 <https://pulp.plan.io/issues/3392>`_
* `Pulp #3394 <https://pulp.plan.io/issues/3394>`_
* `Pulp #3671 <https://pulp.plan.io/issues/3671>`_
* `Pulp Smash #883 <https://github.com/PulpQE/pulp-smash/issues/883>`_
* `Pulp Smash #917 <https://github.com/PulpQE/pulp-smash/issues/917>`_
"""
# Create a repository and a publisher.
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
publisher = self.client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
# Create a distribution.
self.try_create_distribution(publisher=publisher['_href'])
self.try_create_distribution(repository=repo['_href'])
body = gen_distribution()
body['publisher'] = publisher['_href']
body['repository'] = repo['_href']
distribution = self.client.post(DISTRIBUTION_PATH, body)
self.addCleanup(self.client.delete, distribution['_href'])
# Update the distribution.
self.try_update_distribution(distribution, publisher=None)
self.try_update_distribution(distribution, repository=None)
distribution = self.client.patch(distribution['_href'], {
'publisher': None,
'repository': None,
})
self.assertIsNone(distribution['publisher'], distribution)
self.assertIsNone(distribution['repository'], distribution)
# Publish the repository. Assert that distribution does not point to
# the new publication (because publisher and repository are unset).
remote = self.client.post(
FILE_REMOTE_PATH,
gen_remote(FILE_FIXTURE_MANIFEST_URL),
)
self.addCleanup(self.client.delete, remote['_href'])
sync(self.cfg, remote, repo)
publication = publish(self.cfg, publisher, repo)
self.addCleanup(self.client.delete, publication['_href'])
distribution = self.client.get(distribution['_href'])
self.assertNotEqual(distribution['publication'], publication['_href'])
def test_delete_publication(self):
"""Delete a publication.
Delete a repository version, and verify the associated publication is
also deleted.
"""
publisher = self.client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
publication = publish(self.cfg, publisher, self.repo)
delete_version(self.repo)
with self.assertRaises(HTTPError):
self.client.get(publication['_href'])
def setUpClass(cls):
"""Initialize common use entities and variables.
0. Prepare artifacts (ca and client certs)
1. Create self.contentguard for ca.pem located in CERT_CA_PATH.
2. create a repo.
3. create a file remote.
4. Sync it.
5. Create a Publisher.
6. Create a Publication.
"""
cls.cfg = cfg = config.get_config()
cls.client = client = api.Client(cfg, api.page_handler)
cls.teardown_cleanups = []
# The certificate header must have no \n chars
with open(CERT_CLIENT_FILE_PATH, 'r') as cert_client_file:
cls.client_cert = str(cert_client_file.read()).replace('\n', '')
with utils.ensure_teardownclass(cls):
# 1. Create certguard
with open(CERT_CA_FILE_PATH, 'rb') as cert_ca_file:
cls.certguard = client.post(
CONTENT_GUARDS_PATH,
data={'name': utils.uuid4()},
files={'ca_certificate': cert_ca_file})
cls.teardown_cleanups.append(
(client.delete, cls.certguard['_href']))
# 2. Create a repo
_repo = client.post(REPO_PATH, gen_repo())
cls.teardown_cleanups.append((cls.client.delete, _repo['_href']))
# 3. Create a remote
cls.remote = client.post(FILE_REMOTE_PATH, gen_file_remote())
cls.teardown_cleanups.append(
(cls.client.delete, cls.remote['_href']))
# 4. Sync and read synced repo
sync(cfg, cls.remote, _repo)
cls.repo = client.get(_repo['_href'])
# 5. Create a Publisher
cls.publisher = client.post(FILE_PUBLISHER_PATH,
gen_file_publisher())
cls.teardown_cleanups.append(
(cls.client.delete, cls.publisher['_href']))
# 6. Create a publication
cls.publication = publish(cfg, cls.publisher, cls.repo)
cls.teardown_cleanups.append(
(cls.client.delete, cls.publication['_href']))
def test_delete_publication(self):
"""Delete a publication.
Delete a repository version, and verify the associated publication is
also deleted.
"""
publisher = self.client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
publication = publish(self.cfg, publisher, self.repo)
delete_version(self.repo)
with self.assertRaises(HTTPError):
self.client.get(publication['_href'])
def test_all(self):
"""Verify whether package manager can consume content from Pulp.
This test targets the following issue:
`Pulp #3204 <https://pulp.plan.io/issues/3204>`_
"""
cfg = config.get_config()
try:
cli.PackageManager._get_package_manager(cfg) # pylint:disable=protected-access
except NoKnownPackageManagerError:
raise unittest.SkipTest('This test requires dnf or yum.')
client = api.Client(cfg, api.json_handler)
body = gen_rpm_remote()
remote = client.post(RPM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
sync(cfg, remote, repo)
publisher = client.post(RPM_PUBLISHER_PATH, gen_rpm_publisher())
self.addCleanup(client.delete, publisher['_href'])
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
body = gen_distribution()
body['publication'] = publication['_href']
distribution = client.post(DISTRIBUTION_PATH, body)
self.addCleanup(client.delete, distribution['_href'])
repo_path = gen_yum_config_file(
cfg,
baseurl=urljoin(cfg.get_base_url(), urljoin(
'pulp/content/',
distribution['base_path']
)),
name=repo['name'],
repositoryid=repo['name']
)
cli_client = cli.Client(cfg)
self.addCleanup(cli_client.run, ('rm', repo_path), sudo=True)
rpm_name = 'walrus'
pkg_mgr = cli.PackageManager(cfg)
pkg_mgr.install(rpm_name)
self.addCleanup(pkg_mgr.uninstall, rpm_name)
rpm = cli_client.run(('rpm', '-q', rpm_name)).stdout.strip().split('-')
self.assertEqual(rpm_name, rpm[0])
def test_all(self):
"""Test whether sync/publish for content already in Pulp."""
cfg = config.get_config()
client = api.Client(cfg, api.page_handler)
# step 1. delete orphans to assure that no content is present on disk,
# or database.
delete_orphans(cfg)
remote = client.post(FILE_REMOTE_PATH,
gen_remote(FILE_FIXTURE_MANIFEST_URL))
self.addCleanup(client.delete, remote['_href'])
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
publisher = client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher['_href'])
for _ in range(2):
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
publish(cfg, publisher, repo)
def test_all(self):
"""Verify whether package manager can consume content from Pulp.
This test targets the following issue:
`Pulp #3204 <https://pulp.plan.io/issues/3204>`_
"""
cfg = config.get_config()
pkg_mgr = cli.PackageManager(cfg)
try:
pkg_mgr.name
except NoKnownPackageManagerError:
raise unittest.SkipTest('This test requires dnf or yum.')
client = api.Client(cfg, api.json_handler)
body = gen_rpm_remote()
remote = client.post(RPM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
sync(cfg, remote, repo)
publisher = client.post(RPM_PUBLISHER_PATH, gen_rpm_publisher())
self.addCleanup(client.delete, publisher['_href'])
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
body = gen_distribution()
body['publication'] = publication['_href']
distribution = client.using_handler(api.task_handler).post(
DISTRIBUTION_PATH, body)
self.addCleanup(client.delete, distribution['_href'])
repo_path = gen_yum_config_file(cfg,
baseurl=urljoin(
cfg.get_content_host_base_url(),
'//' + distribution['base_url']),
name=repo['name'],
repositoryid=repo['name'])
cli_client = cli.Client(cfg)
self.addCleanup(cli_client.run, ('rm', repo_path), sudo=True)
rpm_name = 'walrus'
pkg_mgr.install(rpm_name)
self.addCleanup(pkg_mgr.uninstall, rpm_name)
rpm = cli_client.run(('rpm', '-q', rpm_name)).stdout.strip().split('-')
self.assertEqual(rpm_name, rpm[0])
def do_publish(self, download_policy):
"""Publish repository synced with lazy ``download_policy``."""
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
remote = self.client.post(RPM_REMOTE_PATH,
gen_rpm_remote(policy=download_policy))
self.addCleanup(self.client.delete, remote['_href'])
sync(self.cfg, remote, repo)
repo = self.client.get(repo['_href'])
publisher = self.client.post(RPM_PUBLISHER_PATH, gen_rpm_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
publication = publish(self.cfg, publisher, repo)
self.assertIsNotNone(publication['repository_version'], publication)
def do_test(self, url):
"""Sync and publish an RPM repository given a feed URL."""
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
remote = self.client.post(RPM_REMOTE_PATH, gen_rpm_remote(url=url))
self.addCleanup(self.client.delete, remote['_href'])
sync(self.cfg, remote, repo)
repo = self.client.get(repo['_href'])
self.assertIsNotNone(repo['_latest_version_href'])
publisher = self.client.post(RPM_PUBLISHER_PATH, gen_rpm_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
publication = publish(self.cfg, publisher, repo)
self.addCleanup(self.client.delete, publication['_href'])
def create_distribution(self, cfg, client, repo):
"""Create a publication for the latest repo version and a distribution."""
# Create a publisher.
publisher = client.post(COOKBOOK_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher["_href"])
# Create a publication.
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication["_href"])
# Create a distribution.
body = gen_distribution()
body["publication"] = publication["_href"]
response_dict = client.post(DISTRIBUTION_PATH, body)
dist_task = client.get(response_dict["task"])
distribution_href = dist_task["created_resources"][0]
distribution = client.get(distribution_href)
self.addCleanup(client.delete, distribution_href)
return distribution
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()
delete_orphans(cfg)
client = api.Client(cfg, api.json_handler)
body = gen_remote(fixture_u1.url,
cookbooks={fixture_u1.example1_name: ""})
remote = client.post(COOKBOOK_REMOTE_PATH, body)
self.addCleanup(client.delete, remote["_href"])
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo["_href"])
sync(cfg, remote, repo, mirror=True)
repo = client.get(repo["_href"])
repo_content = get_cookbook_content(repo)
self.assertTrue(repo_content)
publisher = client.post(COOKBOOK_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher["_href"])
# Step 1
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo["_href"])
for cookbook in repo_content:
client.post(repo["_versions_href"],
{"add_content_units": [cookbook["_href"]]})
version_hrefs = tuple(ver["_href"] for ver in get_versions(repo))
non_latest = choice(version_hrefs[:-1])
# Step 2
publication = publish(cfg, publisher, repo)
# Step 3
self.assertEqual(publication["repository_version"], version_hrefs[-1])
# Step 4
publication = publish(cfg, publisher, repo, non_latest)
# Step 5
self.assertEqual(publication["repository_version"], non_latest)
# Step 6
with self.assertRaises(HTTPError):
body = {
"repository": repo["_href"],
"repository_version": non_latest
}
client.post(urljoin(publisher["_href"], "publish/"), body)
def test_all(self):
"""Test content promotion for a distribution.
This test targets the following issue:
* `Pulp #4186 <https://pulp.plan.io/issues/4186>`_
Do the following:
1. Create a repository that has at least one repository version.
2. Create a publisher, and publication.
3. Create 2 distributions - using the same publication. Those
distributions will have different ``base_path``.
4. Assert that distributions have the same publication.
5. Select a content unit. Download that content unit from Pulp using
the two different distributions.
Assert that content unit has the same checksum when fetched from
different distributions.
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
remote = client.post(FILE_REMOTE_PATH,
gen_remote(FILE_FIXTURE_MANIFEST_URL))
self.addCleanup(client.delete, remote['_href'])
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
publisher = client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher['_href'])
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
distributions = []
for _ in range(2):
body = gen_distribution()
body['publication'] = publication['_href']
distribution = client.post(DISTRIBUTION_PATH, body)
distributions.append(distribution)
self.addCleanup(client.delete, distribution['_href'])
self.assertEqual(distributions[0]['publication'],
distributions[1]['publication'], distributions)
unit_urls = []
unit_path = get_added_content(repo)[0]['relative_path']
for distribution in distributions:
unit_url = cfg.get_hosts('api')[0].roles['api']['scheme']
unit_url += '://' + distribution['base_url'] + '/'
unit_urls.append(urljoin(unit_url, unit_path))
client.response_handler = api.safe_handler
self.assertEqual(
hashlib.sha256(client.get(unit_urls[0]).content).hexdigest(),
hashlib.sha256(client.get(unit_urls[1]).content).hexdigest(),
unit_urls,
)
def test_all(self):
"""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/PulpQE/pulp-smash/issues/872>`_
"""
cfg = config.get_config()
if not selectors.bug_is_fixed(3502, cfg.pulp_version):
self.skipTest('https://pulp.plan.io/issues/3502')
client = api.Client(cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
body = gen_remote(urljoin(FILE_FEED_URL, 'PULP_MANIFEST'))
remote = client.post(FILE_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
# Create a publisher.
publisher = client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Create a publication.
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
# Create a distribution.
body = gen_distribution()
body['publication'] = publication['_href']
distribution = client.post(DISTRIBUTION_PATH, body)
self.addCleanup(client.delete, distribution['_href'])
# Pick a file, and download it from both Pulp Fixtures…
unit_path = choice(get_content_unit_paths(repo))
fixtures_hash = hashlib.sha256(
utils.http_get(urljoin(FILE_FEED_URL, unit_path))).hexdigest()
# …and Pulp.
client.response_handler = api.safe_handler
unit_url = cfg.get_hosts('api')[0].roles['api']['scheme']
unit_url += '://' + distribution['base_url'] + '/'
unit_url = urljoin(unit_url, unit_path)
pulp_hash = hashlib.sha256(client.get(unit_url).content).hexdigest()
self.assertEqual(fixtures_hash, pulp_hash)
def test_content_app_returns_404(self):
"""Test that content app returns 404 on wrong url.
This test targets the following issue: 4278
* `<https://pulp.plan.io/issues/4278>`_
Do the following:
1. Create a repository that has at least one repository version.
2. Create a publisher.
3. Create a distribution and set the repository and publisher to the
previous created ones.
4. Create a publication using the latest repository version.
5. Verify that the content app serves 404 responses.
"""
self.assertGreaterEqual(len(self.contents), 2, self.contents)
# Create a repository.
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
self.client.post(repo['_versions_href'],
{'add_content_units': [self.contents[0]['_href']]})
repo = self.client.get(repo['_href'])
# Create publisher.
publisher = self.client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
# Create a distribution
body = gen_distribution()
body['repository'] = repo['_href']
body['publisher'] = publisher['_href']
distribution = self.client.post(DISTRIBUTION_PATH, body)
self.addCleanup(self.client.delete, distribution['_href'])
last_version_href = get_versions(repo)[-1]['_href']
publication = publish(self.cfg, publisher, repo, last_version_href)
self.addCleanup(self.client.delete, publication['_href'])
distribution = self.client.get(distribution['_href'])
# Verify 404 response for wrong url of the distribution
unit_path = 'i-do-not-exist'
unit_url = self.cfg.get_hosts('api')[0].roles['api']['scheme']
unit_url += '://' + distribution['base_url'] + '-WRONG/'
unit_url = urljoin(unit_url, unit_path)
self.client.response_handler = api.safe_handler
with self.assertRaisesRegex(HTTPError, r'^404'):
self.client.get(unit_url).content
# Verify 404 response for wrong url inside the distribution
unit_path = 'i-do-not-exist'
unit_url = self.cfg.get_hosts('api')[0].roles['api']['scheme']
unit_url += '://' + distribution['base_url'] + '/'
unit_url = urljoin(unit_url, unit_path)
self.client.response_handler = api.safe_handler
with self.assertRaisesRegex(HTTPError, r'^404'):
self.client.get(unit_url).content
def test_repo_auto_distribution(self):
"""Test auto distribution of a repository.
This test targets the following issue:
* `Pulp Smash #947 <https://github.com/PulpQE/pulp-smash/issues/947>`_
Do the following:
1. Create a repository that has at least one repository version.
2. Create a publisher.
3. Create a distribution and set the repository and publishera to the
previous created ones.
4. Create a publication using the latest repository version.
5. Assert that the previous distribution has a ``publication`` set as
the one created in step 4.
6. Create a new repository version by adding content to the repository.
7. Create another publication using the just created repository
version.
8. Assert that distribution now has the ``publication`` set to the
publication created in the step 7.
9. Verify that content added in the step 7 is now available to download
from distribution, and verify that the content unit has the same
checksum when fetched directly from Pulp-Fixtures.
"""
self.assertGreaterEqual(len(self.contents), 2, self.contents)
# Create a repository.
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
self.client.post(repo['_versions_href'],
{'add_content_units': [self.contents[0]['_href']]})
repo = self.client.get(repo['_href'])
# Create publisher.
publisher = self.client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
# Create a distribution
body = gen_distribution()
body['repository'] = repo['_href']
body['publisher'] = publisher['_href']
distribution = self.client.post(DISTRIBUTION_PATH, body)
self.addCleanup(self.client.delete, distribution['_href'])
last_version_href = get_versions(repo)[-1]['_href']
publication = publish(self.cfg, publisher, repo, last_version_href)
self.addCleanup(self.client.delete, publication['_href'])
distribution = self.client.get(distribution['_href'])
# Assert that distribution was updated as per step 5.
self.assertEqual(distribution['publication'], publication['_href'])
# Create a new repository version.
self.client.post(repo['_versions_href'],
{'add_content_units': [self.contents[1]['_href']]})
repo = self.client.get(repo['_href'])
last_version_href = get_versions(repo)[-1]['_href']
publication = publish(self.cfg, publisher, repo, last_version_href)
self.addCleanup(self.client.delete, publication['_href'])
distribution = self.client.get(distribution['_href'])
# Assert that distribution was updated as per step 8.
self.assertEqual(distribution['publication'], publication['_href'])
unit_path = get_added_content(repo,
last_version_href)[0]['relative_path']
unit_url = self.cfg.get_hosts('api')[0].roles['api']['scheme']
unit_url += '://' + distribution['base_url'] + '/'
unit_url = urljoin(unit_url, unit_path)
self.client.response_handler = api.safe_handler
pulp_hash = hashlib.sha256(
self.client.get(unit_url).content).hexdigest()
fixtures_hash = hashlib.sha256(
utils.http_get(urljoin(FILE_URL, unit_path))).hexdigest()
# Verify checksum. Step 9.
self.assertEqual(fixtures_hash, pulp_hash)
def test_all(self):
"""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. For the cookbook plugin
this is below a live API at ``pulp_cookbook/market/`` e.g.
``http://example.com/pulp_cookbook/market/foo/`` and
``http://example.com/pulp_cookbook/market/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 fixtures.
This test targets the following issues:
* `Pulp #2895 <https://pulp.plan.io/issues/2895>`_
* `Pulp Smash #872 <https://github.com/PulpQE/pulp-smash/issues/872>`_
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
body = gen_remote(fixture_u1.url)
remote = client.post(COOKBOOK_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
# Create a publisher.
publisher = client.post(COOKBOOK_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Create a publication.
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
# Create a distribution.
body = gen_distribution()
body['publication'] = publication['_href']
distribution = client.post(DISTRIBUTION_PATH, body)
self.addCleanup(client.delete, distribution['_href'])
# pulp_cookbook universe live endpoint contains
# all cookbooks
distribution_base_url = cfg.get_hosts('api')[0].roles['api']['scheme']
distribution_base_url += '://' + distribution['base_url'] + '/'
api_host_cfg = cfg.get_hosts('api')[0]
universe_url = api_host_cfg.roles['api']['scheme']
universe_url += '://' + api_host_cfg.hostname
universe_url += ':{}'.format(api_host_cfg.roles['api']['port'])
universe_url += COOKBOOK_BASE_LIVE_API_PATH
universe_url += distribution['base_path'] + '/universe'
universe = client.get(universe_url)
for content, publication_path in get_content_and_unit_paths(repo):
u_url = universe[content['name']][
content['version']]['download_url']
self.assertEqual(u_url,
urljoin(distribution_base_url, publication_path))
# Pick a cookbook, and download it from both Fixtures…
_, unit_path = choice(get_content_and_unit_paths(repo))
fixtures_hash = hashlib.sha256(
utils.http_get(urljoin(fixture_u1.url, unit_path))).hexdigest()
# …and Pulp content
client.response_handler = api.safe_handler
unit_url = urljoin(distribution_base_url, unit_path)
pulp_hash = hashlib.sha256(client.get(unit_url).content).hexdigest()
self.assertEqual(fixtures_hash, pulp_hash)
def test_repo_auto_distribution(self):
"""Test auto distribution of a repository.
This test targets the following issue:
* `Pulp Smash #947 <https://github.com/PulpQE/pulp-smash/issues/947>`_
Do the following:
1. Create a repository that has at least one repository version.
2. Create a publisher.
3. Create a distribution and set the repository and publishera to the
previous created ones.
4. Create a publication using the latest repository version.
5. Assert that the previous distribution has a ``publication`` set as
the one created in step 4.
6. Create a new repository version by adding content to the repository.
7. Create another publication using the just created repository
version.
8. Assert that distribution now has the ``publication`` set to the
publication created in the step 7.
9. Verify that content added in the step 7 is now available to download
from distribution, and verify that the content unit has the same
checksum when fetched directly from Pulp-Fixtures.
"""
self.assertGreaterEqual(len(self.contents), 2, self.contents)
# Create a repository.
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
self.client.post(
repo['_versions_href'],
{'add_content_units': [self.contents[0]['_href']]}
)
repo = self.client.get(repo['_href'])
# Create publisher.
publisher = self.client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(self.client.delete, publisher['_href'])
# Create a distribution
body = gen_distribution()
body['repository'] = repo['_href']
body['publisher'] = publisher['_href']
distribution = self.client.post(DISTRIBUTION_PATH, body)
self.addCleanup(self.client.delete, distribution['_href'])
last_version_href = get_versions(repo)[-1]['_href']
publication = publish(self.cfg, publisher, repo, last_version_href)
self.addCleanup(self.client.delete, publication['_href'])
distribution = self.client.get(distribution['_href'])
# Assert that distribution was updated as per step 5.
self.assertEqual(distribution['publication'], publication['_href'])
# Create a new repository version.
self.client.post(
repo['_versions_href'],
{'add_content_units': [self.contents[1]['_href']]}
)
repo = self.client.get(repo['_href'])
last_version_href = get_versions(repo)[-1]['_href']
publication = publish(self.cfg, publisher, repo, last_version_href)
self.addCleanup(self.client.delete, publication['_href'])
distribution = self.client.get(distribution['_href'])
# Assert that distribution was updated as per step 8.
self.assertEqual(distribution['publication'], publication['_href'])
unit_path = get_added_content(repo, last_version_href)[0]['relative_path']
unit_url = self.cfg.get_hosts('api')[0].roles['api']['scheme']
unit_url += '://' + distribution['base_url'] + '/'
unit_url = urljoin(unit_url, unit_path)
self.client.response_handler = api.safe_handler
pulp_hash = hashlib.sha256(
self.client.get(unit_url).content
).hexdigest()
fixtures_hash = hashlib.sha256(
utils.http_get(urljoin(FILE_URL, unit_path))
).hexdigest()
# Verify checksum. Step 9.
self.assertEqual(fixtures_hash, pulp_hash)
def test_all(self):
"""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/PulpQE/pulp-smash/issues/872>`_
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
body = gen_deb_remote()
remote = client.post(DEB_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
# Create a publisher.
publisher = client.post(self.Meta.publisher_path, self.Meta.gen_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Create a publication.
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
# Create a distribution.
body = gen_distribution()
body['publication'] = publication['_href']
response_dict = client.post(DISTRIBUTION_PATH, body)
dist_task = client.get(response_dict['task'])
distribution_href = dist_task['created_resources'][0]
distribution = client.get(distribution_href)
self.addCleanup(client.delete, distribution['_href'])
# Pick a content unit (of each type), and download it from both Pulp Fixtures…
unit_paths = [
choice(paths) for paths in self.Meta.get_content_unit_paths(repo).values() if paths
]
fixtures_hashes = [hashlib.sha256(
utils.http_get(urljoin(DEB_FIXTURE_URL, unit_path[0]))
).hexdigest() for unit_path in unit_paths]
# …and Pulp.
client.response_handler = api.safe_handler
unit_base_url = cfg.get_hosts('api')[0].roles['api']['scheme']
unit_base_url += '://' + distribution['base_url'] + '/'
unit_urls = [urljoin(unit_base_url, unit_path[1]) for unit_path in unit_paths]
pulp_hashes = [hashlib.sha256(client.get(unit_url).content).hexdigest()
for unit_url in unit_urls]
self.assertEqual(fixtures_hashes, pulp_hashes)
def test_all(self):
"""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/PulpQE/pulp-smash/issues/872>`_
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
body = gen_gem_remote()
remote = client.post(GEM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
# Create a publisher.
publisher = client.post(GEM_PUBLISHER_PATH, gen_gem_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Create a publication.
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
# Create a distribution.
body = gen_distribution()
body['publication'] = publication['_href']
response_dict = client.post(DISTRIBUTION_PATH, body)
dist_task = client.get(response_dict['task'])
distribution_href = dist_task['created_resources'][0]
distribution = client.get(distribution_href)
self.addCleanup(client.delete, distribution['_href'])
# Pick a content unit, and download it from both Pulp Fixtures…
unit_path = choice(get_gem_content_paths(repo))
fixtures_hash = hashlib.sha256(
utils.http_get(urljoin(GEM_FIXTURE_URL, unit_path))).hexdigest()
# …and Pulp.
content = download_content_unit(cfg, distribution, unit_path)
pulp_hash = hashlib.sha256(content).hexdigest()
self.assertEqual(fixtures_hash, pulp_hash)
def test_01_create_publication(self):
"""Create a publication."""
self.publication.update(publish(self.cfg, self.publisher, self.repo))
def test_01_create_publication(self):
"""Create a publication."""
self.publication.update(
publish(self.cfg, self.publisher, self.repo)
)
def test_all(self):
"""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/PulpQE/pulp-smash/issues/872>`_
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
body = gen_rpm_remote()
remote = client.post(RPM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
# Create a publisher.
publisher = client.post(RPM_PUBLISHER_PATH, gen_rpm_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Create a publication.
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
# Create a distribution.
body = gen_distribution()
body['publication'] = publication['_href']
response_dict = client.post(DISTRIBUTION_PATH, body)
dist_task = client.get(response_dict['task'])
distribution_href = dist_task['created_resources'][0]
distribution = client.get(distribution_href)
self.addCleanup(client.delete, distribution['_href'])
# Pick a content unit, and download it from both Pulp Fixtures…
unit_path = choice(get_rpm_package_paths(repo))
fixtures_hash = hashlib.sha256(
utils.http_get(urljoin(RPM_UNSIGNED_FIXTURE_URL, unit_path))
).hexdigest()
# …and Pulp.
content = download_content_unit(cfg, distribution, unit_path)
pulp_hash = hashlib.sha256(content).hexdigest()
self.assertEqual(fixtures_hash, pulp_hash)
def test_all(self):
"""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 Remote.
NOTE: content unit for docker is `image` or `Layer`
This test targets the following issues:
* `Pulp #2895 <https://pulp.plan.io/issues/2895>`_
* `Pulp Smash #872 <https://github.com/PulpQE/pulp-smash/issues/872>`_
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
body = gen_docker_remote()
remote = client.post(DOCKER_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
# Create a publisher.
publisher = client.post(DOCKER_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Create a publication.
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
# Create a distribution.
body = gen_distribution()
body['publication'] = publication['_href']
distribution = client.post(DOCKER_DISTRIBUTION_PATH, body)
self.addCleanup(client.delete, distribution['_href'])
# Get local checksums for content synced from remote registy
checksums = [
content['digest'] for content
in get_content(repo)['docker.manifest-blob']
]
# Assert that at least one layer is synced from remote:latest
# and the checksum matched with remote
self.assertTrue(
any(
[
result['blobSum'] in checksums
for result in get_docker_hub_remote_blobsums()
]
)
)
def test_all(self):
"""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 = api.Client(cfg, api.json_handler)
repo = client.post(ANSIBLE_REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo["pulp_href"])
body = gen_ansible_remote()
remote = client.post(ANSIBLE_REMOTE_PATH, body)
self.addCleanup(client.delete, remote["pulp_href"])
sync(cfg, remote, repo)
repo = client.get(repo["pulp_href"])
# Create a publisher.
publisher = client.post(ANSIBLE_PUBLISHER_PATH, gen_ansible_publisher())
self.addCleanup(client.delete, publisher["pulp_href"])
# Create a publication.
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication["pulp_href"])
# Create a distribution.
body = gen_distribution()
body["publication"] = publication["pulp_href"]
distribution = client.post(ANSIBLE_DISTRIBUTION_PATH, body)
self.addCleanup(client.delete, distribution["pulp_href"])
# Pick a content unit, and download it from both Pulp Fixtures…
unit_path = choice(get_ansible_content_paths(repo))
fixtures_hash = hashlib.sha256(
utils.http_get(urljoin(ANSIBLE_FIXTURE_URL, unit_path))
).hexdigest()
# …and Pulp.
client.response_handler = api.safe_handler
unit_url = cfg.get_hosts("api")[0].roles["api"]["scheme"]
unit_url += "://" + distribution["base_url"] + "/"
unit_url = urljoin(unit_url, unit_path)
pulp_hash = hashlib.sha256(client.get(unit_url).content).hexdigest()
self.assertEqual(fixtures_hash, pulp_hash)
def test_all(self):
"""Test content promotion for a distribution.
This test targets the following issue:
* `Pulp #4186 <https://pulp.plan.io/issues/4186>`_
Do the following:
1. Create a repository that has at least one repository version.
2. Create a publisher, and publication.
3. Create 2 distributions - using the same publication. Those
distributions will have different ``base_path``.
4. Assert that distributions have the same publication.
5. Select a content unit. Download that content unit from Pulp using
the two different distributions.
Assert that content unit has the same checksum when fetched from
different distributions.
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
remote = client.post(
FILE_REMOTE_PATH,
gen_remote(FILE_FIXTURE_MANIFEST_URL)
)
self.addCleanup(client.delete, remote['_href'])
sync(cfg, remote, repo)
repo = client.get(repo['_href'])
publisher = client.post(FILE_PUBLISHER_PATH, gen_publisher())
self.addCleanup(client.delete, publisher['_href'])
publication = publish(cfg, publisher, repo)
self.addCleanup(client.delete, publication['_href'])
distributions = []
for _ in range(2):
body = gen_distribution()
body['publication'] = publication['_href']
distribution = client.post(DISTRIBUTION_PATH, body)
distributions.append(distribution)
self.addCleanup(client.delete, distribution['_href'])
self.assertEqual(
distributions[0]['publication'],
distributions[1]['publication'],
distributions
)
unit_urls = []
unit_path = get_added_content(repo)[FILE_CONTENT_NAME][0]['relative_path']
for distribution in distributions:
unit_url = cfg.get_hosts('api')[0].roles['api']['scheme']
unit_url += '://' + distribution['base_url'] + '/'
unit_urls.append(urljoin(unit_url, unit_path))
client.response_handler = api.safe_handler
self.assertEqual(
hashlib.sha256(client.get(unit_urls[0]).content).hexdigest(),
hashlib.sha256(client.get(unit_urls[1]).content).hexdigest(),
unit_urls,
)
