def test_duplicate_file_sync(self):
"""Sync a repository with remotes containing same file names.
This test does the following.
1. Create a repository in pulp.
2. Create two remotes containing the same file.
3. Check whether the created repo has only one copy of the file.
This test targets the following issue:
`Pulp #4738 <https://pulp.plan.io/issues/4738>`_
"""
# Step 1
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo["_href"])
# Step 2
remote = self.client.post(FILE_REMOTE_PATH, gen_file_remote())
self.addCleanup(self.client.delete, remote["_href"])
remote2 = self.client.post(
FILE_REMOTE_PATH, gen_file_remote(url=FILE2_FIXTURE_MANIFEST_URL))
self.addCleanup(self.client.delete, remote2["_href"])
sync(self.cfg, remote, repo)
repo = self.client.get(repo["_href"])
self.assertDictEqual(get_content_summary(repo), FILE_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo),
FILE_FIXTURE_SUMMARY)
sync(self.cfg, remote2, repo)
repo = self.client.get(repo["_href"])
self.assertDictEqual(get_added_content_summary(repo),
FILE_FIXTURE_SUMMARY)
def test_file_decriptors(self):
"""Test whether file descriptors are closed properly.
This test targets the following issue:
`Pulp #4073 <https://pulp.plan.io/issues/4073>`_
Do the following:
1. Check if 'lsof' is installed. If it is not, skip this test.
2. Create and sync a repo.
3. Run the 'lsof' command to verify that files in the
path ``/var/lib/pulp/`` are closed after the sync.
4. Assert that issued command returns `0` opened files.
"""
cli_client = cli.Client(self.cfg, cli.echo_handler)
# check if 'lsof' is available
if cli_client.run(('which', 'lsof')).returncode != 0:
raise unittest.SkipTest('lsof package is not present')
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
remote = self.client.post(FILE_REMOTE_PATH, gen_file_remote())
self.addCleanup(self.client.delete, remote['_href'])
sync(self.cfg, remote, repo)
cmd = 'lsof -t +D {}'.format(MEDIA_PATH).split()
response = cli_client.run(cmd).stdout
self.assertEqual(len(response), 0, response)
def do_test(self, policy):
"""Access lazy synced content on using content endpoint."""
# delete orphans to assure that no content units are present on the
# file system
delete_orphans()
content_api = ContentFilesApi(self.client)
repo_api = RepositoriesFileApi(self.client)
remote_api = RemotesFileApi(self.client)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
body = gen_file_remote(**{"policy": policy})
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
# Sync the repository.
self.assertEqual(repo.latest_version_href,
f"{repo.pulp_href}versions/0/")
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
# Assert that no HTTP error was raised.
# Assert that the number of units present is according to the synced
# feed.
content = content_api.list().to_dict()["results"]
self.assertEqual(len(content), FILE_FIXTURE_COUNT, content)
def do_publish(self, download_policy):
"""Publish repository synced with lazy download policy."""
repo_api = RepositoriesFileApi(self.client)
remote_api = RemotesFileApi(self.client)
publications = PublicationsFileApi(self.client)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
body = gen_file_remote(policy=download_policy)
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
publish_data = FileFilePublication(repository=repo.pulp_href)
publish_response = publications.create(publish_data)
created_resources = monitor_task(
publish_response.task).created_resources
publication_href = created_resources[0]
self.addCleanup(publications.delete, publication_href)
publication = publications.read(publication_href)
self.assertIsNotNone(publication.repository_version, publication)
def test_all(self):
"""Perform a lazy sync and change to immeditae to force download."""
cfg = config.get_config()
# delete orphans to assure that no content units are present on the
# file system
delete_orphans(cfg)
client = api.Client(cfg, api.page_handler)
repo = client.post(FILE_REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo["pulp_href"])
body = gen_file_remote(policy=choice(ON_DEMAND_DOWNLOAD_POLICIES))
remote = client.post(FILE_REMOTE_PATH, body)
self.addCleanup(client.delete, remote["pulp_href"])
# Sync the repository using a lazy download policy
sync(cfg, remote, repo)
artifacts = client.get(ARTIFACTS_PATH)
self.assertEqual(len(artifacts), 0, artifacts)
# Update the policy to immediate
client.patch(remote["pulp_href"], {"policy": "immediate"})
remote = client.get(remote["pulp_href"])
self.assertEqual(remote["policy"], "immediate")
# Sync using immediate download policy
sync(cfg, remote, repo)
# Assert that missing artifacts are downloaded
artifacts = client.get(ARTIFACTS_PATH)
self.assertEqual(len(artifacts), FILE_FIXTURE_COUNT, artifacts)
def do_test(self, policy):
"""Verify whether content served by pulp can be downloaded.
The process of publishing content is more involved in Pulp 3 than it
was under Pulp 2. Given a repository, the process is as follows:
1. Create a publication from the repository. (The latest repository
version is selected if no version is specified.) A publication is a
repository version plus metadata.
2. Create a distribution from the publication. The distribution defines
at which URLs a publication is available, e.g.
``http://example.com/content/foo/`` and
``http://example.com/content/bar/``.
Do the following:
1. Create, populate, publish, and distribute a repository.
2. Select a random content unit in the distribution. Download that
content unit from Pulp, and verify that the content unit has the
same checksum when fetched directly from Pulp-Fixtures.
This test targets the following issues:
* `Pulp #2895 <https://pulp.plan.io/issues/2895>`_
* `Pulp Smash #872 <https://github.com/PulpQE/pulp-smash/issues/872>`_
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo["pulp_href"])
body = gen_file_remote(policy=policy)
remote = client.post(FILE_REMOTE_PATH, body)
self.addCleanup(client.delete, remote["pulp_href"])
sync(cfg, remote, repo)
repo = client.get(repo["pulp_href"])
# Create a publication.
publication = create_file_publication(cfg, repo)
self.addCleanup(client.delete, publication["pulp_href"])
# Create a distribution.
body = gen_distribution()
body["publication"] = publication["pulp_href"]
distribution = client.using_handler(api.task_handler).post(
FILE_DISTRIBUTION_PATH, body)
self.addCleanup(client.delete, distribution["pulp_href"])
# Pick a file, and download it from both Pulp Fixtures…
unit_path = choice(get_file_content_paths(repo))
fixtures_hash = hashlib.sha256(
utils.http_get(urljoin(FILE_FIXTURE_URL, unit_path))).hexdigest()
# …and Pulp.
content = download_content_unit(cfg, distribution, unit_path)
pulp_hash = hashlib.sha256(content).hexdigest()
self.assertEqual(fixtures_hash, pulp_hash)
def _setup_repositories(cls):
"""Create and sync a number of repositories to be exported."""
# create and remember a set of repo
repos = []
remotes = []
publications = []
for r in range(NUM_REPOS):
repo = cls.repo_api.create(gen_repo())
remote = cls.remote_api.create(gen_file_remote())
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = cls.repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = cls.repo_api.read(file_file_repository_href=repo.pulp_href)
publish_data = FileFilePublication(repository=repo.pulp_href)
publish_response = cls.publication_api.create(publish_data)
created_resources = monitor_task(publish_response.task)
publication_href = created_resources[0]
publication = cls.publication_api.read(publication_href)
repos.append(repo)
remotes.append(remote)
publications.append(publication)
return repos, remotes, publications
def test_all(self):
"""Test whether a particular repository version can be published.
1. Create a repository with at least 2 repository versions.
2. Create a publication by supplying the latest ``repository_version``.
3. Assert that the publication ``repository_version`` attribute points
to the latest repository version.
4. Create a publication by supplying the non-latest
``repository_version``.
5. Assert that the publication ``repository_version`` attribute points
to the supplied repository version.
6. Assert that an exception is raised when providing two different
repository versions to be published at same time.
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
body = gen_file_remote()
remote = client.post(FILE_REMOTE_PATH, body)
self.addCleanup(client.delete, remote['_href'])
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
sync(cfg, remote, repo)
publisher = client.post(FILE_PUBLISHER_PATH, gen_file_publisher())
self.addCleanup(client.delete, publisher['_href'])
# Step 1
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo['_href'])
for file_content in client.get(FILE_CONTENT_PATH)['results']:
client.post(repo['_versions_href'],
{'add_content_units': [file_content['_href']]})
version_hrefs = tuple(ver['_href'] for ver in get_versions(repo))
non_latest = choice(version_hrefs[:-1])
# Step 2
publication = publish(cfg, publisher, repo)
# Step 3
self.assertEqual(publication['repository_version'], version_hrefs[-1])
# Step 4
publication = publish(cfg, publisher, repo, non_latest)
# Step 5
self.assertEqual(publication['repository_version'], non_latest)
# Step 6
with self.assertRaises(HTTPError):
body = {
'repository': repo['_href'],
'repository_version': non_latest
}
client.post(urljoin(publisher['_href'], 'publish/'), body)
def do_test(self, url):
"""Sync a repository given ``url`` on the remote."""
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo['_href'])
body = gen_file_remote(url=url)
remote = self.client.post(FILE_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote['_href'])
with self.assertRaises(TaskReportError) as context:
sync(self.cfg, remote, repo)
return context
def test_02_create_same_name(self):
"""Try to create a second remote with an identical name.
See: `Pulp Smash #1055
<https://github.com/pulp/pulp-smash/issues/1055>`_.
"""
body = gen_file_remote()
body["name"] = self.remote.name
with self.assertRaises(ApiException):
self.remote_api.create(body)
def test_02_create_same_name(self):
"""Try to create a second remote with an identical name.
See: `Pulp Smash #1055
<https://github.com/PulpQE/pulp-smash/issues/1055>`_.
"""
body = gen_file_remote()
body['name'] = self.remote['name']
with self.assertRaises(HTTPError):
self.client.post(FILE_REMOTE_PATH, body)
def test_duplicate_file_sync(self):
"""Sync a repository with remotes containing same file names.
This test does the following.
1. Create a repository in pulp.
2. Create two remotes containing the same file.
3. Check whether the created repo has only one copy of the file.
This test targets the following issue:
`Pulp #4738 <https://pulp.plan.io/issues/4738>`_
"""
repo_api = RepositoriesFileApi(self.client)
remote_api = RemotesFileApi(self.client)
# Step 1
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
# Step 2
remote = remote_api.create(gen_file_remote())
self.addCleanup(remote_api.delete, remote.pulp_href)
remote2 = remote_api.create(
gen_file_remote(url=FILE2_FIXTURE_MANIFEST_URL))
self.addCleanup(remote_api.delete, remote2.pulp_href)
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
self.assertDictEqual(get_content_summary(repo.to_dict()),
FILE_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo.to_dict()),
FILE_FIXTURE_SUMMARY)
repository_sync_data = RepositorySyncURL(remote=remote2.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
self.assertDictEqual(get_added_content_summary(repo.to_dict()),
FILE_FIXTURE_SUMMARY)
def do_sync(self, download_policy):
"""Sync repositories with the different ``download_policy``.
Do the following:
1. Create a repository, and a remote.
2. Assert that repository version is None.
3. Sync the remote.
4. Assert that repository version is not None.
5. Assert that the correct number of possible units to be downloaded
were shown.
6. Sync the remote one more time in order to create another repository
version.
7. Assert that repository version is the same as the previous one.
8. Assert that the same number of units are shown, and after the
second sync no extra units should be shown, since the same remote
was synced again.
"""
# delete orphans to assure that no content units are present on the
# file system
delete_orphans()
repo_api = RepositoriesFileApi(self.client)
remote_api = RemotesFileApi(self.client)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
body = gen_file_remote(**{"policy": download_policy})
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
# Sync the repository.
self.assertEqual(repo.latest_version_href,
f"{repo.pulp_href}versions/0/")
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
self.assertIsNotNone(repo.latest_version_href)
self.assertDictEqual(get_content_summary(repo.to_dict()),
FILE_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo.to_dict()),
FILE_FIXTURE_SUMMARY)
# Sync the repository again.
latest_version_href = repo.latest_version_href
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
self.assertEqual(latest_version_href, repo.latest_version_href)
self.assertDictEqual(get_content_summary(repo.to_dict()),
FILE_FIXTURE_SUMMARY)
def do_test(self, url):
"""Sync repositories with the file plugin.
In order to sync a repository a remote has to be associated within
this repository. When a repository is created this version field is set
as None. After a sync the repository version is updated.
Do the following:
1. Create a repository, and a remote.
2. Assert that repository version is None.
3. Sync the remote.
4. Assert that repository version is not None.
5. Assert that the correct number of units were added and are present
in the repo.
6. Sync the remote one more time.
7. Assert that repository version is different from the previous one.
8. Assert that the same number of are present and that no units were
added.
"""
repo_api = RepositoriesFileApi(self.client)
remote_api = RemotesFileApi(self.client)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
body = gen_file_remote(url)
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
# Sync the repository.
self.assertEqual(repo.latest_version_href,
f"{repo.pulp_href}versions/0/")
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
self.assertIsNotNone(repo.latest_version_href)
self.assertDictEqual(get_content_summary(repo.to_dict()),
FILE_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo.to_dict()),
FILE_FIXTURE_SUMMARY)
# Sync the repository again.
latest_version_href = repo.latest_version_href
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
repo = repo_api.read(repo.pulp_href)
self.assertEqual(latest_version_href, repo.latest_version_href)
self.assertDictEqual(get_content_summary(repo.to_dict()),
FILE_FIXTURE_SUMMARY)
def test_all(self):
"""Verify whether is possible to create a remote without a URL.
This test targets the following issues:
* `Pulp #3395 <https://pulp.plan.io/issues/3395>`_
* `Pulp Smash #984 <https://github.com/pulp/pulp-smash/issues/984>`_
"""
body = gen_file_remote()
del body["url"]
with self.assertRaises(ApiException):
RemotesFileApi(gen_file_client()).create(body)
def test_all(self):
"""Verify whether is possible to create a remote without a URL.
This test targets the following issues:
* `Pulp #3395 <https://pulp.plan.io/issues/3395>`_
* `Pulp Smash #984 <https://github.com/PulpQE/pulp-smash/issues/984>`_
"""
body = gen_file_remote(url=utils.uuid4())
del body['url']
with self.assertRaises(HTTPError):
api.Client(config.get_config()).post(FILE_REMOTE_PATH, body)
def test_all(self):
"""Test whether a particular repository version can be published.
1. Create a repository with at least 2 repository versions.
2. Create a publication by supplying the latest ``repository_version``.
3. Assert that the publication ``repository_version`` attribute points
to the latest repository version.
4. Create a publication by supplying the non-latest ``repository_version``.
5. Assert that the publication ``repository_version`` attribute points
to the supplied repository version.
6. Assert that an exception is raised when providing two different
repository versions to be published at same time.
"""
cfg = config.get_config()
client = api.Client(cfg, api.json_handler)
body = gen_file_remote()
remote = client.post(FILE_REMOTE_PATH, body)
self.addCleanup(client.delete, remote["pulp_href"])
repo = client.post(REPO_PATH, gen_repo())
self.addCleanup(client.delete, repo["pulp_href"])
sync(cfg, remote, repo)
# Step 1
repo = client.get(repo["pulp_href"])
for file_content in get_content(repo)[FILE_CONTENT_NAME]:
client.post(repo["versions_href"],
{"add_content_units": [file_content["pulp_href"]]})
version_hrefs = tuple(ver["pulp_href"] for ver in get_versions(repo))
non_latest = choice(version_hrefs[:-1])
# Step 2
publication = create_file_publication(cfg, repo)
# Step 3
self.assertEqual(publication["repository_version"], version_hrefs[-1])
# Step 4
publication = create_file_publication(cfg, repo, non_latest)
# Step 5
self.assertEqual(publication["repository_version"], non_latest)
# Step 6
with self.assertRaises(HTTPError):
body = {
"repository": repo["pulp_href"],
"repository_version": non_latest
}
client.post(FILE_PUBLICATION_PATH, body)
def test_negative_create_file_remote_with_invalid_parameter(self):
"""Attempt to create file remote passing invalid parameter.
Assert response returns an error 400 including ["Unexpected field"].
This test targets the following issue:
* `Pulp Smash #1085 <https://github.com/PulpQE/pulp-smash/issues/1085>`_
"""
response = api.Client(self.cfg, api.echo_handler).post(
FILE_REMOTE_PATH, gen_file_remote(foo="bar"))
assert response.status_code == 400
assert response.json()["foo"] == ["Unexpected field"]
def setUp(self):
"""Create a new repository before each test."""
body = gen_file_remote()
remote = self.remote_api.create(body)
repo = self.repo_api.create(gen_repo())
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = self.repo_api.sync(repo.pulp_href,
repository_sync_data)
monitor_task(sync_response.task)
self.repo = self.repo_api.read(repo.pulp_href)
def setUpClass(cls):
"""
Initialize Pulp to make authorization assertions using client certificates.
0. Create a FileRepository
1. Create a FileRemote
2. Sync in a few units we can use to fetch with
3. Create a Publication
4. Create a CertGuard with the CA cert used to sign all client certificates
5. Create a Distribution for the publication that is protected by the CertGuard
"""
cls.teardown_cleanups = []
cls.cfg = config.get_config()
file_client = gen_file_client()
repo_api = RepositoriesFileApi(file_client)
remote_api = RemotesFileApi(file_client)
publications = PublicationsFileApi(file_client)
cls.distributions_api = DistributionsFileApi(file_client)
cls.repo = repo_api.create(gen_repo())
cls.teardown_cleanups.append((repo_api.delete, cls.repo.pulp_href))
body = gen_file_remote(policy="immediate")
remote = remote_api.create(body)
cls.teardown_cleanups.append((remote_api.delete, remote.pulp_href))
# Sync a Repository
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(cls.repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
cls.repo = repo_api.read(cls.repo.pulp_href)
# Create a publication.
publish_data = FileFilePublication(repository=cls.repo.pulp_href)
publish_response = publications.create(publish_data)
created_resources = monitor_task(publish_response.task)
publication_href = created_resources[0]
cls.teardown_cleanups.append((publications.delete, publication_href))
content_guard_href = cls._setup_content_guard()
# Create a distribution.
body = gen_distribution()
body["publication"] = publication_href
body["content_guard"] = content_guard_href
distribution_response = cls.distributions_api.create(body)
created_resources = monitor_task(distribution_response.task)
cls.distribution = cls.distributions_api.read(created_resources[0])
cls.teardown_cleanups.append((cls.distributions_api.delete, cls.distribution.pulp_href))
def setUp(self):
"""Create a new repository before each test."""
manifest_path = "/pulp/content/pulp_pre_upgrade_test/PULP_MANIFEST"
url = self.cfg.get_content_host_base_url() + manifest_path
body = gen_file_remote(url=url)
remote = self.remote_api.create(body)
repo = self.repo_api.create(gen_repo())
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = self.repo_api.sync(repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
self.repo = self.repo_api.read(repo.pulp_href)
def do_publish(self, download_policy):
"""Publish repository synced with lazy download policy."""
repo = self.client.post(FILE_REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo["pulp_href"])
body = gen_file_remote(policy=download_policy)
remote = self.client.post(FILE_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote["pulp_href"])
sync(self.cfg, remote, repo)
repo = self.client.get(repo["pulp_href"])
publication = create_file_publication(self.cfg, repo)
self.assertIsNotNone(publication["repository_version"], publication)
def setUp(self):
"""Create remote, repo, and distribution."""
self.remote = self.remote_api.create(gen_file_remote())
self.repo = self.repo_api.create(
gen_repo(manifest=self.CUSTOM_MANIFEST, autopublish=True))
response = self.distributions_api.create({
"name":
"foo",
"base_path":
"bar/foo",
"repository":
self.repo.pulp_href
})
distribution_href = monitor_task(response.task).created_resources[0]
self.distribution = self.distributions_api.read(distribution_href)
def test_negative_create_file_remote_with_invalid_parameter(self):
"""Attempt to create file remote passing invalid parameter.
Assert response returns an error 400 including ["Unexpected field"].
This test targets the following issue:
* `Pulp Smash #1085 <https://github.com/pulp/pulp-smash/issues/1085>`_
"""
with self.assertRaises(ApiException) as exc:
RemotesFileApi(gen_file_client()).create(
gen_file_remote(foo="bar"))
assert exc.exception.status == 400
assert json.loads(exc.exception.body)["foo"] == ["Unexpected field"]
def do_test(self, url):
"""Sync a repository given ``url`` on the remote."""
repo_api = RepositoriesFileApi(self.client)
remote_api = RemotesFileApi(self.client)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
body = gen_file_remote(url=url)
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = repo_api.sync(repo.pulp_href, repository_sync_data)
return monitor_task(sync_response.task)
def _setup_repositories(cls):
"""Create and sync a number of repositories to be exported."""
# create and remember a set of repo
repos = []
remotes = []
for r in range(NUM_REPOS):
a_repo = cls.repo_api.create(gen_repo())
# give it a remote and sync it
body = gen_file_remote()
remote = cls.remote_api.create(body)
repository_sync_data = RepositorySyncURL(remote=remote.pulp_href)
sync_response = cls.repo_api.sync(a_repo.pulp_href, repository_sync_data)
monitor_task(sync_response.task)
# remember it
repos.append(a_repo)
remotes.append(remote)
return repos, remotes
def test_03_set_remote_on_repository(self):
"""Test setting remotes on repositories."""
body = gen_file_remote()
remote = self.client.post(FILE_REMOTE_PATH, body)
# verify that syncing with no remote raises an error
with self.assertRaises(HTTPError):
self.client.post(urljoin(self.repo["pulp_href"], "sync/"))
# test setting the remote on the repo
self.client.patch(self.repo["pulp_href"], {"remote": remote["pulp_href"]})
# test syncing without a remote
self.client.post(urljoin(self.repo["pulp_href"], "sync/"))
repo = self.client.get(self.repo["pulp_href"])
self.assertEqual(repo["latest_version_href"], f"{repo['pulp_href']}versions/1/")
def do_sync(self, download_policy):
"""Sync repositories with the different ``download_policy``.
Do the following:
1. Create a repository, and a remote.
2. Assert that repository version is None.
3. Sync the remote.
4. Assert that repository version is not None.
5. Assert that the correct number of possible units to be downloaded
were shown.
6. Sync the remote one more time in order to create another repository
version.
7. Assert that repository version is the same as the previous one.
8. Assert that the same number of units are shown, and after the
second sync no extra units should be shown, since the same remote
was synced again.
"""
# delete orphans to assure that no content units are present on the
# file system
delete_orphans(self.cfg)
repo = self.client.post(FILE_REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo["pulp_href"])
body = gen_file_remote(policy=download_policy)
remote = self.client.post(FILE_REMOTE_PATH, body)
self.addCleanup(self.client.delete, remote["pulp_href"])
# Sync the repository.
self.assertIsNone(repo["latest_version_href"])
sync(self.cfg, remote, repo)
repo = self.client.get(repo["pulp_href"])
self.assertIsNotNone(repo["latest_version_href"])
self.assertDictEqual(get_content_summary(repo), FILE_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo),
FILE_FIXTURE_SUMMARY)
# Sync the repository again.
latest_version_href = repo["latest_version_href"]
sync(self.cfg, remote, repo)
repo = self.client.get(repo["pulp_href"])
self.assertEqual(latest_version_href, repo["latest_version_href"])
self.assertDictEqual(get_content_summary(repo), FILE_FIXTURE_SUMMARY)
def test_sync(self):
"""Sync repositories with the file plugin.
In order to sync a repository a remote has to be associated within
this repository. When a repository is created this version field is set
as None. After a sync the repository version is updated.
Do the following:
1. Create a repository, and a remote.
2. Assert that repository version is None.
3. Sync the remote.
4. Assert that repository version is not None.
5. Assert that the correct number of units were added and are present
in the repo.
6. Sync the remote one more time.
7. Assert that repository version is different from the previous one.
8. Assert that the same number of are present and that no units were
added.
"""
repo = self.client.post(REPO_PATH, gen_repo())
self.addCleanup(self.client.delete, repo["_href"])
body = gen_file_remote()
remote = self.client.post(FILE_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.assertIsNotNone(repo["_latest_version_href"])
self.assertDictEqual(get_content_summary(repo), FILE_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo),
FILE_FIXTURE_SUMMARY)
# Sync the repository again.
latest_version_href = repo["_latest_version_href"]
sync(self.cfg, remote, repo)
repo = self.client.get(repo["_href"])
self.assertNotEqual(latest_version_href, repo["_latest_version_href"])
self.assertDictEqual(get_content_summary(repo), FILE_FIXTURE_SUMMARY)
self.assertDictEqual(get_added_content_summary(repo), {})
def _gen_verbose_remote():
"""Return a semi-random dict for use in defining a remote.
For most tests, it's desirable to create remotes with as few attributes
as possible, so that the tests can specifically target and attempt to break
specific features. This module specifically targets remotes, so it makes
sense to provide as many attributes as possible.
Note that 'username' and 'password' are write-only attributes.
"""
attrs = gen_file_remote(url=choice((FILE_FIXTURE_MANIFEST_URL,
FILE2_FIXTURE_MANIFEST_URL)))
attrs.update({
"password": utils.uuid4(),
"username": utils.uuid4(),
"policy": choice(ON_DEMAND_DOWNLOAD_POLICIES),
})
return attrs
