def setUpClass(cls):
"""Create an RPM repository with a valid feed and sync it.
Do the following:
1. Reset Pulp, including the Squid cache.
2. Create a repository with the "on demand" download policy.
3. Sync and publish the repository.
4. Download an RPM from the published repository.
5. Download the same RPM to ensure it is served by the cache.
"""
super().setUpClass()
if check_issue_3104(cls.cfg):
raise unittest.SkipTest('https://pulp.plan.io/issues/3104')
if not selectors.bug_is_fixed(4120, cls.cfg.pulp_version):
raise unittest.SkipTest('https://pulp.plan.io/issues/4120')
# Ensure `locally_stored_units` is 0 before we start.
reset_squid(cls.cfg)
reset_pulp(cls.cfg)
# Create, sync and publish a repository.
repo = _create_repo(cls.cfg, 'on_demand')
cls.resources.add(repo['_href'])
sync_repo(cls.cfg, repo)
# Read the repository.
client = api.Client(cls.cfg)
cls.repo = client.get(repo['_href'], params={'details': True}).json()
# Download the same RPM twice.
cls.rpm = get_unit(cls.cfg, cls.repo['distributors'][0], RPM)
cls.same_rpm = get_unit(cls.cfg, cls.repo['distributors'][0], RPM)
def setUpClass(cls):
"""Create an RPM repository with a valid feed and sync it.
Do the following:
1. Reset Pulp, including the Squid cache.
2. Create a repository with the "background" download policy.
3. Sync and publish the repository.
4. Download an RPM from the repository.
"""
super().setUpClass()
if check_issue_3104(cls.cfg):
raise unittest.SkipTest('https://pulp.plan.io/issues/3104')
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')
# Required to ensure content is actually downloaded.
reset_squid(cls.cfg)
reset_pulp(cls.cfg)
# Create, sync and publish a repository.
repo = _create_repo(cls.cfg, 'background')
cls.resources.add(repo['_href'])
report = sync_repo(cls.cfg, repo).json()
# Record the tasks spawned when syncing the repository, and the state
# of the repository itself after the sync.
client = api.Client(cls.cfg)
cls.repo = client.get(repo['_href'], params={'details': True}).json()
cls.tasks = tuple(api.poll_spawned_tasks(cls.cfg, report))
# Download an RPM.
cls.rpm = get_unit(cls.cfg, cls.repo['distributors'][0], RPM)
def setUp(self):
"""Make sure Pulp and Squid are reset."""
if check_issue_3104(self.cfg):
self.skipTest('https://pulp.plan.io/issues/3104')
# Required to ensure content is actually downloaded.
reset_squid(self.cfg)
reset_pulp(self.cfg)
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 setUp(self):
"""Make sure Pulp and Squid are reset."""
if check_issue_3104(self.cfg):
self.skipTest('https://pulp.plan.io/issues/3104')
if not selectors.bug_is_fixed(4120, self.cfg.pulp_version):
raise unittest.SkipTest('https://pulp.plan.io/issues/4120')
# Required to ensure content is actually downloaded.
reset_squid(self.cfg)
reset_pulp(self.cfg)
def tearDown(self):
"""Reset the number of Pul pworkers, and reset Pulp.
Reset Pulp because :meth:`test_all` may break Pulp.
"""
# Delete last line from file.
cli.Client(self.cfg).run(('sed', '-i', '$d', _PULP_WORKERS_CFG),
sudo=True)
reset_pulp(self.cfg)
def setUpModule(): # pylint:disable=invalid-name
"""Execute ``pulp-admin login`` and reset Pulp.
For :class:`RemovedContentTestCase` to function correctly, we require that
all of the content units on Pulp's filesystem belong to the repository
created by that test case. Resetting Pulp guarantees that this is so.
Ideally, all test cases would clean up after themselves so that no resets
are necessary.
"""
cfg = config.get_config()
set_up_module()
reset_pulp(cfg)
pulp_admin_login(cfg)
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 and publish 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.
"""
super().setUpClass()
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, sync and publish a repository.
repo = _create_repo(cls.cfg, 'on_demand')
cls.resources.add(repo['_href'])
sync_repo(cls.cfg, repo)
# Trigger a repository download. Read the repo before and after.
api_client = api.Client(cls.cfg, api.json_handler)
download_path = urljoin(repo['_href'], 'actions/download/')
params = {'details': True}
cls.repo_pre_download = api_client.get(repo['_href'], params=params)
api_client.post(download_path, {'verify_all_units': False})
cls.repo_post_download = api_client.get(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)
sudo = '' if cli.is_root(cls.cfg) else 'sudo '
checksum_cmd = (sudo + 'sha256sum ' + rpm_abs_path).split()
cls.sha_pre_corruption = cli_client.run(checksum_cmd).stdout.strip()
cli_client.run((sudo + 'rm ' + rpm_abs_path).split())
cli_client.run((sudo + 'touch ' + rpm_abs_path).split())
cli_client.run((sudo + 'chown apache:apache ' + rpm_abs_path).split())
cls.sha_post_corruption = cli_client.run(checksum_cmd).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).stdout.strip()
api_client.post(download_path, {'verify_all_units': True})
cls.verified_file_sha = cli_client.run(checksum_cmd).stdout.strip()
def setUpClass(cls):
"""Upload puppet module to a repo, copy it to another repo, publish and download.
Create two puppet repositories, both without feeds. Upload a module to
the first repository. Copy its content to the second repository. Add
distributors to the repositories, publish repositories and download
modules back from them.
"""
cls.cfg = config.get_config()
cls.resources = set()
reset_pulp(cls.cfg) # See: https://pulp.plan.io/issues/1406
cls.responses = {}
cls.modules = [] # Raw puppet modules.
# Download a puppet module and create two repositories.
cls.client = api.Client(cls.cfg, api.json_handler)
repos = [cls.client.post(REPOSITORY_PATH, gen_repo()) for _ in range(2)]
for repo in repos:
cls.resources.add(repo['_href'])
cls.client.response_handler = api.safe_handler
cls.modules.append(utils.http_get(PUPPET_MODULE_URL_1))
# Begin an upload request, upload a puppet module, move the puppet
# module into a repository, and end the upload request.
cls.responses['malloc'] = cls.client.post(CONTENT_UPLOAD_PATH)
cls.responses['upload'] = cls.client.put(
urljoin(cls.responses['malloc'].json()['_href'], '0/'),
data=cls.modules[0],
)
cls.responses['import'] = cls.client.post(
urljoin(repos[0]['_href'], 'actions/import_upload/'),
{
'unit_key': {},
'unit_type_id': 'puppet_module',
'upload_id': cls.responses['malloc'].json()['upload_id'],
},
)
cls.responses['free'] = cls.client.delete(
cls.responses['malloc'].json()['_href']
)
# Copy content from the first puppet repository to the second.
cls.responses['copy'] = cls.client.post(
urljoin(repos[1]['_href'], 'actions/associate/'),
{'source_repo_id': repos[0]['id']}
)
# Add a distributor to each repository. Publish each repository.
for key in {'distribute', 'publish'}:
cls.responses[key] = []
for repo in repos:
cls.responses['distribute'].append(cls.client.post(
urljoin(repo['_href'], 'distributors/'),
{
'auto_publish': False,
'distributor_id': utils.uuid4(),
'distributor_type_id': 'puppet_distributor',
'distributor_config': {
'serve_http': True,
'serve_https': True,
'relative_url': '/' + utils.uuid4(),
},
}
))
cls.responses['publish'].append(cls.client.post(
urljoin(repo['_href'], 'actions/publish/'),
{'id': cls.responses['distribute'][-1].json()['id']},
))
# Query both distributors using all three query forms.
cls.responses['puppet releases'] = []
author_name = PUPPET_MODULE_1['author'] + '/' + PUPPET_MODULE_1['name']
for repo in repos:
if not selectors.bug_is_fixed(1440, cls.cfg.pulp_version):
continue
cls.responses['puppet releases'].append(cls.client.get(
'/api/v1/releases.json',
params={'module': author_name},
auth=('.', repo['id']),
))
cls.responses['puppet releases'].append(cls.client.get(
'/pulp_puppet/forge/repository/{}/api/v1/releases.json'
.format(repo['id']),
params={'module': author_name},
))
if cls.cfg.pulp_version < Version('2.8'):
continue
cls.responses['puppet releases'].append(cls.client.get(
'/v3/releases',
params={'module': author_name},
auth=('repository', repo['id']),
))
# Download each unit referenced by the queries above.
for response in cls.responses['puppet releases']:
body = response.json()
if set(body.keys()) == {'pagination', 'results'}: # Puppet >= 3.6
path = body['results'][0]['file_uri']
else:
path = body[author_name][0]['file']
cls.modules.append(cls.client.get(path).content)
# Search for all units in each of the two repositories.
cls.responses['repo units'] = [
search_units(cls.cfg, repo, {}, api.safe_handler)
for repo in repos
]
def tearDownModule(): # pylint:disable=invalid-name
"""Reset Pulp, in case one of the test cases breaks Pulp."""
reset_pulp(config.get_config())