def setUpModule(): # pylint:disable=invalid-name
"""Conditionally skip tests. Create repositories with fixture data."""
cfg = config.get_config()
if not selectors.bug_is_fixed(1991, cfg.pulp_version):
raise unittest.SkipTest('https://pulp.plan.io/issues/1991')
set_up_module()
# Fetch RPMs.
_SIGNED_PACKAGES['rpm'] = utils.http_get(RPM_SIGNED_URL)
_SIGNED_PACKAGES['srpm'] = utils.http_get(SRPM_SIGNED_URL)
_UNSIGNED_PACKAGES['rpm'] = utils.http_get(RPM_UNSIGNED_URL)
_UNSIGNED_PACKAGES['srpm'] = utils.http_get(SRPM_UNSIGNED_URL)
if selectors.bug_is_fixed(1806, cfg.pulp_version):
_SIGNED_PACKAGES['drpm'] = utils.http_get(DRPM_SIGNED_URL)
_UNSIGNED_PACKAGES['drpm'] = utils.http_get(DRPM_UNSIGNED_URL)
# Create repos, and upload RPMs to them.
client = api.Client(cfg, api.json_handler)
try:
repo = client.post(REPOSITORY_PATH, gen_repo())
_REPOS['signed'] = repo
for type_id, pkg in _SIGNED_PACKAGES.items():
upload_import_unit(cfg, pkg, {'unit_type_id': type_id}, repo)
repo = client.post(REPOSITORY_PATH, gen_repo())
_REPOS['unsigned'] = repo
for type_id, pkg in _UNSIGNED_PACKAGES.items():
upload_import_unit(cfg, pkg, {'unit_type_id': type_id}, repo)
except: # noqa:E722
_SIGNED_PACKAGES.clear()
_UNSIGNED_PACKAGES.clear()
for _ in range(len(_REPOS)):
client.delete(_REPOS.popitem()[1]['_href'])
raise
def do_test(self, recursive, recursive_conservative):
"""Copy of units for a repository with rich/weak dependencies."""
repos = []
body = gen_repo(importer_config={'feed': RPM_RICH_WEAK_FEED_URL},
distributors=[gen_distributor()])
repos.append(self.client.post(REPOSITORY_PATH, body))
self.addCleanup(self.client.delete, repos[0]['_href'])
sync_repo(self.cfg, repos[0])
repos.append(self.client.post(REPOSITORY_PATH, gen_repo()))
self.addCleanup(self.client.delete, repos[1]['_href'])
# Pulp 2.18.1 introduced a new flag `recursive_conservative`.
# If true, units are copied together with their
# dependencies, unless those are already satisfied by the content in
# the target repository.
override_config = {'recursive': recursive}
if self.cfg.pulp_version >= Version('2.18.1'):
override_config.update(
{'recursive_conservative': recursive_conservative})
self.client.post(
urljoin(repos[1]['_href'], 'actions/associate/'), {
'source_repo_id': repos[0]['id'],
'override_config': override_config,
'criteria': {
'filters': {
'unit': {
'name': RPM2_RICH_WEAK_DATA['name']
}
},
'type_ids': ['rpm'],
},
})
return self.client.get(repos[1]['_href'], params={'details': True})
def test_all(self):
"""Test that recursive copy of erratas copies RPM packages.
This test targets the following issues:
* `Pulp Smash #769 <https://github.com/PulpQE/pulp-smash/issues/769>`_
* `Pulp #3004 <https://pulp.plan.io/issues/3004>`_
Do the following:
1. Create and sync a repository with errata, and RPM packages.
2. Create second repository.
3. Copy units from from first repository to second repository
using ``recursive`` as true, and filter ``type_id`` as
``erratum``.
4. Assert that RPM packages were copied.
"""
cfg = config.get_config()
if not selectors.bug_is_fixed(3004, cfg.pulp_version):
self.skipTest('https://pulp.plan.io/issues/3004')
repos = []
client = api.Client(cfg, api.json_handler)
body = gen_repo()
body['importer_config']['feed'] = RPM_UPDATED_INFO_FEED_URL
body['distributors'] = [gen_distributor()]
repos.append(client.post(REPOSITORY_PATH, body))
self.addCleanup(client.delete, repos[0]['_href'])
sync_repo(cfg, repos[0])
# Create a second repository.
repos.append(client.post(REPOSITORY_PATH, gen_repo()))
self.addCleanup(client.delete, repos[1]['_href'])
# Copy data to second repository.
client.post(
urljoin(repos[1]['_href'], 'actions/associate/'),
{
'source_repo_id': repos[0]['id'],
'override_config': {
'recursive': True
},
'criteria': {
'filters': {},
'type_ids': ['erratum']
},
},
)
# Assert that RPM packages were copied.
units = search_units(cfg, repos[1], {'type_ids': ['rpm']})
self.assertGreater(len(units), 0)
def test_all(self):
"""Check if Pulp only associate missing repo content."""
cfg = config.get_config()
if cfg.pulp_version < Version('2.11'):
self.skipTest(
'Selective association is available on Pulp 2.11+ see Pulp '
'#2457 for more information'
)
client = api.Client(cfg, api.json_handler)
body = gen_repo()
body['importer_config']['feed'] = RPM_UNSIGNED_FEED_URL
repo = client.post(REPOSITORY_PATH, body)
self.addCleanup(client.delete, repo['_href'])
sync_repo(cfg, repo)
rpm_units = (
_get_units_by_type(search_units(cfg, repo), 'rpm')
)
# Let's select up to 1/5 of the available units to remove
to_remove = random.sample(
rpm_units, random.randrange(int(RPM_UNSIGNED_FEED_COUNT / 4)))
for unit in to_remove:
_remove_unit(cfg, repo, unit)
report = client.post(urljoin(repo['_href'], 'actions/sync/'))
tasks = tuple(api.poll_spawned_tasks(cfg, report))
self.assertEqual(len(tasks), 1, tasks)
self.assertEqual(
tasks[0]['result']['added_count'], len(to_remove), to_remove)
def setUpClass(cls):
"""Create a repository."""
cls.cfg = config.get_config()
client = api.Client(cls.cfg)
body = gen_repo()
body['distributors'] = [gen_distributor()]
cls.repo = client.post(REPOSITORY_PATH, body).json()
def do_test(self, distributor_config_update):
"""Implement most of the test logic."""
rpms = tuple(
utils.http_get(url)
for url in (RPM_UNSIGNED_URL, RPM2_UNSIGNED_URL))
# Create a repository.
client = api.Client(self.cfg, api.json_handler)
body = gen_repo()
body['distributors'] = [gen_distributor()]
body['distributors'][0]['distributor_config'].update(
distributor_config_update)
repo = client.post(REPOSITORY_PATH, body)
self.addCleanup(client.delete, repo['_href'])
repo = client.get(repo['_href'], params={'details': True})
# Upload an RPM, publish the repo, and count metadata files twice.
cli_client = cli.Client(self.cfg)
sudo = () if cli.is_root(self.cfg) else ('sudo', )
find_repodata_cmd = sudo + (
'find',
os.path.join('/var/lib/pulp/published/yum/master/yum_distributor/',
str(repo['id'])), '-type', 'd', '-name', 'repodata')
found = []
for rpm in rpms:
upload_import_unit(self.cfg, rpm, {'unit_type_id': 'rpm'}, repo)
publish_repo(self.cfg, repo)
repodata_path = cli_client.run(find_repodata_cmd).stdout.strip()
found.append(
cli_client.run(sudo + ('find', repodata_path, '-type',
'f')).stdout.splitlines())
return found
def test_broken_simlinks(self):
"""Test broken symlinks."""
client = api.Client(self.cfg, api.json_handler)
body = gen_repo(
importer_config={'feed': RPM_YUM_METADATA_FILE},
distributors=[gen_distributor(auto_publish=True)]
)
repo = client.post(REPOSITORY_PATH, body)
self.addCleanup(client.delete, repo['_href'])
sync_repo(self.cfg, repo)
repo = client.get(repo['_href'], params={'details': True})
# Assert that there is a yum_repo_metadata file present in the repo.
self.assertEqual(
repo['content_unit_counts']['yum_repo_metadata_file'],
1,
repo
)
path = os.path.join(
'/var/lib/pulp/published/yum/https/repos/',
repo['distributors'][0]['config']['relative_url'],
'repodata'
)
# Assert that the productid was not saved as symlink
productid_symlink = self.find_productid(True, path)
self.assertEqual(len(productid_symlink), 0, productid_symlink)
# Assert that the productid was saved as a file
productid_file = self.find_productid(False, path)
self.assertEqual(len(productid_file), 1, productid_symlink)
def test_missing_filelists_error_message(self):
"""Test whether an error report contains sufficient information.
Do the following:
1. Create and sync a repository using a missing filelist feed URL.
2. Get a reference to the task containing error information.
3. Assert that:
* The error description is sufficiently verbose. See `Pulp #4262`_
* The traceback is non-null. See `Pulp #1455`_.
.. _Pulp #4262: https://pulp.plan.io/issues/4262
"""
cfg = config.get_config()
if cfg.pulp_version < Version('2.19'):
raise unittest.SkipTest('This test requires Pulp 2.19 or newer.')
repo_body = gen_repo(
importer_config={'feed': RPM_MISSING_FILELISTS_FEED_URL}
)
task = self.run_task(repo_body)
with self.subTest(comment='check task error description'):
tokens = ['error', 'metadata', 'not', 'found']
self.assertTrue(
all(
[
token
in task['error']['description'].lower()
for token in tokens
]
)
)
def test_invalid_feed_error_message(self):
"""Test whether an error report contains sufficient information.
Do the following:
1. Create and sync a repository using an invalid feed URL.
2. Get a reference to the task containing error information.
3. Assert that:
* The error description is sufficiently verbose. See `Pulp #1376`_
and `Pulp Smash #525`_.
* The traceback is non-null. See `Pulp #1455`_.
.. _Pulp #1376: https://pulp.plan.io/issues/1376
.. _Pulp #1455: https://pulp.plan.io/issues/1455
.. _Pulp Smash #525: https://github.com/PulpQE/pulp-smash/issues/525
"""
task = self.run_task(gen_repo(importer_config={'feed': utils.uuid4()}))
with self.subTest(comment='check task error description'):
tokens = ['scheme', 'must', 'be', 'http', 'https', 'file']
self.assertTrue(
all(
[
token
in task['error']['description'].lower()
for token in tokens
]
)
)
def setUpClass(cls):
"""Create a schedule to publish a repo, verify the ``total_run_count``.
Do the following:
1. Create a repository with a valid feed
2. Sync it
3. Schedule publish to run every 2 minutes
4. Wait for 130 seconds and read the schedule to get the number of
"publish" runs
"""
super().setUpClass()
client = api.Client(cls.cfg, api.json_handler)
# Create a repo with a valid feed and sync it
body = gen_repo()
body['importer_config']['feed'] = RPM_SIGNED_FEED_URL
repo = client.post(REPOSITORY_PATH, body)
cls.resources.add(repo['_href'])
sync_repo(cls.cfg, repo)
# Schedule a publish to run every 2 minutes
distributor = gen_distributor()
client.post(urljoin(repo['_href'], 'distributors/'), distributor)
scheduling_url = '/'.join([
'distributors', distributor['distributor_id'], 'schedules/publish/'
])
schedule_path = urljoin(repo['_href'], scheduling_url)
schedule = client.post(schedule_path, {'schedule': 'PT2M'})
# Wait for publish to run
time.sleep(130)
# Read the schedule
cls.response = client.get(schedule['_href'])
def setUpClass(cls):
"""Create a schedule to publish the repository.
Do the following:
1. Create a repository with a valid feed
2. Sync it
3. Schedule publish to run every 30 seconds
"""
super().setUpClass()
client = api.Client(cls.cfg)
# Create a repo with a valid feed and sync it
body = gen_repo()
body['importer_config']['feed'] = RPM_SIGNED_FEED_URL
repo = client.post(REPOSITORY_PATH, body).json()
cls.resources.add(repo['_href'])
sync_repo(cls.cfg, repo)
# Schedule a publish to run every 30 seconds
distributor = gen_distributor()
distributor_url = urljoin(repo['_href'], 'distributors/')
client.post(distributor_url, distributor)
scheduling_url = urljoin(
distributor_url,
'{}/schedules/publish/'.format(distributor['distributor_id']),
)
cls.response = client.post(scheduling_url, {'schedule': 'PT30S'})
cls.attrs = cls.response.json()
def test_all(self):
"""Verify whether uploaded module.yaml is reflected in the pulp repo."""
cfg = config.get_config()
if cfg.pulp_version < Version('2.17'):
raise unittest.SkipTest(
'This test requires at least Pulp 2.17 or newer.')
client = api.Client(cfg, api.json_handler)
# Create a normal Repo without any data.
body = gen_repo(importer_config={'feed': RPM_UNSIGNED_FEED_URL},
distributors=[gen_distributor()])
repo = client.post(REPOSITORY_PATH, body)
repo = client.get(repo['_href'], params={'details': True})
self.addCleanup(client.delete, repo['_href'])
sync_repo(cfg, repo)
# download modules.yaml and upload it to pulp_repo
unit = self._get_module_yaml_file(RPM_WITH_MODULES_FEED_URL)
upload_import_unit(cfg, unit, {
'unit_key': {},
'unit_type_id': 'modulemd',
}, repo)
repo = client.get(repo['_href'], params={'details': True})
# Assert that `modulemd` and `modulemd_defaults` are present on the
# repository.
self.assertIsNotNone(repo['content_unit_counts']['modulemd'])
self.assertIsNotNone(repo['content_unit_counts']['modulemd_defaults'])
def setUpClass(cls):
"""Create an RPM repository, upload package groups, and publish."""
super().setUpClass()
if check_issue_3104(cls.cfg):
raise unittest.SkipTest('https://pulp.plan.io/issues/3104')
# Create a repository and add a distributor to it.
client = api.Client(cls.cfg, api.json_handler)
body = gen_repo()
body['distributors'] = [gen_distributor()]
repo = client.post(REPOSITORY_PATH, body)
cls.resources.add(repo['_href'])
repo = client.get(repo['_href'], params={'details': True})
# Generate several package groups, import them into the repository, and
# publish the repository.
cls.package_groups = {
'minimal': _gen_minimal_group(),
'realistic': _gen_realistic_group(),
}
cls.tasks = {}
for key, package_group in cls.package_groups.items():
report = _upload_import_package_group(cls.cfg, repo, package_group)
cls.tasks[key] = tuple(api.poll_spawned_tasks(cls.cfg, report))
publish_repo(cls.cfg, repo)
# Fetch the generated repodata of type 'group' (a.k.a. 'comps')
cls.root_element = (get_repodata(cls.cfg, repo['distributors'][0],
'group'))
def setUpModule(): # pylint:disable=invalid-name
"""Possibly skip the tests in this module. Create and sync an RPM repo.
Skip this module of tests if Pulp is older than version 2.9. (See `Pulp
#1724`_.) Then create an RPM repository with a feed and sync it. Test cases
may copy data from this repository but should **not** change it.
.. _Pulp #1724: https://pulp.plan.io/issues/1724
"""
set_up_module()
cfg = config.get_config()
if cfg.pulp_version < Version('2.9'):
raise unittest.SkipTest('This module requires Pulp 2.9 or greater.')
if check_issue_2277(cfg):
raise unittest.SkipTest('https://pulp.plan.io/issues/2277')
# Create and sync a repository.
client = api.Client(cfg, api.json_handler)
_CLEANUP.append((client.delete, [ORPHANS_PATH], {}))
body = gen_repo()
body['importer_config']['feed'] = RPM_SIGNED_FEED_URL
_REPO.clear()
_REPO.update(client.post(REPOSITORY_PATH, body))
_CLEANUP.append((client.delete, [_REPO['_href']], {}))
try:
sync_repo(cfg, _REPO)
except (exceptions.CallReportError, exceptions.TaskReportError,
exceptions.TaskTimedOutError):
tearDownModule()
raise
def test_all(self):
"""Package manager can consume RPM with rich/weak dependencies from Pulp."""
cfg = config.get_config()
if cfg.pulp_version < Version('2.17'):
raise unittest.SkipTest('This test requires Pulp 2.17 or newer.')
if not rpm_rich_weak_dependencies(cfg):
raise unittest.SkipTest('This test requires RPM 4.12 or newer.')
client = api.Client(cfg, api.json_handler)
body = gen_repo(
importer_config={'feed': RPM_RICH_WEAK_FEED_URL},
distributors=[gen_distributor()]
)
repo = client.post(REPOSITORY_PATH, body)
self.addCleanup(client.delete, repo['_href'])
repo = client.get(repo['_href'], params={'details': True})
sync_repo(cfg, repo)
publish_repo(cfg, repo)
repo_path = gen_yum_config_file(
cfg,
baseurl=urljoin(cfg.get_base_url(), urljoin(
'pulp/repos/',
repo['distributors'][0]['config']['relative_url']
)),
name=repo['_href'],
repositoryid=repo['id']
)
cli_client = cli.Client(cfg)
self.addCleanup(cli_client.run, ('rm', repo_path), sudo=True)
rpm_name = 'Cobbler'
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 that uploading DRPM with checksumtype specified works."""
if not selectors.bug_is_fixed(1806, self.cfg.pulp_version):
raise unittest.SkipTest('https://pulp.plan.io/issues/1806')
if not selectors.bug_is_fixed(2627, self.cfg.pulp_version):
raise unittest.SkipTest('https://pulp.plan.io/issues/2627')
client = api.Client(self.cfg)
repo = client.post(REPOSITORY_PATH, gen_repo()).json()
self.addCleanup(client.delete, repo['_href'])
drpm = utils.http_get(DRPM_UNSIGNED_URL)
upload_import_unit(
self.cfg,
drpm,
{
'unit_type_id': 'drpm',
'unit_metadata': {
'checksumtype': 'sha256'
},
},
repo,
)
units = search_units(self.cfg, repo, {})
self.assertEqual(len(units), 1, units)
# Test if DRPM extracted correct metadata for creating filename.
self.assertEqual(
units[0]['metadata']['filename'],
DRPM,
)
def test_all(self):
"""Verify ``RPM_LARGE_METADATA`` RPM file can be uploaded.
Specifically, this method does the following:
1. Create an RPM repo.
2. Verify whether the file ``RPM_LARGE_METADATA`` can be uploaded
into the repo without errors.
This test targets:
* `Pulp #723 <https://pulp.plan.io/issues/723>`_
* `Pulp-2-Tests #88 <https://github.com/PulpQE/Pulp-2-Tests/issues/88>`_
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
body = gen_repo(distributors=[gen_distributor()])
repo = client.post(REPOSITORY_PATH, body)
self.addCleanup(client.delete, repo['_href'])
rpm = utils.http_get(RPM_LARGE_METADATA_FEED)
upload_import_unit(cfg, rpm, {'unit_type_id': 'rpm'}, repo)
repo = client.get(repo['_href'], params={'details': True})
publish_repo(cfg, repo)
rpm_path = get_rpm_published_path(cfg, repo, RPM_LARGE_METADATA)
# Check whether the RPM is uploaded published.
self.assertIn(RPM_LARGE_METADATA, rpm_path, rpm_path)
def setUpClass(cls):
"""Create an RPM repository and issue a task to download the repo.
Do the following:
1. Reset Pulp.
2. Create a repository with the "on demand" download policy.
3. Sync the repository.
4. Trigger a repository download.
5. Corrupt a file in the repository.
6. Trigger a repository download, without unit verification.
7. Trigger a repository download, with unit verification.
"""
cls.cfg = config.get_config()
if (not selectors.bug_is_fixed(1905, cls.cfg.pulp_version)
and os_is_rhel6(cls.cfg)):
raise unittest.SkipTest('https://pulp.plan.io/issues/1905')
# Ensure Pulp is empty of units otherwise we might just associate pre-
# existing units.
reset_pulp(cls.cfg)
# Create and sync a repository.
api_client = api.Client(cls.cfg, api.json_handler)
body = gen_repo(importer_config={
'feed': RPM_UNSIGNED_FEED_URL,
'download_policy': 'on_demand'
})
cls.repo = api_client.post(REPOSITORY_PATH, body)
sync_repo(cls.cfg, cls.repo)
# Trigger a repository download. Read the repo before and after.
download_path = urljoin(cls.repo['_href'], 'actions/download/')
params = {'details': True}
cls.repo_pre_download = api_client.get(cls.repo['_href'],
params=params)
api_client.post(download_path, {'verify_all_units': False})
cls.repo_post_download = api_client.get(cls.repo['_href'],
params=params)
# Corrupt an RPM. The file is there, but the checksum isn't right.
rpm_abs_path = cls.get_rpm_abs_path()
cli_client = cli.Client(cls.cfg)
checksum_cmd = ('sha256sum ' + rpm_abs_path).split()
cls.sha_pre_corruption = cli_client.run(checksum_cmd,
sudo=True).stdout.strip()
cli_client.run(('rm ' + rpm_abs_path).split(), sudo=True)
cli_client.run(('touch ' + rpm_abs_path).split(), sudo=True)
cli_client.run(('chown apache:apache ' + rpm_abs_path).split(),
sudo=True)
cls.sha_post_corruption = cli_client.run(checksum_cmd,
sudo=True).stdout.strip()
# Trigger repository downloads that don't and do checksum files, resp.
api_client.post(download_path, {'verify_all_units': False})
cls.unverified_file_sha = cli_client.run(checksum_cmd,
sudo=True).stdout.strip()
api_client.post(download_path, {'verify_all_units': True})
cls.verified_file_sha = cli_client.run(checksum_cmd,
sudo=True).stdout.strip()
def test_update_checksum_type(self):
"""Check if RPM distributor can receive null checksum_type.
See: https://pulp.plan.io/issues/2134.
"""
cfg = config.get_config()
if cfg.pulp_version < version.Version('2.9'):
raise unittest.SkipTest('This test requires Pulp 2.9 or above.')
client = api.Client(cfg, api.json_handler)
distributor = gen_distributor()
body = gen_repo()
body['distributors'] = [distributor]
repo = client.post(REPOSITORY_PATH, body)
self.addCleanup(client.delete, repo['_href'])
for checksum_type in (None, 'sha256', None):
client.put(
repo['_href'], {
'distributor_configs': {
distributor['distributor_id']: {
'checksum_type': checksum_type,
}
}
})
repo = client.get(repo['_href'], params={'details': True})
self.assertEqual(
repo['distributors'][0]['config'].get('checksum_type'),
checksum_type)
def make_repo(self, cfg, dist_cfg_updates):
"""Create a repository with an importer and pair of distributors.
Create an RPM repository with:
* A yum importer with a valid feed.
* A yum distributor.
* An RPM rsync distributor referencing the yum distributor.
In addition, schedule the repository for deletion.
:param cfg: Information about the
Pulp deployment being targeted.
:param dist_cfg_updates: A dict to be merged into the RPM rsync
distributor's ``distributor_config`` dict. At a minimum, this
argument should have a value of ``{'remote': {…}}``.
:returns: A detailed dict of information about the repo.
"""
api_client = api.Client(cfg, api.json_handler)
body = gen_repo()
body['importer_config']['feed'] = RPM_SIGNED_FEED_URL
body['distributors'] = [gen_distributor()]
body['distributors'].append({
'distributor_id': utils.uuid4(),
'distributor_type_id': 'rpm_rsync_distributor',
'distributor_config': {
'predistributor_id': body['distributors'][0]['distributor_id'],
}
})
body['distributors'][1]['distributor_config'].update(dist_cfg_updates)
repo = api_client.post(REPOSITORY_PATH, body)
self.addCleanup(api_client.delete, repo['_href'])
return api_client.get(repo['_href'], params={'details': True})
def test_all(self):
"""Upload a package group to a repository twice."""
cfg = config.get_config()
if check_issue_3104(cfg):
self.skipTest('https://pulp.plan.io/issues/3104')
client = api.Client(cfg, api.json_handler)
self.addCleanup(client.delete, ORPHANS_PATH)
# Create a repository.
body = gen_repo()
body['distributors'] = [gen_distributor()]
repo = client.post(REPOSITORY_PATH, body)
self.addCleanup(client.delete, repo['_href'])
# Give the repository a package group, and publish the repository.
package_group = {'id': utils.uuid4(), 'name': utils.uuid4()}
_upload_import_package_group(cfg, repo, package_group)
repo = client.get(repo['_href'], params={'details': True})
publish_repo(cfg, repo)
# Update the repository's package group, and re-publish the repository.
package_group['name'] = utils.uuid4()
_upload_import_package_group(cfg, repo, package_group)
publish_repo(cfg, repo)
# Fetch the generated repodata of type 'group' (a.k.a. 'comps'). Verify
# the package group portion.
root_element = get_repodata(cfg, repo['distributors'][0], 'group')
groups = root_element.findall('group')
self.assertEqual(len(groups), 1, ElementTree.tostring(root_element))
for key, value in package_group.items():
with self.subTest(key=key):
self.assertEqual(groups[0].find(key).text, value)
def test_all(self):
"""Verify whether package manager can read module list from a Pulp repo."""
cfg = config.get_config()
if cfg.pulp_version < Version('2.17'):
raise unittest.SkipTest(
'This test requires at least Pulp 2.17 or newer.')
if not os_support_modularity(cfg):
raise unittest.SkipTest(
'This test requires an OS that supports modularity.')
client = api.Client(cfg, api.json_handler)
body = gen_repo(importer_config={'feed': RPM_WITH_MODULES_FEED_URL},
distributors=[gen_distributor()])
repo = client.post(REPOSITORY_PATH, body)
self.addCleanup(client.delete, repo['_href'])
repo = client.get(repo['_href'], params={'details': True})
sync_repo(cfg, repo)
publish_repo(cfg, repo)
repo = client.get(repo['_href'], params={'details': True})
repo_path = gen_yum_config_file(
cfg,
baseurl=urljoin(
cfg.get_base_url(),
urljoin('pulp/repos/',
repo['distributors'][0]['config']['relative_url'])),
name=repo['_href'],
repositoryid=repo['id'])
cli_client = cli.Client(cfg)
self.addCleanup(cli_client.run, ('rm', repo_path), sudo=True)
lines = cli_client.run((('dnf', 'module', 'list', '--all')),
sudo=True).stdout.splitlines()
for key, value in MODULE_FIXTURES_PACKAGES.items():
with self.subTest(package=key):
module = [line for line in lines if key in line]
self.assertEqual(len(module), value, module)
def test_all(self):
"""Search contents of a richnweak repository matching package name.
This test targets `Pulp #3929`_ and `Pulp Smash #901`_. The
`repository content`_ documentation describes the CLI content syntax.
.. _Pulp #3929: https://pulp.plan.io/issues/3929
.. _Pulp Smash #901: https://github.com/PulpQE/pulp-smash/issues/901
.. _repository content:
https://docs.pulpproject.org/en/latest/user-guide/admin-client/repositories.html#content-search
Asserts the required fields are present.
"""
cfg = config.get_config()
if cfg.pulp_version < Version('2.17.1'):
raise unittest.SkipTest('This test requires Pulp 2.17.1 or newer.')
api_client = api.Client(cfg, api.json_handler)
body = gen_repo(
importer_config={'feed': RPM_RICH_WEAK_FEED_URL},
)
repo = api_client.post(REPOSITORY_PATH, body)
self.addCleanup(api_client.delete, repo['_href'])
sync_repo(cfg, repo)
repo = api_client.get(repo['_href'], params={'details': True})
result = cli.Client(cfg).run(
'pulp-admin rpm repo content rpm --repo-id {} '
'--match name=Cobbler'
.format(repo['id']).split()
)
required_fields = ('Recommends:', 'Requires:', 'Provides:')
for field in required_fields:
with self.subTest(field=field):
self.assertEqual(result.stdout.count(field), 1, result)
def _create_repository(cfg, importer_config):
"""Create an RPM repository with the given importer configuration.
Return a dict of information about the repository.
"""
body = gen_repo()
body['importer_config'] = importer_config
return api.Client(cfg).post(REPOSITORY_PATH, body).json()
def setUp(self):
"""Perform common set-up tasks."""
self.client = api.Client(self.cfg, api.json_handler)
body = gen_repo()
body['importer_config'] = {'feed': RPM_UNSIGNED_FEED_URL}
repo = self.client.post(REPOSITORY_PATH, body)
self.addCleanup(self.client.delete, repo['_href'])
self.repo = self.client.get(repo['_href'], params={'details': True})
def test_all(self):
"""Test whether one can upload an RPM with non-ascii metadata."""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
repo = client.post(REPOSITORY_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
rpm = utils.http_get(RPM_WITH_NON_ASCII_URL)
upload_import_unit(cfg, rpm, {'unit_type_id': 'rpm'}, repo)
def test_all(self):
"""Test whether copied files retain their original mtime.
This test targets the following issues:
* `Pulp #2783 <https://pulp.plan.io/issues/2783>`_
* `Pulp Smash #720 <https://github.com/PulpQE/pulp-smash/issues/720>`_
Do the following:
1. Create, sync and publish a repository, with ``generate_sqlite`` set
to true.
2. Get the ``mtime`` of the sqlite files.
3. Upload an RPM package into the repository, and sync the repository.
4. Get the ``mtime`` of the sqlite files again. Verify that the mtimes
are the same.
"""
cfg = config.get_config()
if not selectors.bug_is_fixed(2783, cfg.pulp_version):
self.skipTest('https://pulp.plan.io/issues/2783')
# Create, sync and publish a repository.
client = api.Client(cfg, api.json_handler)
body = gen_repo()
body['importer_config']['feed'] = RPM_UNSIGNED_FEED_URL
body['distributors'] = [gen_distributor()]
body['distributors'][0]['distributor_config']['generate_sqlite'] = True
repo = client.post(REPOSITORY_PATH, body)
self.addCleanup(client.delete, repo['_href'])
repo = client.get(repo['_href'], params={'details': True})
sync_repo(cfg, repo)
publish_repo(cfg, repo)
# Get the mtime of the sqlite files.
cli_client = cli.Client(cfg, cli.echo_handler)
cmd = '' if cli.is_root(cfg) else 'sudo '
cmd += "bash -c \"stat --format %Y '{}'/*\"".format(
os.path.join(
_PATH,
repo['distributors'][0]['config']['relative_url'],
'repodata',
))
# machine.session is used here to keep SSH session open
mtimes_pre = (
cli_client.machine.session().run(cmd)[1].strip().split().sort())
# Upload to the repo, and sync it.
rpm = utils.http_get(RPM_SIGNED_URL)
upload_import_unit(cfg, rpm, {'unit_type_id': 'rpm'}, repo)
sync_repo(cfg, repo)
# Get the mtime of the sqlite files again.
time.sleep(1)
# machine.session is used here to keep SSH session open
mtimes_post = (
cli_client.machine.session().run(cmd)[1].strip().split().sort())
self.assertEqual(mtimes_pre, mtimes_post)
def setUpClass(cls):
"""Create several schedules.
Each schedule is created to test a different failure scenario.
"""
super().setUpClass()
client = api.Client(cls.cfg)
# Create a repo with a valid feed and sync it
body = gen_repo()
body['importer_config']['feed'] = RPM_SIGNED_FEED_URL
repo = client.post(REPOSITORY_PATH, body).json()
cls.resources.add(repo['_href'])
sync_repo(cls.cfg, repo)
# Add a distibutor
distributor = gen_distributor()
client.post(urljoin(repo['_href'], 'distributors/'), distributor)
client.response_handler = api.echo_handler
cls.bodies = (
{
'schedule': None
}, # 400
{
'unknown': 'parameter',
'schedule': 'PT30S'
}, # 400
['Incorrect data type'], # 400
{
'missing_required_keys': 'schedule'
}, # 400
{
'schedule': 'PT30S'
}, # tests incorrect distributor in url, 404
{
'schedule': 'PT30S'
}, # tests incorrect repo in url, 404
)
scheduling_url = '/'.join([
'distributors', distributor['distributor_id'], 'schedules/publish/'
])
bad_distributor_url = '/'.join(
['distributors',
utils.uuid4(), 'schedules/publish/'])
bad_repo_path = '/'.join([REPOSITORY_PATH, utils.uuid4()])
cls.paths = (urljoin(repo['_href'], scheduling_url),
urljoin(repo['_href'], scheduling_url),
urljoin(repo['_href'], scheduling_url),
urljoin(repo['_href'], scheduling_url),
urljoin(repo['_href'], bad_distributor_url),
urljoin(bad_repo_path, scheduling_url))
cls.status_codes = (400, 400, 400, 400, 404, 404)
cls.responses = [
client.post(path, req_body)
for path, req_body in zip(cls.paths, cls.bodies)
]
def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
cls.client = api.Client(cls.cfg, api.json_handler)
body = gen_repo(importer_config={'feed': RPM_UNSIGNED_FEED_URL},
distributors=[gen_distributor()])
cls.repo = cls.client.post(REPOSITORY_PATH, body)
cls.repo = cls.client.get(cls.repo['_href'], params={'details': True})
sync_repo(cls.cfg, cls.repo)
cls.errata = _gen_errata()
def test_all(self):
"""Test whether one can upload an RPM with non-ascii metadata."""
cfg = config.get_config()
if not selectors.bug_is_fixed(1903, cfg.pulp_version):
self.skipTest('https://pulp.plan.io/issues/1903')
client = api.Client(cfg, api.json_handler)
repo = client.post(REPOSITORY_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
rpm = utils.http_get(RPM_WITH_NON_UTF_8_URL)
upload_import_unit(cfg, rpm, {'unit_type_id': 'rpm'}, repo)