def test_03_remove_content(self):
"""Remove content from the repository.
Make roughly the same assertions as :meth:`test_02_sync_content`.
"""
repo = self.client.get(self.repo['_href'])
self.content.update(choice(get_content(repo)))
self.client.post(
repo['_versions_href'],
{'remove_content_units': [self.content['_href']]}
)
repo = self.client.get(self.repo['_href'])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 2, repo_versions)
self.assertIsNotNone(repo['_latest_version_href'])
content = get_content(repo)
self.assertEqual(len(content), FILE_FIXTURE_COUNT - 1)
added_content = get_added_content(repo)
self.assertEqual(len(added_content), 0, added_content)
removed_content = get_removed_content(repo)
self.assertEqual(len(removed_content), 1, removed_content)
content_summary = self.get_content_summary(repo)
self.assertEqual(content_summary, {'file': FILE_FIXTURE_COUNT - 1})
def test_04_add_content(self):
"""Add content to the repository.
Make roughly the same assertions as :meth:`test_02_sync_content`.
"""
repo = self.client.get(self.repo['_href'])
self.client.post(
repo['_versions_href'],
{'add_content_units': [self.content['_href']]}
)
repo = self.client.get(self.repo['_href'])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 3, repo_versions)
self.assertIsNotNone(repo['_latest_version_href'])
content = get_content(repo)
self.assertEqual(len(content), FILE_FIXTURE_COUNT)
added_content = get_added_content(repo)
self.assertEqual(len(added_content), 1, added_content)
removed_content = get_removed_content(repo)
self.assertEqual(len(removed_content), 0, removed_content)
content_summary = self.get_content_summary(repo)
self.assertEqual(content_summary, {'file': FILE_FIXTURE_COUNT})
def test_02_sync_content(self):
"""Sync content into the repository.
Assert that:
* The ``_versions_href`` API call is correct.
* The ``_latest_version_href`` API call is correct.
* The ``_latest_version_href + content/`` API call is correct.
* The ``_latest_version_href + added_content/`` API call is correct.
* The ``_latest_version_href + removed_content/`` API call is correct.
* The ``content_summary`` attribute is correct.
"""
body = gen_remote(urljoin(FILE_FIXTURE_URL, 'PULP_MANIFEST'))
self.remote.update(self.client.post(FILE_REMOTE_PATH, body))
sync(self.cfg, self.remote, self.repo)
repo = self.client.get(self.repo['_href'])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 1, repo_versions)
self.assertIsNotNone(repo['_latest_version_href'])
content = get_content(repo)
self.assertEqual(len(content), FILE_FIXTURE_COUNT)
added_content = get_added_content(repo)
self.assertEqual(len(added_content), FILE_FIXTURE_COUNT, added_content)
removed_content = get_removed_content(repo)
self.assertEqual(len(removed_content), 0, removed_content)
content_summary = self.get_content_summary(repo)
self.assertEqual(content_summary, {'file': FILE_FIXTURE_COUNT})
def test_all(self):
"""Sync two fixture content with same NEVRA and different checksum.
Make sure we end up with the most recently synced content.
Do the following:
1. Create a repository
2. Create two remotes with same content but different checksums.
Sync the remotes one after the other.
a. Sync remote with packages with SHA256: ``RPM_UNSIGNED_FIXTURE_URL``.
b. Sync remote with packages with SHA512: ``RPM_SHA512_FIXTURE_URL``.
3. Make sure the latest content is only kept.
This test targets the following issues:
* `Pulp #4297 <https://pulp.plan.io/issues/4297>`_
* `Pulp #3954 <https://pulp.plan.io/issues/3954>`_
"""
# Step 1
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
# Step 2.
for body in [
gen_rpm_remote(),
gen_rpm_remote(url=RPM_SHA512_FIXTURE_URL)
]:
remote = self.client.post(RPM_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote['_href'])
# Sync the repository.
sync(self.cfg, remote, repo)
# Step 3
repo = self.client.get(repo['_href'])
added_content = get_content(repo)[RPM_PACKAGE_CONTENT_NAME]
removed_content = get_removed_content(repo)[RPM_PACKAGE_CONTENT_NAME]
# In case of "duplicates" the most recent one is chosen, so the old
# package is removed from and the new one is added to a repo version.
self.assertEqual(
len(added_content),
RPM_PACKAGES_COUNT,
added_content
)
self.assertEqual(
len(removed_content),
RPM_PACKAGES_COUNT,
removed_content
)
# Verifying whether the packages with first checksum is removed and second
# is added.
self.assertEqual(added_content[0]['checksum_type'], 'sha512')
self.assertEqual(removed_content[0]['checksum_type'], 'sha256')
def test_clear_all_units(self):
"""Test clear all units of a given repository version."""
added_content = sorted([
content['pulp_href']
for content in get_content(self.repo)[FILE_CONTENT_NAME]
])
self.client.post(self.repo['versions_href'],
{'remove_content_units': ['*']})
self.repo = self.client.get(self.repo['pulp_href'])
removed_content = sorted([
content['pulp_href']
for content in get_removed_content(self.repo)[FILE_CONTENT_NAME]
])
self.assertEqual(added_content, removed_content)
content = get_content(self.repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content), 0, content)
def test_clear_all_units(self):
"""Test clear all units of a given repository version."""
added_content = sorted([
content["pulp_href"]
for content in get_content(self.repo)[FILE_CONTENT_NAME]
])
modify_repo(self.cfg, self.repo, remove_units=["*"])
self.repo = self.client.get(self.repo["pulp_href"])
removed_content = sorted([
content["pulp_href"]
for content in get_removed_content(self.repo)[FILE_CONTENT_NAME]
])
self.assertEqual(added_content, removed_content)
content = get_content(self.repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content), 0, content)
def test_sync_diff_checksum_packages(self):
"""Sync two fixture content with same NEVRA and different checksum.
Make sure we end up with the most recently synced content.
Do the following:
1. Create two remotes with same content but different checksums.
Sync the remotes one after the other.
a. Sync remote with packages with SHA256: ``RPM_UNSIGNED_FIXTURE_URL``.
b. Sync remote with packages with SHA512: ``RPM_SHA512_FIXTURE_URL``.
2. Make sure the latest content is only kept.
This test targets the following issues:
* `Pulp #4297 <https://pulp.plan.io/issues/4297>`_
* `Pulp #3954 <https://pulp.plan.io/issues/3954>`_
"""
body = gen_rpm_remote(RPM_UNSIGNED_FIXTURE_URL)
remote = self.remote_api.create(body)
# sync with SHA256
repo, remote = self.do_test(remote=remote)
body = gen_rpm_remote(RPM_SHA512_FIXTURE_URL)
remote = self.remote_api.create(body)
# re-sync with SHA512
repo, remote = self.do_test(repo, remote)
# add resources to clean up
self.addCleanup(self.repo_api.delete, repo.pulp_href)
self.addCleanup(self.remote_api.delete, remote.pulp_href)
added_content = get_content(repo.to_dict())[RPM_PACKAGE_CONTENT_NAME]
removed_content = get_removed_content(
repo.to_dict())[RPM_PACKAGE_CONTENT_NAME]
# In case of "duplicates" the most recent one is chosen, so the old
# package is removed from and the new one is added to a repo version.
self.assertEqual(len(added_content), RPM_PACKAGE_COUNT)
self.assertEqual(len(removed_content), RPM_PACKAGE_COUNT)
# Verifying whether the packages with first checksum is removed and second
# is added.
self.assertEqual(added_content[0]['checksum_type'], 'sha512')
self.assertEqual(removed_content[0]['checksum_type'], 'sha256')
def test_02_sync_content(self):
"""Sync content into the repository.
Assert that:
* The ``versions_href`` API call is correct.
* The ``latest_version_href`` API call is correct.
* The ``content_hrefs`` attribute is correct.
* The ``content_added_hrefs`` attribute is correct.
* The ``content_removed_hrefs`` attribute is correct.
* The ``content_summary`` attribute is correct.
* The ``content_added_summary`` attribute is correct.
* The ``content_removed_summary`` attribute is correct.
"""
body = gen_file_remote()
self.remote.update(self.client.post(FILE_REMOTE_PATH, body))
sync(self.cfg, self.remote, self.repo)
repo = self.client.get(self.repo['pulp_href'])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 2, repo_versions)
self.assertIsNotNone(repo['latest_version_href'])
content_hrefs = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(
len(content_hrefs), FILE_FIXTURE_COUNT, content_hrefs
)
content = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content), FILE_FIXTURE_COUNT)
content_added = get_added_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content_added), FILE_FIXTURE_COUNT)
content_removed = get_removed_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content_removed), 0)
content_summary = get_content_summary(repo)
self.assertDictEqual(content_summary, FILE_FIXTURE_SUMMARY)
content_added_summary = get_added_content_summary(repo)
self.assertDictEqual(content_added_summary, FILE_FIXTURE_SUMMARY)
content_removed_summary = get_removed_content_summary(repo)
self.assertDictEqual(content_removed_summary, {})
def test_02_sync_content(self):
"""Sync content into the repository.
Assert that:
* The ``_versions_href`` API call is correct.
* The ``_latest_version_href`` API call is correct.
* The ``content_hrefs`` attribute is correct.
* The ``content_added_hrefs`` attribute is correct.
* The ``content_removed_hrefs`` attribute is correct.
* The ``content_summary`` attribute is correct.
* The ``content_added_summary`` attribute is correct.
* The ``content_removed_summary`` attribute is correct.
"""
body = gen_file_remote()
self.remote.update(self.client.post(FILE_REMOTE_PATH, body))
sync(self.cfg, self.remote, self.repo)
repo = self.client.get(self.repo['_href'])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 1, repo_versions)
self.assertIsNotNone(repo['_latest_version_href'])
content_hrefs = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(
len(content_hrefs), FILE_FIXTURE_COUNT, content_hrefs
)
content = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content), FILE_FIXTURE_COUNT)
content_added = get_added_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content_added), FILE_FIXTURE_COUNT)
content_removed = get_removed_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content_removed), 0)
content_summary = get_content_summary(repo)
self.assertDictEqual(content_summary, FILE_FIXTURE_SUMMARY)
content_added_summary = get_added_content_summary(repo)
self.assertDictEqual(content_added_summary, FILE_FIXTURE_SUMMARY)
content_removed_summary = get_removed_content_summary(repo)
self.assertDictEqual(content_removed_summary, {})
def test_sync_merge_advisories(self):
"""Sync two advisories with same ID, version and different pkglist.
Test if two advisories are merged.
"""
body = gen_rpm_remote(RPM_UNSIGNED_FIXTURE_URL)
remote = self.remote_api.create(body)
# sync
repo, remote = self.do_test(remote=remote)
# add remote to clean up
self.addCleanup(self.remote_api.delete, remote.pulp_href)
body = gen_rpm_remote(RPM_ADVISORY_DIFFERENT_PKGLIST_URL)
remote = self.remote_api.create(body)
# re-sync
repo, remote = self.do_test(repo, remote)
# add resources to clean up
self.addCleanup(self.repo_api.delete, repo.pulp_href)
self.addCleanup(self.remote_api.delete, remote.pulp_href)
# check advisories were merged
added_advisories = get_added_content(repo.to_dict())[PULP_TYPE_ADVISORY]
added_advisory_pkglist = [
advisory["pkglist"]
for advisory in added_advisories
if advisory["id"] == RPM_ADVISORY_TEST_ID
]
removed_advisories = get_removed_content(repo.to_dict())[PULP_TYPE_ADVISORY]
removed_advisory_pkglist = [
advisory["pkglist"]
for advisory in removed_advisories
if advisory["id"] == RPM_ADVISORY_TEST_ID
]
added_count = 0
removed_count = 0
for collection in added_advisory_pkglist[0]:
added_count += len(collection["packages"])
for collection in removed_advisory_pkglist[0]:
removed_count += len(collection["packages"])
self.assertEqual(RPM_ADVISORY_TEST_REMOVE_COUNT, removed_count)
self.assertEqual(RPM_ADVISORY_TEST_ADDED_COUNT, added_count)
def test_sync_advisory_new_version(self):
"""Sync a repository and re-sync with newer version of Advisory.
Test if advisory with same ID and pkglist, but newer version is updated.
`Pulp #4142 <https://pulp.plan.io/issues/4142>`_
1. Sync rpm-unsigned repository
2. Re-sync rpm-advisory-updateversion
3. Check if the newer version advisory was synced
"""
body = gen_rpm_remote(RPM_UNSIGNED_FIXTURE_URL)
remote = self.remote_api.create(body)
# sync
repo, remote = self.do_test(remote=remote)
# add remote to clean up
self.addCleanup(self.remote_api.delete, remote.pulp_href)
body = gen_rpm_remote(RPM_ADVISORY_UPDATED_VERSION_URL)
remote = self.remote_api.create(body)
# re-sync
repo, remote = self.do_test(repo, remote)
# add resources to clean up
self.addCleanup(self.repo_api.delete, repo.pulp_href)
self.addCleanup(self.remote_api.delete, remote.pulp_href)
# check if newer version advisory was added and older removed
added_advisories = get_added_content(repo.to_dict())[PULP_TYPE_ADVISORY]
added_advisory = [
advisory["version"]
for advisory in added_advisories
if advisory["id"] == RPM_ADVISORY_TEST_ID
]
removed_advisories = get_removed_content(repo.to_dict())[PULP_TYPE_ADVISORY]
removed_advisory = [
advisory["version"]
for advisory in removed_advisories
if advisory["id"] == RPM_ADVISORY_TEST_ID
]
self.assertGreater(int(added_advisory[0]), int(removed_advisory[0]))
def test_03_remove_content(self):
"""Remove content from the repository.
Make roughly the same assertions as :meth:`test_02_sync_content`.
"""
repo = self.client.get(self.repo['_href'])
self.content.update(choice(get_content(repo)[FILE_CONTENT_NAME]))
self.client.post(
repo['_versions_href'],
{'remove_content_units': [self.content['_href']]}
)
repo = self.client.get(self.repo['_href'])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 2, repo_versions)
self.assertIsNotNone(repo['_latest_version_href'])
content_hrefs = get_content(repo)['pulp_file.file']
self.assertEqual(
len(content_hrefs), FILE_FIXTURE_COUNT - 1, content_hrefs
)
content = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content), FILE_FIXTURE_COUNT - 1)
added_content = get_added_content(repo)[FILE_CONTENT_NAME]
self.assertListEqual(added_content, [], added_content)
removed_content = get_removed_content(repo)[FILE_CONTENT_NAME]
self.assertListEqual(removed_content, [self.content], removed_content)
content_summary = get_content_summary(repo)
self.assertDictEqual(
content_summary, {FILE_CONTENT_NAME: FILE_FIXTURE_COUNT - 1}
)
content_added_summary = get_added_content_summary(repo)
self.assertDictEqual(content_added_summary, {})
content_removed_summary = get_removed_content_summary(repo)
self.assertDictEqual(content_removed_summary, {FILE_CONTENT_NAME: 1})
def test_03_remove_content(self):
"""Remove content from the repository.
Make roughly the same assertions as :meth:`test_02_sync_content`.
"""
repo = self.client.get(self.repo['_href'])
self.content.update(choice(get_content(repo)[FILE_CONTENT_NAME]))
self.client.post(
repo['_versions_href'],
{'remove_content_units': [self.content['_href']]}
)
repo = self.client.get(self.repo['_href'])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 2, repo_versions)
self.assertIsNotNone(repo['_latest_version_href'])
content_hrefs = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(
len(content_hrefs), FILE_FIXTURE_COUNT - 1, content_hrefs
)
content = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content), FILE_FIXTURE_COUNT - 1)
added_content = get_added_content(repo)[FILE_CONTENT_NAME]
self.assertListEqual(added_content, [], added_content)
removed_content = get_removed_content(repo)[FILE_CONTENT_NAME]
self.assertListEqual(removed_content, [self.content], removed_content)
content_summary = get_content_summary(repo)
self.assertDictEqual(
content_summary, {FILE_CONTENT_NAME: FILE_FIXTURE_COUNT - 1}
)
content_added_summary = get_added_content_summary(repo)
self.assertDictEqual(content_added_summary, {})
content_removed_summary = get_removed_content_summary(repo)
self.assertDictEqual(content_removed_summary, {FILE_CONTENT_NAME: 1})
def test_sync_advisory_no_updated_date(self):
"""Test sync advisory with no update.
1. Sync repository with advisory which has updated_date
2. Re-sync with repo with same id and version as previous
but missing updated_date (issued_date should be used instead).
"""
body = gen_rpm_remote(RPM_UNSIGNED_FIXTURE_URL)
remote = self.remote_api.create(body)
# sync
repo, remote = self.do_test(remote=remote)
# add remote to clean up
self.addCleanup(self.remote_api.delete, remote.pulp_href)
body = gen_rpm_remote(RPM_ADVISORY_NO_DATES)
remote = self.remote_api.create(body)
# re-sync
repo, remote = self.do_test(repo, remote)
# add resources to clean up
self.addCleanup(self.repo_api.delete, repo.pulp_href)
self.addCleanup(self.remote_api.delete, remote.pulp_href)
added_advisory_date = [
advisory['updated_date']
for advisory in get_added_content(repo.to_dict())[PULP_TYPE_ADVISORY]
if RPM_ADVISORY_TEST_ID in advisory['id']
]
removed_advisory_date = [
advisory['issued_date']
for advisory in get_removed_content(repo.to_dict())[PULP_TYPE_ADVISORY]
if RPM_ADVISORY_TEST_ID in advisory['id']
]
self.assertGreater(
parse_datetime(added_advisory_date[0]),
parse_datetime(removed_advisory_date[0])
)
def test_04_add_content(self):
"""Add content to the repository.
Make roughly the same assertions as :meth:`test_02_sync_content`.
"""
repo = self.client.get(self.repo['_href'])
self.client.post(
repo['_versions_href'],
{'add_content_units': [self.content['_href']]}
)
repo = self.client.get(self.repo['_href'])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 3, repo_versions)
self.assertIsNotNone(repo['_latest_version_href'])
content_hrefs = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(
len(content_hrefs), FILE_FIXTURE_COUNT, content_hrefs
)
content = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content), FILE_FIXTURE_COUNT)
added_content = get_added_content(repo)[FILE_CONTENT_NAME]
self.assertListEqual(added_content, [self.content], added_content)
removed_content = get_removed_content(repo)[FILE_CONTENT_NAME]
self.assertListEqual(removed_content, [], removed_content)
content_summary = get_content_summary(repo)
self.assertDictEqual(content_summary, FILE_FIXTURE_SUMMARY)
content_added_summary = get_added_content_summary(repo)
self.assertDictEqual(content_added_summary, {FILE_CONTENT_NAME: 1})
content_removed_summary = get_removed_content_summary(repo)
self.assertDictEqual(content_removed_summary, {})
def test_03_remove_content(self):
"""Remove content from the repository.
Make roughly the same assertions as :meth:`test_02_sync_content`.
"""
repo = self.client.get(self.repo["pulp_href"])
self.content.update(choice(get_content(repo)[FILE_CONTENT_NAME]))
modify_repo(self.cfg, self.repo, remove_units=[self.content])
repo = self.client.get(self.repo["pulp_href"])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 3, repo_versions)
self.assertIsNotNone(repo["latest_version_href"])
content_hrefs = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content_hrefs), FILE_FIXTURE_COUNT - 1,
content_hrefs)
content = get_content(repo)[FILE_CONTENT_NAME]
self.assertEqual(len(content), FILE_FIXTURE_COUNT - 1)
added_content = get_added_content(repo)[FILE_CONTENT_NAME]
self.assertListEqual(added_content, [], added_content)
removed_content = get_removed_content(repo)[FILE_CONTENT_NAME]
self.assertListEqual(removed_content, [self.content], removed_content)
content_summary = get_content_summary(repo)
self.assertDictEqual(content_summary,
{FILE_CONTENT_NAME: FILE_FIXTURE_COUNT - 1})
content_added_summary = get_added_content_summary(repo)
self.assertDictEqual(content_added_summary, {})
content_removed_summary = get_removed_content_summary(repo)
self.assertDictEqual(content_removed_summary, {FILE_CONTENT_NAME: 1})
def test_03_removing_units(self):
"""
Sync a Remote, excluding prereleases again.
Just to be sure that the units are being properly removed afterwards.
Do the following:
1. Update the remote to exclude pre-releases again.
2. Sync the remote again.
3. Assert that we're back to the state in test_01_excluding_prereleases.
"""
body = {'prereleases': False}
self.client.patch(self.remote['_href'], body)
type(self).remote = self.client.get(self.remote['_href'])
sync(self.cfg, self.remote, self.repo)
type(self).repo = self.client.get(self.repo['_href'])
self.assertEqual(len(get_content(self.repo)), PYTHON_WITHOUT_PRERELEASE_COUNT)
self.assertEqual(len(get_removed_content(self.repo)),
PYTHON_WITH_PRERELEASE_COUNT - PYTHON_WITHOUT_PRERELEASE_COUNT)
def test_sync_advisory_updated_update_date(self):
"""Test sync advisory with updated update_date."""
body = gen_rpm_remote(RPM_UNSIGNED_FIXTURE_URL)
remote = self.remote_api.create(body)
# sync
repo, remote = self.do_test(remote=remote)
# add remote to clean up
self.addCleanup(self.remote_api.delete, remote.pulp_href)
body = gen_rpm_remote(RPM_UPDATED_UPDATEINFO_FIXTURE_URL)
remote = self.remote_api.create(body)
# re-sync
repo, remote = self.do_test(repo, remote)
# add resources to clean up
self.addCleanup(self.repo_api.delete, repo.pulp_href)
self.addCleanup(self.remote_api.delete, remote.pulp_href)
added_advisory_date = [
advisory['updated_date']
for advisory in get_added_content(repo.to_dict())[PULP_TYPE_ADVISORY]
if RPM_ADVISORY_TEST_ID_NEW in advisory['id']
]
removed_advisory_date = [
advisory['updated_date']
for advisory in get_removed_content(repo.to_dict())[PULP_TYPE_ADVISORY]
if RPM_ADVISORY_TEST_ID_NEW in advisory['id']
]
self.assertGreater(
parse_datetime(added_advisory_date[0]),
parse_datetime(removed_advisory_date[0])
)
def verify_counts(self, repo, all_count, added_count, removed_count):
self.assertEqual(len(get_content(repo)), all_count)
self.assertEqual(len(get_added_content(repo)), added_count)
self.assertEqual(len(get_removed_content(repo)), removed_count)
def test_all(self):
"""Sync two copies of the same UpdateRecords.
Make sure we end up with only one copy.
Do the following:
1. Create a repository and a remote.
2. Sync the remote.
3. Assert that the content summary matches what is expected.
4. Create a new remote w/ using fixture containing updated advisory
(updaterecords with the ID as the existing updaterecord content, but
different metadata).
5. Sync the remote again.
6. Assert that repository version is different from the previous one
but has the same content summary.
7. Assert that the updaterecords have changed since the last sync.
"""
client = api.Client(self.cfg, api.json_handler)
repo = client.post(RPM_REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['pulp_href'])
# Create a remote with the unsigned RPM fixture url.
# We need to use the unsigned fixture because the one used down below
# has unsigned RPMs. Signed and unsigned units have different hashes,
# so they're seen as different units.
body = gen_rpm_remote(url=RPM_UNSIGNED_FIXTURE_URL)
remote = client.post(RPM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['pulp_href'])
# Sync the repository.
self.assertEqual(repo["latest_version_href"],
f"{repo['pulp_href']}versions/0/")
sync(self.cfg, remote, repo)
repo = client.get(repo['pulp_href'])
self.assertDictEqual(get_content_summary(repo), RPM_FIXTURE_SUMMARY)
# Save a copy of the original updateinfo
original_updaterecords = {
content['id']: content
for content in get_content(repo)[RPM_ADVISORY_CONTENT_NAME]
}
# Create a remote with a different test fixture, one containing mutated
# updateinfo.
body = gen_rpm_remote(url=RPM_UPDATED_UPDATEINFO_FIXTURE_URL)
remote = client.post(RPM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['pulp_href'])
# Sync the repository again.
sync(self.cfg, remote, repo)
repo = client.get(repo['pulp_href'])
self.assertDictEqual(get_content_summary(repo), RPM_FIXTURE_SUMMARY)
self.assertEqual(
len(get_added_content(repo)[RPM_ADVISORY_CONTENT_NAME]), 4)
self.assertEqual(
len(get_removed_content(repo)[RPM_ADVISORY_CONTENT_NAME]), 4)
# Test that the updateinfo have been modified.
mutated_updaterecords = {
content['id']: content
for content in get_content(repo)[RPM_ADVISORY_CONTENT_NAME]
}
self.assertNotEqual(mutated_updaterecords, original_updaterecords)
self.assertEqual(
mutated_updaterecords[RPM_UPDATERECORD_ID]['description'],
'Updated Gorilla_Erratum and the updated date contains timezone',
mutated_updaterecords[RPM_UPDATERECORD_ID],
)
def test_all(self):
"""Sync two copies of the same packages.
Make sure we end up with only one copy.
Do the following:
1. Create a repository and a remote.
2. Sync the remote.
3. Assert that the content summary matches what is expected.
4. Create a new remote w/ using fixture containing updated advisory
(packages with the same NEVRA as the existing package content, but
different pkgId).
5. Sync the remote again.
6. Assert that repository version is different from the previous one
but has the same content summary.
7. Assert that the packages have changed since the last sync.
"""
repo = self.client.post(RPM_REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['pulp_href'])
# Create a remote with the unsigned RPM fixture url.
body = gen_rpm_remote(url=RPM_UNSIGNED_FIXTURE_URL)
remote = self.client.post(RPM_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote['pulp_href'])
# Sync the repository.
self.assertEqual(repo["latest_version_href"],
f"{repo['pulp_href']}versions/0/")
sync(self.cfg, remote, repo)
repo = self.client.get(repo['pulp_href'])
self.assertDictEqual(get_content_summary(repo), RPM_FIXTURE_SUMMARY)
# Save a copy of the original packages.
original_packages = {
(
content['name'],
content['epoch'],
content['version'],
content['release'],
content['arch'],
): content
for content in get_content(repo)[RPM_PACKAGE_CONTENT_NAME]
}
# Create a remote with a different test fixture with the same NEVRA but
# different digests.
body = gen_rpm_remote(url=RPM_SIGNED_FIXTURE_URL)
remote = self.client.post(RPM_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote['pulp_href'])
# Sync the repository again.
sync(self.cfg, remote, repo)
repo = self.client.get(repo['pulp_href'])
self.assertDictEqual(get_content_summary(repo), RPM_FIXTURE_SUMMARY)
# In case of "duplicates" the most recent one is chosen, so the old
# package is removed from and the new one is added to a repo version.
self.assertEqual(
len(get_added_content(repo)[RPM_PACKAGE_CONTENT_NAME]),
RPM_PACKAGE_COUNT,
get_added_content(repo)[RPM_PACKAGE_CONTENT_NAME],
)
self.assertEqual(
len(get_removed_content(repo)[RPM_PACKAGE_CONTENT_NAME]),
RPM_PACKAGE_COUNT,
get_removed_content(repo)[RPM_PACKAGE_CONTENT_NAME],
)
# Test that the packages have been modified.
mutated_packages = {
(
content['name'],
content['epoch'],
content['version'],
content['release'],
content['arch'],
): content
for content in get_content(repo)[RPM_PACKAGE_CONTENT_NAME]
}
for nevra in original_packages:
with self.subTest(pkg=nevra):
self.assertNotEqual(
original_packages[nevra]['pkgId'],
mutated_packages[nevra]['pkgId'],
original_packages[nevra]['pkgId'],
)
def test_all(self):
"""Sync two copies of the same packages.
Make sure we end up with only one copy.
Do the following:
1. Create a repository and a remote.
2. Sync the remote.
3. Assert that the content summary matches what is expected.
4. Create a new remote w/ using fixture containing updated errata
(packages with the same NEVRA as the existing package content, but
different pkgId).
5. Sync the remote again.
6. Assert that repository version is different from the previous one
but has the same content summary.
7. Assert that the packages have changed since the last sync.
"""
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
# Create a remote with the unsigned RPM fixture url.
body = gen_rpm_remote(url=RPM_UNSIGNED_FIXTURE_URL)
remote = self.client.post(RPM_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote['_href'])
# Sync the repository.
self.assertIsNone(repo['_latest_version_href'])
sync(self.cfg, remote, repo)
repo = self.client.get(repo['_href'])
self.assertDictEqual(
get_content_summary(repo),
RPM_FIXTURE_SUMMARY
)
# Save a copy of the original packages.
original_packages = {
(content['name'],
content['epoch'],
content['version'],
content['release'],
content['arch']): content
for content in get_content(repo)[RPM_PACKAGE_CONTENT_NAME]
}
# Create a remote with a different test fixture with the same NEVRA but
# different digests.
body = gen_rpm_remote(url=RPM_SIGNED_FIXTURE_URL)
remote = self.client.post(RPM_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote['_href'])
# Sync the repository again.
sync(self.cfg, remote, repo)
repo = self.client.get(repo['_href'])
self.assertDictEqual(
get_content_summary(repo),
RPM_FIXTURE_SUMMARY
)
# In case of "duplicates" the most recent one is chosen, so the old
# package is removed from and the new one is added to a repo version.
self.assertEqual(
len(get_added_content(repo)[RPM_PACKAGE_CONTENT_NAME]),
RPM_PACKAGES_COUNT,
get_added_content(repo)[RPM_PACKAGE_CONTENT_NAME]
)
self.assertEqual(
len(get_removed_content(repo)[RPM_PACKAGE_CONTENT_NAME]),
RPM_PACKAGES_COUNT,
get_removed_content(repo)[RPM_PACKAGE_CONTENT_NAME]
)
# Test that the packages have been modified.
mutated_packages = {
(content['name'],
content['epoch'],
content['version'],
content['release'],
content['arch']): content
for content in get_content(repo)[RPM_PACKAGE_CONTENT_NAME]
}
for nevra in original_packages:
with self.subTest(pkg=nevra):
self.assertNotEqual(
original_packages[nevra]['pkgId'],
mutated_packages[nevra]['pkgId'],
original_packages[nevra]['pkgId']
)
def test_all(self):
"""Sync two copies of the same UpdateRecords.
Make sure we end up with only one copy.
Do the following:
1. Create a repository and a remote.
2. Sync the remote.
3. Assert that the content summary matches what is expected.
4. Create a new remote w/ using fixture containing updated errata
(updaterecords with the ID as the existing updaterecord content, but
different metadata).
5. Sync the remote again.
6. Assert that repository version is different from the previous one
but has the same content summary.
7. Assert that the updaterecords have changed since the last sync.
"""
client = api.Client(self.cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
# Create a remote with the unsigned RPM fixture url.
# We need to use the unsigned fixture because the one used down below
# has unsigned RPMs. Signed and unsigned units have different hashes,
# so they're seen as different units.
body = gen_rpm_remote(url=RPM_UNSIGNED_FIXTURE_URL)
remote = client.post(RPM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
# Sync the repository.
self.assertIsNone(repo['_latest_version_href'])
sync(self.cfg, remote, repo)
repo = client.get(repo['_href'])
self.assertDictEqual(
get_content_summary(repo),
RPM_FIXTURE_SUMMARY
)
# Save a copy of the original updateinfo
original_updaterecords = {
content['id']: content
for content in get_content(repo)[RPM_UPDATE_CONTENT_NAME]
}
# Create a remote with a different test fixture, one containing mutated
# updateinfo.
body = gen_rpm_remote(url=RPM_UPDATED_UPDATEINFO_FIXTURE_URL)
remote = client.post(RPM_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
# Sync the repository again.
sync(self.cfg, remote, repo)
repo = client.get(repo['_href'])
self.assertDictEqual(
get_content_summary(repo),
RPM_FIXTURE_SUMMARY
)
self.assertEqual(
len(get_added_content(repo)[RPM_UPDATE_CONTENT_NAME]),
4
)
self.assertEqual(
len(get_removed_content(repo)[RPM_UPDATE_CONTENT_NAME]),
4
)
# Test that the updateinfo have been modified.
mutated_updaterecords = {
content['id']: content
for content in get_content(repo)[RPM_UPDATE_CONTENT_NAME]
}
self.assertNotEqual(mutated_updaterecords, original_updaterecords)
self.assertEqual(
mutated_updaterecords[RPM_UPDATERECORD_ID]['description'],
'Updated Gorilla_Erratum and the updated date contains timezone',
mutated_updaterecords[RPM_UPDATERECORD_ID]
)
def test_mutated_advisory_metadata(self):
"""Sync two copies of the same Advisory (only description is updated).
Make sure we end up with only one copy.
Do the following:
1. Create a repository and a remote.
2. Sync the remote.
3. Assert that the content summary matches what is expected.
4. Create a new remote w/ using fixture containing updated advisory
(updaterecords with the ID as the existing updaterecord content, but
different metadata).
5. Sync the remote again.
6. Assert that repository version is different from the previous one
but has the same content summary.
7. Assert that the updaterecords have changed since the last sync.
"""
# Create a remote with the unsigned RPM fixture url.
# We need to use the unsigned fixture because the one used down below
# has unsigned RPMs. Signed and unsigned units have different hashes,
# so they're seen as different units.
body = gen_rpm_remote(RPM_UNSIGNED_FIXTURE_URL)
remote = self.remote_api.create(body)
# sync
repo, remote = self.do_test(remote=remote)
# add resources to clean up
self.addCleanup(self.repo_api.delete, repo.pulp_href)
self.addCleanup(self.remote_api.delete, remote.pulp_href)
# check if sync OK
self.assertDictEqual(get_content_summary(repo.to_dict()), RPM_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo.to_dict()), RPM_FIXTURE_SUMMARY)
original_updaterecords = {
content["id"]: content
for content in get_content(repo.to_dict())[RPM_ADVISORY_CONTENT_NAME]
}
body = gen_rpm_remote(RPM_UPDATED_UPDATEINFO_FIXTURE_URL)
remote = self.remote_api.create(body)
# sync the repository again
repo, remote = self.do_test(repo, remote)
# add the second remote to clean up
self.addCleanup(self.remote_api.delete, remote.pulp_href)
self.assertDictEqual(get_content_summary(repo.to_dict()), RPM_FIXTURE_SUMMARY)
self.assertEqual(len(get_added_content(repo.to_dict())[RPM_ADVISORY_CONTENT_NAME]), 4)
self.assertEqual(len(get_removed_content(repo.to_dict())[RPM_ADVISORY_CONTENT_NAME]), 4)
# Test that the updateinfo have been modified.
mutated_updaterecords = {
content["id"]: content
for content in get_content(repo.to_dict())[RPM_ADVISORY_CONTENT_NAME]
}
self.assertNotEqual(mutated_updaterecords, original_updaterecords)
self.assertEqual(
mutated_updaterecords[RPM_ADVISORY_TEST_ID_NEW]["description"],
"Updated Gorilla_Erratum and the updated date contains timezone",
mutated_updaterecords[RPM_ADVISORY_TEST_ID_NEW],
)
def test_mutated_packages(self):
"""Sync two copies of the same packages.
Make sure we end up with only one copy.
Do the following:
1. Sync.
3. Assert that the content summary matches what is expected.
4. Create a new remote w/ using fixture containing updated advisory
(packages with the same NEVRA as the existing package content, but
different pkgId).
5. Sync the remote again.
6. Assert that repository version is different from the previous one
but has the same content summary.
7. Assert that the packages have changed since the last sync.
"""
body = gen_rpm_remote(RPM_UNSIGNED_FIXTURE_URL)
remote = self.remote_api.create(body)
# sync
repo, remote = self.do_test(remote=remote)
# add resources to clean up
self.addCleanup(self.repo_api.delete, repo.pulp_href)
self.addCleanup(self.remote_api.delete, remote.pulp_href)
# check if sync OK
self.assertDictEqual(get_content_summary(repo.to_dict()), RPM_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo.to_dict()), RPM_FIXTURE_SUMMARY)
# Save a copy of the original packages.
original_packages = {
(
content["name"],
content["epoch"],
content["version"],
content["release"],
content["arch"],
): content
for content in get_content(repo.to_dict())[RPM_PACKAGE_CONTENT_NAME]
}
# Create a remote with a different test fixture with the same NEVRA but
# different digests.
body = gen_rpm_remote(RPM_SIGNED_FIXTURE_URL)
remote = self.remote_api.create(body)
# sync again
repo, remote = self.do_test(repo, remote)
# In case of "duplicates" the most recent one is chosen, so the old
# package is removed from and the new one is added to a repo version.
self.assertEqual(
len(get_added_content(repo.to_dict())[RPM_PACKAGE_CONTENT_NAME]),
RPM_PACKAGE_COUNT,
get_added_content(repo.to_dict())[RPM_PACKAGE_CONTENT_NAME],
)
self.assertEqual(
len(get_removed_content(repo.to_dict())[RPM_PACKAGE_CONTENT_NAME]),
RPM_PACKAGE_COUNT,
get_removed_content(repo.to_dict())[RPM_PACKAGE_CONTENT_NAME],
)
# Test that the packages have been modified.
mutated_packages = {
(
content["name"],
content["epoch"],
content["version"],
content["release"],
content["arch"],
): content
for content in get_content(repo.to_dict())[RPM_PACKAGE_CONTENT_NAME]
}
for nevra in original_packages:
with self.subTest(pkg=nevra):
self.assertNotEqual(
original_packages[nevra]["pkgId"],
mutated_packages[nevra]["pkgId"],
original_packages[nevra]["pkgId"],
)
def test_sync_with_retention(self):
"""Verify functionality with sync.
Do the following:
1. Create a repository, and a remote.
2. Sync the remote.
3. Assert that the correct number of units were added and are present
in the repo.
4. Change the "retain_package_versions" on the repository to 1 (retain the latest
version only).
5. Sync the remote one more time.
6. Assert that repository version is different from the previous one.
7. Assert the repository version we end with has only one version of each package.
"""
delete_orphans()
repo = self.repo_api.create(gen_repo())
self.addCleanup(self.repo_api.delete, repo.pulp_href)
remote = self.remote_api.create(gen_rpm_remote(policy="on_demand"))
self.addCleanup(self.remote_api.delete, remote.pulp_href)
task = self.sync(repository=repo, remote=remote, optimize=False)
repo = self.repo_api.read(repo.pulp_href)
# Test that, by default, everything is retained / nothing is tossed out.
self.assertDictEqual(get_content_summary(repo.to_dict()),
RPM_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo.to_dict()),
RPM_FIXTURE_SUMMARY)
# Test that the # of packages processed is correct
reports = self.get_progress_reports_by_code(task)
self.assertEqual(reports["sync.parsing.packages"].total,
RPM_PACKAGE_COUNT)
# Set the retention policy to retain only 1 version of each package
repo_data = repo.to_dict()
repo_data.update({"retain_package_versions": 1})
self.repo_api.update(repo.pulp_href, repo_data)
repo = self.repo_api.read(repo.pulp_href)
task = self.sync(repository=repo, remote=remote, optimize=False)
repo = self.repo_api.read(repo.pulp_href)
# Test that only one version of each package is present
self.assertTrue(
self.check_retention_policy(
get_content(repo.to_dict())[PULP_TYPE_PACKAGE], 1))
# Test that (only) 4 RPMs were removed (no advisories etc. touched)
self.assertDictEqual(get_removed_content_summary(repo.to_dict()),
{PULP_TYPE_PACKAGE: 4})
# Test that the versions that were removed are the versions we expect.
versions_for_packages = self.versions_for_packages(
get_removed_content(repo.to_dict())[PULP_TYPE_PACKAGE])
self.assertDictEqual(
versions_for_packages,
{
"duck": ["0.6", "0.7"],
"kangaroo": ["0.2"],
"walrus": ["0.71"]
},
versions_for_packages,
)
# Test that the number of packages processed is correct (doesn't include older ones)
reports = self.get_progress_reports_by_code(task)
self.assertEqual(reports["sync.parsing.packages"].total,
RPM_PACKAGE_COUNT)
self.assertEqual(reports["sync.skipped.packages"].total, 4)
