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)