def test_01_create_publisher(self):
"""Create a publisher."""
body = gen_publisher()
type(self).publisher = self.client.post(COOKBOOK_PUBLISHER_PATH, body)
for key, val in body.items():
with self.subTest(key=key):
self.assertEqual(self.publisher[key], val)
def test_04_fully_update(self):
"""Update a publisher using HTTP PUT."""
body = gen_publisher()
self.client.put(self.publisher["_href"], body)
type(self).publisher = self.client.get(self.publisher["_href"])
for key, val in body.items():
with self.subTest(key=key):
self.assertEqual(self.publisher[key], val)
def test_03_partially_update(self):
"""Update a publisher using HTTP PATCH."""
body = gen_publisher()
self.client.patch(self.publisher['_href'], body)
type(self).publisher = self.client.get(self.publisher['_href'])
for key, val in body.items():
with self.subTest(key=key):
self.assertEqual(self.publisher[key], val)
def test_02_create_same_name(self):
"""Try to create a second publisher with an identical name.
See: `Pulp Smash #1055
<https://github.com/PulpQE/pulp-smash/issues/1055>`_.
"""
body = gen_publisher()
body["name"] = self.publisher["name"]
with self.assertRaises(HTTPError):
self.client.post(COOKBOOK_PUBLISHER_PATH, body)
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_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):
"""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):
"""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)