def setUpClass(cls):
"""
Create class-wide variables.
"""
cls.remote_api = RemotesPythonApi(gen_python_client())
cls.remote = cls.remote_api.create(gen_python_remote())
cls._original_remote = cls.remote
def test_on_demand(self):
"""Test whether a particular repository version can be published.
1. Create a repository
2. Create a remote with on_demand sync policy
3. Sync
4. Publish repository
"""
client = gen_python_client()
repo_api = RepositoriesPythonApi(client)
remote_api = RemotesPythonApi(client)
publications = PublicationsPypiApi(client)
body = gen_python_remote(policy="on_demand")
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.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 = PythonPythonPublication(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.assertEqual(publication.repository_version, repo.latest_version_href)
def setUpClass(cls):
"""
Check if packages to install through tests are already installed
"""
cls.client = gen_python_client()
cls.cli_client = cli.Client(cfg)
cls.PACKAGES = PYTHON_FIXTURES_PACKAGES
cls.PACKAGES_URLS = [
urljoin(urljoin(PYTHON_FIXTURE_URL, "packages/"), filename)
for filename in PYTHON_FIXTURES_FILENAMES
]
cls.PACKAGES_FILES = [{
"file": http_get(file)
} for file in cls.PACKAGES_URLS]
delete_orphans()
for pkg in cls.PACKAGES:
cls.assertFalse(
cls,
cls.check_install(cls.cli_client, pkg),
"{} is already installed".format(pkg),
)
cls.repo_api = RepositoriesPythonApi(cls.client)
cls.remote_api = RemotesPythonApi(cls.client)
cls.content_api = ContentPackagesApi(cls.client)
cls.publications_api = PublicationsPypiApi(cls.client)
cls.distro_api = DistributionsPypiApi(cls.client)
def setUpClass(cls):
"""Sets up the apis for the tests."""
client = gen_python_client()
cls.repo_api = RepositoriesPythonApi(client)
cls.rem_api = RemotesPythonApi(client)
cls.pub_api = PublicationsPypiApi(client)
cls.dis_api = DistributionsPypiApi(client)
cls.releases = [PYTHON_EGG_FILENAME, PYTHON_WHEEL_FILENAME]
def setUpClass(cls):
"""Create class-wide variables."""
cls.client = gen_python_client()
cls.remote = {}
cls.remote_api = RemotesPythonApi(cls.client)
cls.repo_api = RepositoriesPythonApi(cls.client)
cls.repo = cls.repo_api.create(gen_repo())
def setUpClass(cls):
"""Sets up the class"""
client = gen_python_client()
cls.cfg = config.get_config()
cls.repo_api = RepositoriesPythonApi(client)
cls.remote_api = RemotesPythonApi(client)
cls.publications_api = PublicationsPypiApi(client)
cls.distro_api = DistributionsPypiApi(client)
def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
client = gen_python_client()
cls.repo_api = RepositoriesPythonApi(client)
cls.remote_api = RemotesPythonApi(client)
cls.publications = PublicationsPypiApi(client)
cls.distributions = DistributionsPypiApi(client)
def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
cls.client = gen_python_client()
configuration = Configuration()
configuration.username = '******'
configuration.password = '******'
configuration.host = 'http://{}:24817'.format(socket.gethostname())
configuration.safe_chars_for_path_param = '/'
cls.core_client = CoreApiClient(configuration)
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_python_remote()
del body["url"]
with self.assertRaises(ApiException):
RemotesPythonApi(gen_python_client()).create(body)
def test_01_creation(self):
"""Create a remote from Bandersnatch config."""
remote_api = RemotesPythonApi(gen_python_client())
with NamedTemporaryFile() as config:
config.write(BANDERSNATCH_CONF)
config.seek(0)
name = utils.uuid4()
remote = remote_api.from_bandersnatch(config.name, name)
self.addCleanup(remote_api.delete, remote.pulp_href)
expected = _gen_expected_remote_body(name)
for key, val in expected.items():
with self.subTest(key=key):
self.assertEqual(remote.to_dict()[key], val, key)
def test_06_upload_file_with_repo(self):
"""
1) returns a task
2) check task status complete
3) check created resource of completed task
4) ensure there was two resources created and are a content unit and a repository version
"""
delete_orphans()
repo_api = RepositoriesPythonApi(gen_python_client())
repo = repo_api.create({"name": "foo"})
self.addCleanup(repo_api.delete, repo.pulp_href)
response = self.do_upload(repository=repo.pulp_href)
created_resources = monitor_task(response.task)
self.assertEqual(len(created_resources), 2)
content_list_search = self.python_content_api.list(
repository_version_added=created_resources[0]).results[0]
content_unit = self.python_content_api.read(created_resources[1])
self.assertEqual(content_unit.pulp_href, content_list_search.pulp_href)
self.check_package_data(content_unit.to_dict())
def setUpClass(cls):
"""Create class-wide variable."""
delete_orphans()
cls.content_unit = {}
cls.python_content_api = ContentPackagesApi(gen_python_client())
cls.artifact = gen_artifact()
def setUpClass(cls):
"""Create class-wide variables."""
cls.cfg = config.get_config()
cls.client = gen_python_client()
def test_all(self):
"""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/pulp/pulp-smash/issues/872>`_
"""
client = gen_python_client()
repo_api = RepositoriesPythonApi(client)
remote_api = RemotesPythonApi(client)
publications = PublicationsPypiApi(client)
distributions = DistributionsPypiApi(client)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.pulp_href)
body = gen_python_remote()
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
# Sync a Repository
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)
# Create a publication.
publish_data = PythonPythonPublication(repository=repo.pulp_href)
publish_response = publications.create(publish_data)
created_resources = monitor_task(publish_response.task)
publication_href = created_resources[0]
self.addCleanup(publications.delete, publication_href)
# Create a distribution.
body = gen_distribution()
body["publication"] = publication_href
distribution_response = distributions.create(body)
created_resources = monitor_task(distribution_response.task)
distribution = distributions.read(created_resources[0])
self.addCleanup(distributions.delete, distribution.pulp_href)
# Pick a content unit (of each type), and download it from both Pulp Fixtures…
unit_paths = [
choice(paths)
for paths in get_python_content_paths(repo.to_dict()).values()
]
fixtures_hashes = [
hashlib.sha256(
utils.http_get(
urljoin(urljoin(PYTHON_FIXTURE_URL, "packages/"),
unit_path[0]))).hexdigest()
for unit_path in unit_paths
]
# …and Pulp.
pulp_hashes = []
cfg = config.get_config()
for unit_path in unit_paths:
content = download_content_unit(cfg, distribution.to_dict(),
unit_path[1])
pulp_hashes.append(hashlib.sha256(content).hexdigest())
self.assertEqual(fixtures_hashes, pulp_hashes)
def setUpClass(cls):
"""Create class-wide variables."""
cls.client = gen_python_client()
def setUpClass(cls):
"""Sets up APIs used by tests."""
client = gen_python_client()
cls.repo_api = RepositoriesPythonApi(client)
cls.remote_api = RemotesPythonApi(client)
cls.pub_api = PublicationsPypiApi(client)
def setUpClass(cls):
"""Create class-wide variables."""
cls.remote_api = RemotesPythonApi(gen_python_client())
def setUpClass(cls):
"""Create class-wide variables."""
cls.remote_api = RemotesPythonApi(gen_python_client())
cls.remote = {}
cls.policies = ON_DEMAND_DOWNLOAD_POLICIES
cls.body = _gen_verbose_remote()
def setUpClass(cls):
"""Setup apis for all tests."""
client = gen_python_client()
cls.repo_api = RepositoriesPythonApi(client)
cls.pub_api = PublicationsPypiApi(client)
cls.dis_api = DistributionsPypiApi(client)
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 = gen_python_client()
repo_api = RepositoriesPythonApi(client)
remote_api = RemotesPythonApi(client)
publications = PublicationsPypiApi(client)
body = gen_python_remote()
remote = remote_api.create(body)
self.addCleanup(remote_api.delete, remote.pulp_href)
repo = repo_api.create(gen_repo())
self.addCleanup(repo_api.delete, repo.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)
# Step 1
repo = repo_api.read(repo.pulp_href)
for python_content in get_content(repo.to_dict())[PYTHON_CONTENT_NAME]:
modify_repo(cfg, repo.to_dict(), add_units=[python_content])
version_hrefs = tuple(ver["pulp_href"]
for ver in get_versions(repo.to_dict()))
non_latest = choice(version_hrefs[:-1])
# Step 2
publish_data = PythonPythonPublication(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)
# Step 3
self.assertEqual(publication.repository_version, version_hrefs[-1])
# Step 4
publish_data.repository = None
publish_data.repository_version = non_latest
publish_response = publications.create(publish_data)
created_resources = monitor_task(
publish_response.task).created_resources
publication_href = created_resources[0]
publication = publications.read(publication_href)
# Step 5
self.assertEqual(publication.repository_version, non_latest)
# Step 6
with self.assertRaises(ApiException):
body = {
"repository": repo.pulp_href,
"repository_version": non_latest
}
publications.create(body)
