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["pulp_href"])
modify_repo(self.cfg, self.repo, add_units=[self.content])
repo = self.client.get(self.repo["pulp_href"])
repo_versions = get_versions(repo)
self.assertEqual(len(repo_versions), 4, 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_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, mirror=True)
type(self).repo = self.client.get(self.repo['_href'])
self.assertDictEqual(
get_content_summary(self.repo),
PYTHON_WITHOUT_PRERELEASE_FIXTURE_SUMMARY
)
self.assertEqual(
get_removed_content_summary(self.repo)[PYTHON_CONTENT_NAME],
PYTHON_WITH_PRERELEASE_COUNT - PYTHON_WITHOUT_PRERELEASE_COUNT
)
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}
sync_to_remote(self, body, mirror=True)
self.assertDictEqual(
get_content_summary(self.repo.to_dict()),
PYTHON_WITHOUT_PRERELEASE_FIXTURE_SUMMARY,
)
self.assertEqual(
get_removed_content_summary(
self.repo.to_dict())[PYTHON_CONTENT_NAME],
PYTHON_WITH_PRERELEASE_COUNT - PYTHON_WITHOUT_PRERELEASE_COUNT,
)
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, mirror=True)
type(self).repo = self.client.get(self.repo['_href'])
self.assertDictEqual(get_content_summary(self.repo),
PYTHON_WITHOUT_PRERELEASE_FIXTURE_SUMMARY)
self.assertEqual(
get_removed_content_summary(self.repo)[PYTHON_CONTENT_NAME],
PYTHON_WITH_PRERELEASE_COUNT - PYTHON_WITHOUT_PRERELEASE_COUNT)
def test_03_add_subset_exclude(self):
"""
Test that excluding a subset of the packages will reduce the count by that amount.
Do the following:
1. Update the remote to exclude a specifier that is a strict subset of the previous one.
2. Sync the remote again.
3. Assert that that the content counts in the repo decreased by the count of the
excludes specifier.
"""
body = {'excludes': PYTHON_SM_PROJECT_SPECIFIER}
self.client.patch(self.remote['_href'], body)
type(self).remote = self.client.get(self.remote['_href'])
sync(self.cfg, self.remote, self.repo, mirror=True)
type(self).repo = self.client.get(self.repo['_href'])
self.assertEqual(
get_content_summary(self.repo)[PYTHON_CONTENT_NAME],
PYTHON_MD_PACKAGE_COUNT - PYTHON_SM_PACKAGE_COUNT)
self.assertEqual(
get_removed_content_summary(self.repo)[PYTHON_CONTENT_NAME],
PYTHON_SM_PACKAGE_COUNT)
def test_03_add_subset_exclude(self):
"""
Test that excluding a subset of the packages will reduce the count by that amount.
Do the following:
1. Update the remote to exclude a specifier that is a strict subset of the previous one.
2. Sync the remote again.
3. Assert that that the content counts in the repo decreased by the count of the
excludes specifier.
"""
body = {'excludes': PYTHON_SM_PROJECT_SPECIFIER}
self.client.patch(self.remote['_href'], body)
type(self).remote = self.client.get(self.remote['_href'])
sync(self.cfg, self.remote, self.repo, mirror=True)
type(self).repo = self.client.get(self.repo['_href'])
self.assertEqual(
get_content_summary(self.repo)[PYTHON_CONTENT_NAME],
PYTHON_MD_PACKAGE_COUNT - PYTHON_SM_PACKAGE_COUNT
)
self.assertEqual(
get_removed_content_summary(self.repo)[PYTHON_CONTENT_NAME],
PYTHON_SM_PACKAGE_COUNT
)
def test_mirror_sync_with_requirements(self):
"""
Sync multiple remotes into the same repo with mirror as `True` using requirements.
This test targets the following issue: 5250
* `<https://pulp.plan.io/issues/5250>`_
This test does the following:
1. Create a repo.
2. Create two remotes
a. Role remote
b. Collection remote
3. Sync the repo with Role remote.
4. Sync the repo with Collection remote with ``Mirror=True``.
5. Verify whether the content in the latest version of the repo
has only Collection content and Role content is deleted.
"""
# Step 1
repo = self.client.post(ANSIBLE_REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo["pulp_href"])
# Step 2
role_remote = self.client.post(ANSIBLE_REMOTE_PATH,
gen_ansible_remote())
self.addCleanup(self.client.delete, role_remote["pulp_href"])
collection_remote = self.client.post(
ANSIBLE_COLLECTION_REMOTE_PATH,
gen_ansible_remote(
url=ANSIBLE_COLLECTION_TESTING_URL_V2,
requirements_file=ANSIBLE_COLLECTION_REQUIREMENT,
),
)
self.addCleanup(self.client.delete, collection_remote["pulp_href"])
# Step 3
sync(self.cfg, role_remote, repo)
repo = self.client.get(repo["pulp_href"])
self.assertIsNotNone(repo["latest_version_href"], repo)
self.assertDictEqual(get_added_content_summary(repo),
ANSIBLE_FIXTURE_CONTENT_SUMMARY)
# Step 4
sync(self.cfg, collection_remote, repo, mirror=True)
repo = self.client.get(repo["pulp_href"])
added_content_summary = get_added_content_summary(repo)
self.assertGreaterEqual(
added_content_summary[ANSIBLE_COLLECTION_CONTENT_NAME],
ANSIBLE_COLLECTION_FIXTURE_COUNT)
# Step 5
content_summary = get_content_summary(repo)
self.assertGreaterEqual(
content_summary[ANSIBLE_COLLECTION_CONTENT_NAME],
ANSIBLE_COLLECTION_FIXTURE_COUNT)
self.assertDictEqual(get_removed_content_summary(repo),
ANSIBLE_FIXTURE_CONTENT_SUMMARY)
def test_sync_with_retention_and_modules(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 the same as the previous one, because the older
versions are part of modules, and they should be ignored by the retention policy.
"""
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(
url=RPM_MODULES_STATIC_CONTEXT_FIXTURE_URL,
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)
self.addCleanup(delete_orphans) # TODO: #2587
# Test that, by default, everything is retained / nothing is tossed out.
self.assertDictEqual(get_content_summary(repo.to_dict()),
RPM_MODULAR_STATIC_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo.to_dict()),
RPM_MODULAR_STATIC_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_MODULAR_PACKAGE_COUNT)
self.assertEqual(reports["sync.skipped.packages"].total, 0)
# 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 no RPMs were removed (and no advisories etc. touched)
# it should be the same because the older version are covered by modules)
self.assertDictEqual(get_removed_content_summary(repo.to_dict()), {})
# Test that the number of packages processed is correct
reports = self.get_progress_reports_by_code(task)
self.assertEqual(reports["sync.parsing.packages"].total,
RPM_MODULAR_PACKAGE_COUNT)
self.assertEqual(reports["sync.skipped.packages"].total, 0)
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.
"""
repo = self.repo_api.create(gen_repo())
self.addCleanup(self.repo_api.delete, repo.pulp_href)
remote = self.remote_api.create(gen_rpm_remote())
self.addCleanup(self.remote_api.delete, remote.pulp_href)
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)
# 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)
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,
)
def test_mirror_sync(self):
"""Sync multiple plugin into the same repo with mirror as `True`.
This test targets the following issue: 4448
* `<https://pulp.plan.io/issues/4448>`_
This test does the following:
1. Create a repo.
2. Create two remotes
a. RPM remote
b. File remote
3. Sync the repo with RPM remote.
4. Sync the repo with File remote with ``Mirror=True``.
5. Verify whether the content in the latest version of the repo
has only File content and RPM content is deleted.
"""
# Step 1
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
# Step 2
rpm_remote = self.client.post(RPM_REMOTE_PATH,
gen_remote(url=RPM_UNSIGNED_FIXTURE_URL))
self.addCleanup(self.client.delete, rpm_remote['_href'])
file_remote = self.client.post(
FILE_REMOTE_PATH, gen_remote(url=FILE_FIXTURE_MANIFEST_URL))
self.addCleanup(self.client.delete, file_remote['_href'])
# Step 3
sync(self.cfg, rpm_remote, repo)
repo = self.client.get(repo['_href'])
self.assertIsNotNone(repo['_latest_version_href'])
self.assertDictEqual(get_added_content_summary(repo),
RPM_FIXTURE_SUMMARY)
# Step 4
sync(self.cfg, file_remote, repo, mirror=True)
repo = self.client.get(repo['_href'])
self.assertIsNotNone(repo['_latest_version_href'])
self.assertDictEqual(get_added_content_summary(repo),
FILE_FIXTURE_SUMMARY)
# Step 5
self.assertDictEqual(get_content_summary(repo), FILE_FIXTURE_SUMMARY)
self.assertDictEqual(get_removed_content_summary(repo),
RPM_FIXTURE_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['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_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_03_add_subset_exclude(self):
"""
Test that excluding a subset of the packages will reduce the count by that amount.
Do the following:
1. Update the remote to exclude a specifier that is a strict subset of the previous one.
2. Sync the remote again.
3. Assert that that the content counts in the repo decreased by the count of the
excludes specifier.
"""
body = {"excludes": PYTHON_SM_PROJECT_SPECIFIER}
sync_to_remote(self, body, mirror=True)
self.assertEqual(
get_content_summary(self.repo.to_dict())[PYTHON_CONTENT_NAME],
PYTHON_MD_PACKAGE_COUNT - PYTHON_SM_PACKAGE_COUNT,
)
self.assertEqual(
get_removed_content_summary(self.repo.to_dict())[PYTHON_CONTENT_NAME],
PYTHON_SM_PACKAGE_COUNT,
)
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})
