def test_01_create_publisher(self): """Create a publisher.""" body = gen_publisher(self.repo) type(self).publisher = self.client.post(FILE_PUBLISHER_PATH, body) for key, val in body.items(): with self.subTest(key=key): self.assertEqual(self.publisher[key], val)
def test_04_fully_update(self): """Update a publisher using HTTP PUT.""" body = gen_publisher(self.repo) self.client.put(self.publisher['_href'], body) type(self).publisher = self.client.get(self.publisher['_href']) for key, val in body.items(): with self.subTest(key=key): self.assertEqual(self.publisher[key], val)
def test_03_partially_update(self): """Update a publisher using HTTP PATCH.""" body = gen_publisher() self.client.patch(self.publisher['_href'], body) type(self).publisher = self.client.get(self.publisher['_href']) for key, val in body.items(): with self.subTest(key=key): self.assertEqual(self.publisher[key], val)
def test_02_create_same_name(self): """Try to create a second publisher with an identical name. See: `Pulp Smash #1055 <https://github.com/PulpQE/pulp-smash/issues/1055>`_. """ body = gen_publisher() body['name'] = self.publisher['name'] with self.assertRaises(HTTPError): self.client.post(FILE_PUBLISHER_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_remote(urljoin(FILE_FEED_URL, 'PULP_MANIFEST')) 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_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 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/PulpQE/pulp-smash/issues/872>`_ """ cfg = config.get_config() if not selectors.bug_is_fixed(3502, cfg.pulp_version): self.skipTest('https://pulp.plan.io/issues/3502') client = api.Client(cfg, api.json_handler) repo = client.post(REPO_PATH, gen_repo()) self.addCleanup(client.delete, repo['_href']) body = gen_remote(urljoin(FILE_FEED_URL, 'PULP_MANIFEST')) remote = client.post(FILE_REMOTE_PATH, body) self.addCleanup(client.delete, remote['_href']) sync(cfg, remote, repo) repo = client.get(repo['_href']) # Create a publisher. publisher = client.post(FILE_PUBLISHER_PATH, gen_publisher()) self.addCleanup(client.delete, publisher['_href']) # Create a publication. publication = publish(cfg, publisher, repo) self.addCleanup(client.delete, publication['_href']) # Create a distribution. body = gen_distribution() body['publication'] = publication['_href'] distribution = client.post(DISTRIBUTION_PATH, body) self.addCleanup(client.delete, distribution['_href']) # Pick a file, and download it from both Pulp Fixtures… unit_path = choice(get_content_unit_paths(repo)) fixtures_hash = hashlib.sha256( utils.http_get(urljoin(FILE_FEED_URL, unit_path))).hexdigest() # …and Pulp. client.response_handler = api.safe_handler unit_url = cfg.get_hosts('api')[0].roles['api']['scheme'] unit_url += '://' + distribution['base_url'] + '/' unit_url = urljoin(unit_url, unit_path) pulp_hash = hashlib.sha256(client.get(unit_url).content).hexdigest() self.assertEqual(fixtures_hash, pulp_hash)