def setUpModule():  # pylint:disable=invalid-name
    """Conditionally skip tests. Create repositories with fixture data."""
    cfg = config.get_config()
    if selectors.bug_is_untestable(1991, cfg.pulp_version):
        raise unittest.SkipTest('https://pulp.plan.io/issues/1991')
    set_up_module()

    # Fetch RPMs.
    _SIGNED_PACKAGES['rpm'] = utils.http_get(RPM_SIGNED_URL)
    _SIGNED_PACKAGES['srpm'] = utils.http_get(SRPM_SIGNED_URL)
    _UNSIGNED_PACKAGES['rpm'] = utils.http_get(RPM_UNSIGNED_URL)
    _UNSIGNED_PACKAGES['srpm'] = utils.http_get(SRPM_UNSIGNED_URL)
    if selectors.bug_is_testable(1806, cfg.pulp_version):
        _SIGNED_PACKAGES['drpm'] = utils.http_get(DRPM_SIGNED_URL)
        _UNSIGNED_PACKAGES['drpm'] = utils.http_get(DRPM_UNSIGNED_URL)

    # Create repos, and upload RPMs to them.
    client = api.Client(cfg, api.json_handler)
    try:
        repo = client.post(REPOSITORY_PATH, gen_repo())
        _REPOS['signed'] = repo
        for type_id, pkg in _SIGNED_PACKAGES.items():
            utils.upload_import_unit(cfg, pkg, {'unit_type_id': type_id}, repo)

        repo = client.post(REPOSITORY_PATH, gen_repo())
        _REPOS['unsigned'] = repo
        for type_id, pkg in _UNSIGNED_PACKAGES.items():
            utils.upload_import_unit(cfg, pkg, {'unit_type_id': type_id}, repo)
    except:  # noqa:E722
        _SIGNED_PACKAGES.clear()
        _UNSIGNED_PACKAGES.clear()
        for _ in range(len(_REPOS)):
            client.delete(_REPOS.popitem()[1]['_href'])
        raise
def setUpModule():  # pylint:disable=invalid-name
    """Conditionally skip tests. Create repositories with fixture data."""
    cfg = config.get_config()
    if selectors.bug_is_untestable(1991, cfg.version):
        raise unittest.SkipTest('https://pulp.plan.io/issues/1991')
    set_up_module()

    # Fetch RPMs.
    _SIGNED_PACKAGES['rpm'] = utils.http_get(RPM_URL)
    _SIGNED_PACKAGES['srpm'] = utils.http_get(SRPM_URL)
    _UNSIGNED_PACKAGES['rpm'] = utils.http_get(RPM_UNSIGNED_URL)
    _UNSIGNED_PACKAGES['srpm'] = utils.http_get(SRPM_UNSIGNED_URL)
    if selectors.bug_is_testable(1806, cfg.version):
        _SIGNED_PACKAGES['drpm'] = utils.http_get(DRPM_URL)
        _UNSIGNED_PACKAGES['drpm'] = utils.http_get(DRPM_UNSIGNED_URL)

    # Create repos, and upload RPMs to them.
    client = api.Client(cfg, api.json_handler)
    try:
        repo = client.post(REPOSITORY_PATH, gen_repo())
        _REPOS['signed'] = repo
        for type_id, pkg in _SIGNED_PACKAGES.items():
            utils.upload_import_unit(cfg, pkg, type_id, repo['_href'])

        repo = client.post(REPOSITORY_PATH, gen_repo())
        _REPOS['unsigned'] = repo
        for type_id, pkg in _UNSIGNED_PACKAGES.items():
            utils.upload_import_unit(cfg, pkg, type_id, repo['_href'])
    except:
        _SIGNED_PACKAGES.clear()
        _UNSIGNED_PACKAGES.clear()
        for _ in range(len(_REPOS)):
            client.delete(_REPOS.popitem()[1]['_href'])
        raise
Пример #3
0
    def test_all(self):
        """Add a content unit to a repo in the middle of several publishes."""
        cfg = config.get_config()
        if selectors.bug_is_untestable(2532, cfg.pulp_version):
            self.skipTest('https://pulp.plan.io/issues/2532')
        rpms = (utils.http_get(RPM_UNSIGNED_URL),
                utils.http_get(RPM2_UNSIGNED_URL))

        # Create a user and a repository.
        ssh_user, priv_key = self.make_user(cfg)
        ssh_identity_file = self.write_private_key(cfg, priv_key)
        repo = self.make_repo(
            cfg, {
                'remote': {
                    'host': urlparse(cfg.get_base_url()).hostname,
                    'root': '/home/' + ssh_user,
                    'ssh_identity_file': ssh_identity_file,
                    'ssh_user': ssh_user,
                }
            })

        # Add content, publish w/yum, add more content, publish w/rsync.
        dists = get_dists_by_type_id(cfg, repo)
        for i, key in enumerate(('yum_distributor', 'rpm_rsync_distributor')):
            utils.upload_import_unit(cfg, rpms[i], {'unit_type_id': 'rpm'},
                                     repo)
            utils.publish_repo(cfg, repo, {'id': dists[key]['id']})
        self.verify_remote_units_path(cfg, dists['rpm_rsync_distributor'], 1)

        # Publish with yum and rsync, respectively.
        for key in 'yum_distributor', 'rpm_rsync_distributor':
            utils.publish_repo(cfg, repo, {'id': dists[key]['id']})
        self.verify_remote_units_path(cfg, dists['rpm_rsync_distributor'], 1)
Пример #4
0
 def test_01_add_unit(self):
     """Add a content unit to the repository. Publish the repository."""
     repo_before = self.get_repo()
     rpm = utils.http_get(RPM_UNSIGNED_URL)
     utils.upload_import_unit(
         self.cfg,
         rpm,
         {'unit_type_id': 'rpm'},
         self.repo,
     )
     utils.publish_repo(self.cfg, repo_before)
     repo_after = self.get_repo()
     with self.subTest(comment='last_unit_added'):
         if selectors.bug_is_untestable(1847, self.cfg.pulp_version):
             self.skipTest('https://pulp.plan.io/issues/1847')
         pre = repo_before['last_unit_added']
         post = repo_after['last_unit_added']
         self.assertIsNone(pre)
         self.assertIsNotNone(post)
     with self.subTest(comment='last_unit_removed'):
         pre = repo_before['last_unit_removed']
         post = repo_after['last_unit_removed']
         self.assertIsNone(pre)
         self.assertIsNone(post)
     with self.subTest(comment='last_publish'):
         pre = repo_before['distributors'][0]['last_publish']
         post = repo_after['distributors'][0]['last_publish']
         self.assertIsNone(pre)
         self.assertIsNotNone(post)
Пример #5
0
 def test_all(self):
     """Test that uploading DRPM with checksumtype specified works."""
     if selectors.bug_is_untestable(1806, self.cfg.pulp_version):
         raise unittest.SkipTest('https://pulp.plan.io/issues/1806')
     if selectors.bug_is_untestable(2627, self.cfg.pulp_version):
         raise unittest.SkipTest('https://pulp.plan.io/issues/2627')
     client = api.Client(self.cfg)
     repo = client.post(REPOSITORY_PATH, gen_repo()).json()
     self.addCleanup(client.delete, repo['_href'])
     drpm = utils.http_get(DRPM_UNSIGNED_URL)
     utils.upload_import_unit(
         self.cfg,
         drpm,
         {
             'unit_type_id': 'drpm',
             'unit_metadata': {
                 'checksumtype': 'sha256'
             },
         },
         repo,
     )
     units = utils.search_units(self.cfg, repo, {})
     self.assertEqual(len(units), 1, units)
     # Test if DRPM extracted correct metadata for creating filename.
     self.assertEqual(
         units[0]['metadata']['filename'],
         DRPM,
     )
 def test_all(self):
     """Test whether one can upload an RPM with non-ascii metadata."""
     cfg = config.get_config()
     client = api.Client(cfg, api.json_handler)
     repo = client.post(REPOSITORY_PATH, gen_repo())
     self.addCleanup(client.delete, repo['_href'])
     rpm = utils.http_get(RPM_WITH_NON_ASCII_URL)
     utils.upload_import_unit(cfg, rpm, {'unit_type_id': 'rpm'}, repo)
 def test_all(self):
     """Test whether one can upload an RPM with non-ascii metadata."""
     cfg = config.get_config()
     if selectors.bug_is_untestable(1903, cfg.pulp_version):
         self.skipTest('https://pulp.plan.io/issues/1903')
     client = api.Client(cfg, api.json_handler)
     repo = client.post(REPOSITORY_PATH, gen_repo())
     self.addCleanup(client.delete, repo['_href'])
     rpm = utils.http_get(RPM_WITH_NON_UTF_8_URL)
     utils.upload_import_unit(cfg, rpm, {'unit_type_id': 'rpm'}, repo)
Пример #8
0
 def upload_import_unit(url):
     """Upload and import the unit at ``url`` to ``repo``."""
     unit = utils.http_get(url)
     utils.upload_import_unit(
         self.cfg, unit, {
             'unit_key': {
                 'filename': basename(urlparse(url).path)
             },
             'unit_type_id': 'python_package',
         }, repo)
Пример #9
0
    def test_all(self):
        """Test whether copied files retain their original mtime.

        This test targets the following issues:

        * `Pulp #2783 <https://pulp.plan.io/issues/2783>`_
        * `Pulp Smash #720 <https://github.com/PulpQE/pulp-smash/issues/720>`_

        Do the following:

        1. Create, sync and publish a repository, with ``generate_sqlite`` set
           to true.
        2. Get the ``mtime`` of the sqlite files.
        3. Upload an RPM package into the repository, and sync the repository.
        4. Get the ``mtime`` of the sqlite files again. Verify that the mtimes
           are the same.
        """
        cfg = config.get_config()
        if selectors.bug_is_untestable(2783, cfg.pulp_version):
            self.skipTest('https://pulp.plan.io/issues/2783')

        # Create, sync and publish a repository.
        client = api.Client(cfg, api.json_handler)
        body = gen_repo()
        body['importer_config']['feed'] = RPM_UNSIGNED_FEED_URL
        body['distributors'] = [gen_distributor()]
        body['distributors'][0]['distributor_config']['generate_sqlite'] = True
        repo = client.post(REPOSITORY_PATH, body)
        self.addCleanup(client.delete, repo['_href'])
        repo = client.get(repo['_href'], params={'details': True})
        utils.sync_repo(cfg, repo)
        utils.publish_repo(cfg, repo)

        # Get the mtime of the sqlite files.
        cli_client = cli.Client(cfg, cli.echo_handler)
        cmd = '' if utils.is_root(cfg) else 'sudo '
        cmd += "bash -c \"stat --format %Y '{}'/*\"".format(
            os.path.join(
                _PATH,
                repo['distributors'][0]['config']['relative_url'],
                'repodata',
            ))
        mtimes_pre = (
            cli_client.machine.session().run(cmd)[1].strip().split().sort())

        # Upload to the repo, and sync it.
        rpm = utils.http_get(RPM_SIGNED_URL)
        utils.upload_import_unit(cfg, rpm, {'unit_type_id': 'rpm'}, repo)
        utils.sync_repo(cfg, repo)

        # Get the mtime of the sqlite files again.
        time.sleep(1)
        mtimes_post = (
            cli_client.machine.session().run(cmd)[1].strip().split().sort())
        self.assertEqual(mtimes_pre, mtimes_post)
Пример #10
0
    def test_upload(self):
        """Test whether Pulp recognizes an uploaded RPM's vendor information.

        Create a repository, upload an RPM with a non-null vendor, and perform
        several checks. See :meth:`do_test`.
        """
        client = api.Client(self.cfg, api.json_handler)
        repo = client.post(REPOSITORY_PATH, gen_repo())
        self.addCleanup(client.delete, repo['_href'])
        rpm = utils.http_get(RPM_WITH_VENDOR_URL)
        utils.upload_import_unit(self.cfg, rpm, {'unit_type_id': 'rpm'}, repo)
        self.do_test(repo)
Пример #11
0
    def test_all(self):
        """Publish a repository with the repoview feature on and off."""
        cfg = config.get_config()
        if cfg.version < Version('2.9'):
            self.skipTest('https://pulp.plan.io/issues/189')

        # Create a repo, and add content
        client = api.Client(cfg, api.json_handler)
        body = gen_repo()
        body['distributors'] = [gen_distributor()]
        repo_href = client.post(constants.REPOSITORY_PATH, body)['_href']
        self.addCleanup(client.delete, repo_href)
        rpm = utils.http_get(constants.RPM_UNSIGNED_URL)
        utils.upload_import_unit(cfg, rpm, 'rpm', repo_href)

        # Gather some facts about the repo distributor
        dist = client.get(urljoin(repo_href, 'distributors/'))[0]
        dist_url = urljoin('/pulp/repos/', dist['config']['relative_url'])

        # Publish the repo
        client.response_handler = api.safe_handler
        client.post(urljoin(repo_href, 'actions/publish/'), {'id': dist['id']})
        response = client.get(dist_url)
        with self.subTest(comment='first publish'):
            self.assertEqual(len(response.history), 0, response.history)

        # Publish the repo a second time
        client.post(
            urljoin(repo_href, 'actions/publish/'),
            {
                'id': dist['id'],
                'override_config': {
                    'generate_sqlite': True,
                    'repoview': True,
                }
            },
        )
        response = client.get(dist_url)
        with self.subTest(comment='second publish'):
            self.assertEqual(len(response.history), 1, response.history)
            self.assertEqual(
                response.request.url,
                urljoin(response.history[0].request.url,
                        'repoview/index.html'))

        # Publish the repo a third time
        if selectors.bug_is_untestable(2349, cfg.version):
            self.skipTest('https://pulp.plan.io/issues/2349')
        client.post(urljoin(repo_href, 'actions/publish/'), {'id': dist['id']})
        response = client.get(dist_url)
        with self.subTest(comment='third publish'):
            self.assertEqual(len(response.history), 0, response.history)
    def test_unsigned_packages(self):
        """Import unsigned DRPM, RPM and SRPM packages into the repository.

        Verify that each import succeeds.
        """
        for key, package in _UNSIGNED_PACKAGES.items():
            with self.subTest(key=key):
                utils.upload_import_unit(
                    self.cfg,
                    package,
                    key.split(' ')[-1],
                    self.repo_href,
                )
    def test_unsigned_packages(self):
        """Import unsigned DRPM, RPM and SRPM packages into the repository.

        Verify that each import succeeds.
        """
        for key, package in _UNSIGNED_PACKAGES.items():
            with self.subTest(key=key):
                utils.upload_import_unit(
                    self.cfg,
                    package,
                    key.split(' ')[-1],
                    self.repo_href,
                )
    def test_signed_packages(self):
        """Import signed DRPM, RPM and SRPM packages into the repo.

        Verify that each import succeeds.
        """
        for key, package in _SIGNED_PACKAGES.items():
            with self.subTest(key=key):
                utils.upload_import_unit(
                    self.cfg,
                    package,
                    {'unit_type_id': key.split(' ')[-1]},
                    self.repo,
                )
    def test_signed_packages(self):
        """Import signed DRPM, RPM and SRPM packages into the repository.

        Verify that each import fails.
        """
        for key, package in _SIGNED_PACKAGES.items():
            with self.subTest(key=key):
                with self.assertRaises(exceptions.TaskReportError):
                    utils.upload_import_unit(
                        self.cfg,
                        package,
                        key.split(' ')[-1],
                        self.repo_href,
                    )
    def test_unsigned_packages(self):
        """Import unsigned DRPM, RPM and SRPM packages into the repo.

        Verify that each import fails.
        """
        for key, package in _UNSIGNED_PACKAGES.items():
            with self.subTest(key=key):
                with self.assertRaises(exceptions.TaskReportError):
                    utils.upload_import_unit(
                        self.cfg,
                        package,
                        {'unit_type_id': key.split(' ')[-1]},
                        self.repo,
                    )
    def test_signed_packages(self):
        """Import signed DRPM, RPM and SRPM packages into the repository.

        Verify that each import fails.
        """
        for key, package in _SIGNED_PACKAGES.items():
            with self.subTest(key=key):
                with self.assertRaises(exceptions.TaskReportError):
                    utils.upload_import_unit(
                        self.cfg,
                        package,
                        key.split(' ')[-1],
                        self.repo_href,
                    )
Пример #18
0
    def test_all(self):
        """Publish a repository with the repoview feature on and off."""
        cfg = config.get_config()
        if cfg.pulp_version < Version('2.9'):
            self.skipTest('https://pulp.plan.io/issues/189')

        # Create a repo, and add content
        client = api.Client(cfg)
        body = gen_repo()
        body['distributors'] = [gen_distributor()]
        repo = client.post(REPOSITORY_PATH, body).json()
        self.addCleanup(client.delete, repo['_href'])
        rpm = utils.http_get(constants.RPM_UNSIGNED_URL)
        utils.upload_import_unit(cfg, rpm, {'unit_type_id': 'rpm'}, repo)

        # Get info about the repo distributor
        repo = client.get(repo['_href'], params={'details': True}).json()
        pub_path = urljoin('/pulp/repos/',
                           repo['distributors'][0]['config']['relative_url'])

        # Publish the repo
        utils.publish_repo(cfg, repo)
        response = client.get(pub_path)
        with self.subTest(comment='first publish'):
            self.assertEqual(len(response.history), 0, response.history)

        # Publish the repo a second time
        utils.publish_repo(
            cfg, repo, {
                'id': repo['distributors'][0]['id'],
                'override_config': {
                    'generate_sqlite': True,
                    'repoview': True
                },
            })
        response = client.get(pub_path)
        with self.subTest(comment='second publish'):
            self.assertEqual(len(response.history), 1, response.history)
            self.assertEqual(
                response.request.url,
                urljoin(response.history[0].request.url,
                        'repoview/index.html'))

        # Publish the repo a third time
        if selectors.bug_is_untestable(2349, cfg.pulp_version):
            self.skipTest('https://pulp.plan.io/issues/2349')
        utils.publish_repo(cfg, repo)
        response = client.get(pub_path)
        with self.subTest(comment='third publish'):
            self.assertEqual(len(response.history), 0, response.history)
    def test_all(self):
        """Publish a repository with the repoview feature on and off."""
        cfg = config.get_config()
        if cfg.version < Version('2.9'):
            self.skipTest('https://pulp.plan.io/issues/189')

        # Create a repo, and add content
        client = api.Client(cfg, api.json_handler)
        body = gen_repo()
        body['distributors'] = [gen_distributor()]
        repo_href = client.post(constants.REPOSITORY_PATH, body)['_href']
        self.addCleanup(client.delete, repo_href)
        rpm = utils.http_get(constants.RPM_UNSIGNED_URL)
        utils.upload_import_unit(cfg, rpm, 'rpm', repo_href)

        # Gather some facts about the repo distributor
        dist = client.get(urljoin(repo_href, 'distributors/'))[0]
        dist_url = urljoin('/pulp/repos/', dist['config']['relative_url'])

        # Publish the repo
        client.response_handler = api.safe_handler
        client.post(urljoin(repo_href, 'actions/publish/'), {'id': dist['id']})
        response = client.get(dist_url)
        with self.subTest(comment='first publish'):
            self.assertEqual(len(response.history), 0, response.history)

        # Publish the repo a second time
        client.post(
            urljoin(repo_href, 'actions/publish/'),
            {'id': dist['id'], 'override_config': {
                'generate_sqlite': True,
                'repoview': True,
            }},
        )
        response = client.get(dist_url)
        with self.subTest(comment='second publish'):
            self.assertEqual(len(response.history), 1, response.history)
            self.assertEqual(
                response.request.url,
                urljoin(response.history[0].request.url, 'repoview/index.html')
            )

        # Publish the repo a third time
        if selectors.bug_is_untestable(2349, cfg.version):
            self.skipTest('https://pulp.plan.io/issues/2349')
        client.post(urljoin(repo_href, 'actions/publish/'), {'id': dist['id']})
        response = client.get(dist_url)
        with self.subTest(comment='third publish'):
            self.assertEqual(len(response.history), 0, response.history)
Пример #20
0
    def test_all(self):
        """Publish with a yum and rsync distributor twice."""
        cfg = config.get_config()
        if selectors.bug_is_untestable(2666, cfg.pulp_version):
            self.skipTest('https://pulp.plan.io/issues/2666')
        if check_issue_2844(cfg):
            self.skipTest('https://pulp.plan.io/issues/2844')

        # Create a user and a repository.
        ssh_user, priv_key = self.make_user(cfg)
        ssh_identity_file = self.write_private_key(cfg, priv_key)
        repo = self.make_repo(
            cfg, {
                'remote': {
                    'host': urlparse(cfg.get_base_url()).hostname,
                    'root': '/home/' + ssh_user,
                    'ssh_identity_file': ssh_identity_file,
                    'ssh_user': ssh_user,
                }
            })

        # Add content.
        for url in (RPM_UNSIGNED_URL, RPM2_UNSIGNED_URL):
            utils.upload_import_unit(cfg, utils.http_get(url),
                                     {'unit_type_id': 'rpm'}, repo)
        dists = get_dists_by_type_id(cfg, repo)

        # See https://pulp.plan.io/issues/2844#note-11
        time.sleep(2)

        # Publish with yum and rsync.
        for dist in 'yum_distributor', 'rpm_rsync_distributor':
            report = (utils.publish_repo(cfg, repo, {
                'id': dists[dist]['id']
            }).json())
            publish_task = self.get_publish_task(cfg, report)
        num_processed = self.get_num_processed(publish_task)
        with self.subTest(comment='first rsync publish'):
            self.assertEqual(num_processed, 2, publish_task)

        # Publish with yum and rsync again.
        for dist in 'yum_distributor', 'rpm_rsync_distributor':
            report = (utils.publish_repo(cfg, repo, {
                'id': dists[dist]['id']
            }).json())
            publish_task = self.get_publish_task(cfg, report)
        num_processed = self.get_num_processed(publish_task)
        with self.subTest(comment='second rsync publish'):
            self.assertEqual(num_processed, 0, publish_task)
Пример #21
0
    def test_01_upload_publish(self):
        """Upload an RPM to the first repository, and publish it.

        Execute :meth:`verify_repo_search` and :meth:`verify_repo_download`.
        """
        repo = self.repos[0]
        utils.upload_import_unit(
            self.cfg,
            self.rpm,
            {'unit_type_id': 'rpm'},
            repo,
        )
        utils.publish_repo(self.cfg, repo)
        self.verify_repo_search(repo)
        self.verify_repo_download(repo)
Пример #22
0
    def test_all(self):
        """Publish a repository with the repoview feature on and off."""
        cfg = config.get_config()
        if cfg.version < Version('2.9'):
            self.skipTest('https://pulp.plan.io/issues/189')

        # Create a repo, and add content
        client = api.Client(cfg)
        body = gen_repo()
        body['distributors'] = [gen_distributor()]
        repo = client.post(constants.REPOSITORY_PATH, body).json()
        self.addCleanup(client.delete, repo['_href'])
        rpm = utils.http_get(constants.RPM_UNSIGNED_URL)
        utils.upload_import_unit(cfg, rpm, 'rpm', repo['_href'])

        # Get info about the repo distributor
        repo = client.get(repo['_href'], params={'details': True}).json()
        pub_path = urljoin(
            '/pulp/repos/',
            repo['distributors'][0]['config']['relative_url']
        )

        # Publish the repo
        utils.publish_repo(cfg, repo)
        response = client.get(pub_path)
        with self.subTest(comment='first publish'):
            self.assertEqual(len(response.history), 0, response.history)

        # Publish the repo a second time
        utils.publish_repo(cfg, repo, {
            'id': repo['distributors'][0]['id'],
            'override_config': {'generate_sqlite': True, 'repoview': True},
        })
        response = client.get(pub_path)
        with self.subTest(comment='second publish'):
            self.assertEqual(len(response.history), 1, response.history)
            self.assertEqual(
                response.request.url,
                urljoin(response.history[0].request.url, 'repoview/index.html')
            )

        # Publish the repo a third time
        if selectors.bug_is_untestable(2349, cfg.version):
            self.skipTest('https://pulp.plan.io/issues/2349')
        utils.publish_repo(cfg, repo)
        response = client.get(pub_path)
        with self.subTest(comment='third publish'):
            self.assertEqual(len(response.history), 0, response.history)
    def _create_repo_import_unit(self, pkg_url):
        """Create a repository, and import the given package into it.

        Schedule the repository and all orphan content units for deletion.
        Return the repository's href.
        """
        self.addCleanup(self.client.delete, ORPHANS_PATH)
        repo_href = self.client.post(REPOSITORY_PATH, gen_repo())['_href']
        self.addCleanup(self.client.delete, repo_href)

        pkg = utils.http_get(pkg_url)
        pkg_filename = _get_pkg_filename(pkg_url)
        pkg_unit_type = _get_pkg_unit_type(pkg_filename)
        utils.upload_import_unit(self.cfg, pkg, pkg_unit_type, repo_href)

        return repo_href
    def test_all_packages(self):
        """Import signed and unsigned DRPM, RPM & SRPM packages into the repo.

        Verify that each import succeeds.
        """
        for key, package in _PACKAGES.items():
            if (key.endswith('drpm') and
                    selectors.bug_is_untestable(1806, self.cfg.version)):
                continue
            with self.subTest(key=key):
                utils.upload_import_unit(
                    self.cfg,
                    package,
                    key.split(' ')[-1],
                    self.repo_href,
                )
Пример #25
0
    def do_test(self, feed, type_id, body, unit_key=None):
        """Test how well Pulp can deal with duplicate unit uploads.

        Do the following:

        1. Create a new feed-less repository.
        2. Upload content and import it into the repository. Assert the upload
           and import was successful.
        3. Upload identical content and import it into the repository.

        The second upload should silently fail for all Pulp releases in the 2.x
        series.
        """
        if unit_key is None:
            unit_key = {}
        client = api.Client(self.cfg, api.json_handler)
        unit = utils.http_get(feed)
        repo = client.post(REPOSITORY_PATH, body)
        self.addCleanup(client.delete, repo['_href'])
        for _ in range(2):
            call_report = utils.upload_import_unit(self.cfg, unit, {
                'unit_type_id': type_id,
                'unit_key': unit_key
            }, repo)
            self.assertIsNone(call_report['result'])
    def _create_repo_import_unit(self, pkg_url):
        """Create a repository, and import the given package into it.

        Schedule the repository and all orphan content units for deletion.
        Return the repository's href.
        """
        self.addCleanup(self.client.delete, ORPHANS_PATH)
        repo_href = self.client.post(REPOSITORY_PATH, gen_repo())['_href']
        self.addCleanup(self.client.delete, repo_href)

        pkg = utils.http_get(pkg_url)
        pkg_filename = _get_pkg_filename(pkg_url)
        pkg_unit_type = _get_pkg_unit_type(pkg_filename)
        utils.upload_import_unit(self.cfg, pkg, pkg_unit_type, repo_href)

        return repo_href
Пример #27
0
    def test_all(self):
        """Import a DRPM into a repository and search it for content units."""
        cfg = config.get_config()
        if selectors.bug_is_untestable(1806, cfg.pulp_version):
            self.skipTest('https://pulp.plan.io/issues/1806')
        client = api.Client(cfg)
        repo = client.post(REPOSITORY_PATH, gen_repo()).json()
        self.addCleanup(client.delete, repo['_href'])
        drpm = utils.http_get(DRPM_UNSIGNED_URL)
        utils.upload_import_unit(cfg, drpm, {'unit_type_id': 'drpm'}, repo)
        units = utils.search_units(cfg, repo)

        # Test if DRPM has been uploaded successfully
        self.assertEqual(len(units), 1)

        # Test if DRPM extracted correct metadata for creating filename
        self.assertEqual(units[0]['metadata']['filename'], DRPM)
Пример #28
0
    def test_all(self):  # pylint:disable=no-self-use
        """Upload an ISO file into an ISO repository.

        Specifically, do the following:

        1. Create an ISO repository.
        2. Upload :data:`pulp_smash.constants.FILE_URL` to the repository.
        3. Publish the repository.
        4. Download the published ISO, and assert it's equal to the uploaded
           ISO.
        """
        # create a repo
        cfg = config.get_config()
        client = api.Client(cfg, api.json_handler)
        body = {
            'id': utils.uuid4(),
            'importer_type_id': 'iso_importer',
            'distributors': [{
                'auto_publish': False,
                'distributor_id': utils.uuid4(),
                'distributor_type_id': 'iso_distributor',
            }],
        }
        repo = client.post(REPOSITORY_PATH, body)
        self.addCleanup(client.delete, repo['_href'])
        repo = client.get(repo['_href'], params={'details': True})

        # upload an ISO to the repository
        iso = utils.http_get(FILE_URL)
        iso_name = os.path.basename(urlsplit(FILE_URL).path)
        utils.upload_import_unit(cfg, iso, {
            'unit_type_id': 'iso',
            'unit_key': {
                'checksum': hashlib.sha256(iso).hexdigest(),
                'name': iso_name,
                'size': len(iso),
            },
        }, repo)

        # publish the repository, and get the published ISO
        utils.publish_repo(cfg, repo)
        client.response_handler = api.safe_handler
        path = urljoin(urljoin('/pulp/isos/', repo['id'] + '/'), iso_name)
        iso2 = client.get(path).content
        self.assertEqual(iso, iso2)
Пример #29
0
    def test_all(self):
        """Test puppet_install_distributor.

        Do the following:

        1. Create a puppet repository with a puppet_install_distributor
        2. Upload a puppet module
        3. Publish the repository
        4. Check if the puppet_install_distributor config was properly used
        """
        cli_client = cli.Client(self.cfg)
        sudo = () if utils.is_root(self.cfg) else ('sudo', )

        # Create a directory and make sure Pulp can write to it.
        install_path = cli_client.run(('mktemp', '--directory')).stdout.strip()
        self.addCleanup(cli_client.run, sudo + ('rm', '-rf', install_path))
        cli_client.run(sudo + ('chown', 'apache:apache', install_path))
        cli_client.run(sudo + ('chcon', '-t', 'puppet_etc_t', install_path))

        # Make sure the pulp_manage_puppet boolean is enabled
        cli_client.run(sudo + ('semanage', 'boolean', '--modify', '--on',
                               'pulp_manage_puppet'))
        self.addCleanup(
            cli_client.run, sudo +
            ('semanage', 'boolean', '--modify', '--off', 'pulp_manage_puppet'))

        # Create and populate a Puppet repository.
        distributor = gen_install_distributor()
        distributor['distributor_config']['install_path'] = install_path
        body = gen_repo()
        body['distributors'] = [distributor]
        client = api.Client(self.cfg, api.json_handler)
        repo = client.post(REPOSITORY_PATH, body)
        self.addCleanup(client.delete, repo['_href'])
        repo = client.get(repo['_href'], params={'details': True})
        unit = utils.http_get(PUPPET_MODULE_URL_1)
        utils.upload_import_unit(self.cfg, unit,
                                 {'unit_type_id': 'puppet_module'}, repo)

        # Publish, and verify the module is present. (Dir has 700 permissions.)
        utils.publish_repo(self.cfg, repo)
        proc = cli_client.run(sudo +
                              ('runuser', '--shell', '/bin/sh', '--command',
                               'ls -1 {}'.format(install_path), '-', 'apache'))
        self.assertIn(PUPPET_MODULE_1['name'], proc.stdout.split('\n'), proc)
Пример #30
0
    def setUpClass(cls):
        """Import a SRPM into a repository and search it for content units.

        Specifically, this method does the following:

        1. Create a yum repository.
        2. Upload a SRPM into the repository.
        3. Search for all content units in the repository.
        """
        super(UploadSrpmTestCase, cls).setUpClass()
        if check_issue_2620(cls.cfg):
            raise unittest.SkipTest('https://pulp.plan.io/issues/2620')
        client = api.Client(cls.cfg)
        repo = client.post(REPOSITORY_PATH, gen_repo()).json()
        cls.resources.add(repo['_href'])
        srpm = utils.http_get(SRPM_UNSIGNED_URL)
        utils.upload_import_unit(cls.cfg, srpm, {'unit_type_id': 'srpm'}, repo)
        cls.units = utils.search_units(cls.cfg, repo, {}, api.safe_handler)
Пример #31
0
 def setUpClass(cls):
     """Create a Python repo. Upload a Python package into it twice."""
     super(DuplicateUploadsTestCase, cls).setUpClass()
     unit = utils.http_get(PYTHON_EGG_URL)
     unit_type_id = "python_package"
     client = api.Client(cls.cfg, api.json_handler)
     repo_href = client.post(REPOSITORY_PATH, gen_repo())["_href"]
     cls.resources.add(repo_href)
     cls.call_reports = tuple((utils.upload_import_unit(cls.cfg, unit, unit_type_id, repo_href) for _ in range(2)))
    def test_signed_packages(self):
        """Import signed DRPM, RPM and SRPM packages into the repository.

        Verify that each import fails.
        """
        for key, package in _PACKAGES.items():
            if key.startswith('unsigned'):
                continue
            if (key.endswith('drpm') and
                    selectors.bug_is_untestable(1806, self.cfg.version)):
                continue
            with self.subTest(key=key):
                with self.assertRaises(exceptions.TaskReportError):
                    utils.upload_import_unit(
                        self.cfg,
                        package,
                        key.split(' ')[-1],
                        self.repo_href,
                    )
    def setUpClass(cls):
        """Import a SRPM into a repository and search it for content units.

        Specifically, this method does the following:

        1. Create a yum repository.
        2. Upload a SRPM into the repository.
        3. Search for all content units in the repository.
        """
        super(UploadSrpmTestCase, cls).setUpClass()
        client = api.Client(cls.cfg)
        repo = client.post(REPOSITORY_PATH, gen_repo()).json()
        cls.resources.add(repo['_href'])
        srpm = utils.http_get(SRPM_UNSIGNED_URL)
        upload_import_unit(cls.cfg, srpm, 'srpm', repo['_href'])
        cls.repo_units = client.post(
            urljoin(repo['_href'], 'search/units/'),
            {'criteria': {}},
        )
Пример #34
0
    def setUpClass(cls):
        """Create, populate and publish a repository.

        More specifically, do the following:

        1. Create an RPM repository with a distributor.
        2. Populate the repository with an RPM and two errata, where one
           erratum references the RPM, and the other does not.
        3. Publish the repository Fetch and parse its ``updateinfo.xml`` file.
        """
        super(UpdateInfoTestCase, cls).setUpClass()
        if check_issue_3104(cls.cfg):
            raise unittest.SkipTest('https://pulp.plan.io/issues/3104')
        cls.errata = {key: _gen_errata() for key in ('full', 'partial')}
        del cls.errata['partial']['pkglist']
        cls.tasks = {}

        # Create a repo.
        client = api.Client(cls.cfg, api.json_handler)
        body = gen_repo()
        body['distributors'] = [gen_distributor()]
        repo = client.post(REPOSITORY_PATH, body)
        cls.resources.add(repo['_href'])

        try:
            # Populate and publish the repo.
            repo = client.get(repo['_href'], params={'details': True})
            unit = utils.http_get(RPM_UNSIGNED_URL)
            utils.upload_import_unit(cls.cfg, unit, {'unit_type_id': 'rpm'},
                                     repo)
            for key, erratum in cls.errata.items():
                report = utils.upload_import_erratum(cls.cfg, erratum,
                                                     repo['_href'])
                cls.tasks[key] = tuple(api.poll_spawned_tasks(cls.cfg, report))
            utils.publish_repo(cls.cfg, repo)

            # Fetch and parse updateinfo.xml.
            cls.updates_element = (get_repodata(cls.cfg,
                                                repo['distributors'][0],
                                                'updateinfo'))
        except:  # noqa:E722
            cls.tearDownClass()
            raise
Пример #35
0
    def setUpClass(cls):
        """Import a SRPM into a repository and search it for content units.

        Specifically, this method does the following:

        1. Create a yum repository.
        2. Upload a SRPM into the repository.
        3. Search for all content units in the repository.
        """
        super(UploadSrpmTestCase, cls).setUpClass()
        client = api.Client(cls.cfg)
        repo = client.post(REPOSITORY_PATH, gen_repo()).json()
        cls.resources.add(repo['_href'])
        srpm = utils.http_get(SRPM_UNSIGNED_URL)
        upload_import_unit(cls.cfg, srpm, 'srpm', repo['_href'])
        cls.repo_units = client.post(
            urljoin(repo['_href'], 'search/units/'),
            {'criteria': {}},
        )
    def setUpClass(cls):
        """Import a DRPM into a repository and search it for content units.

        Specifically, this method does the following:

        1. Create a yum repository.
        2. Upload a DRPM into the repository.
        3. Search for all content units in the repository.
        """
        super(UploadDrpmTestCase, cls).setUpClass()
        if selectors.bug_is_untestable(1806, cls.cfg.version):
            raise unittest.SkipTest('https://pulp.plan.io/issues/1806')
        client = api.Client(cls.cfg)
        repo = client.post(REPOSITORY_PATH, gen_repo()).json()
        cls.resources.add(repo['_href'])
        drpm = utils.http_get(DRPM_UNSIGNED_URL)
        upload_import_unit(cls.cfg, drpm, 'drpm', repo['_href'])
        cls.repo_units = client.post(
            urljoin(repo['_href'], 'search/units/'),
            {'criteria': {}},
        )
Пример #37
0
    def setUpClass(cls):
        """Import a DRPM into a repository and search it for content units.

        Specifically, this method does the following:

        1. Create a yum repository.
        2. Upload a DRPM into the repository.
        3. Search for all content units in the repository.
        """
        super(UploadDrpmTestCase, cls).setUpClass()
        if selectors.bug_is_untestable(1806, cls.cfg.version):
            raise unittest.SkipTest('https://pulp.plan.io/issues/1806')
        client = api.Client(cls.cfg)
        repo = client.post(REPOSITORY_PATH, gen_repo()).json()
        cls.resources.add(repo['_href'])
        drpm = utils.http_get(DRPM_UNSIGNED_URL)
        upload_import_unit(cls.cfg, drpm, 'drpm', repo['_href'])
        cls.repo_units = client.post(
            urljoin(repo['_href'], 'search/units/'),
            {'criteria': {}},
        )
Пример #38
0
 def setUpClass(cls):
     """Create a Puppet repository. Upload a Puppet module into it twice."""
     super(DuplicateUploadsTestCase, cls).setUpClass()
     unit = utils.http_get(PUPPET_MODULE_URL)
     unit_type_id = 'puppet_module'
     client = api.Client(cls.cfg, api.json_handler)
     repo_href = client.post(REPOSITORY_PATH, gen_repo())['_href']
     cls.resources.add(repo_href)
     cls.call_reports = tuple((
         utils.upload_import_unit(cls.cfg, unit, unit_type_id, repo_href)
         for _ in range(2)
     ))
Пример #39
0
    def test_all(self):
        """Test whether one invalid RPM upload fails and produces error details.

        This test targets the following issues.

        * `Pulp Smash #544 <https://github.com/PulpQE/pulp-smash/issues/544>`_
        * `Pulp #2543 <https://pulp.plan.io/issues/2543>`_
        * `Pulp #3090 <https://pulp.plan.io/issues/3090>`_

        Do the following:

        1. Create a RPM repository.
        2. Upload an invalid RPM to repository. Assert that upload fails, and
           that the returned error contains a descriptive message.
        3. Verify that the repository contains no RPMs.
        """
        cfg = config.get_config()
        if selectors.bug_is_untestable(2543, cfg.pulp_version):
            self.skipTest('https://pulp.plan.io/issues/2543')
        if selectors.bug_is_untestable(3090, cfg.pulp_version):
            self.skipTest('https://pulp.plan.io/issues/3090')
        client = api.Client(cfg, api.json_handler)
        repo = client.post(REPOSITORY_PATH, gen_repo())
        self.addCleanup(client.delete, repo['_href'])

        # Upload invalid RPM
        rpm = utils.http_get(RPM_INVALID_URL)
        with self.assertRaises(exceptions.TaskReportError) as context:
            utils.upload_import_unit(cfg, rpm, {'unit_type_id': 'rpm'}, repo)
        task = context.exception.task

        # Assert that rturned error contains a descriptive message
        self.assertIsNotNone(task['error']['description'])
        self.assertIn('upload', task['error']['description'])

        # Verify that the repository contains no RPMs
        rpm = utils.search_units(cfg, repo, {'type_ids': ('rpm', )})
        self.assertEqual(len(rpm), 0)
Пример #40
0
    def do_test(self, distributor_config_update):
        """Implement most of the test logic."""
        rpms = tuple(
            utils.http_get(url)
            for url in (RPM_UNSIGNED_URL, RPM2_UNSIGNED_URL))

        # Create a repository.
        client = api.Client(self.cfg, api.json_handler)
        body = gen_repo()
        body['distributors'] = [gen_distributor()]
        body['distributors'][0]['distributor_config'].update(
            distributor_config_update)
        repo = client.post(REPOSITORY_PATH, body)
        self.addCleanup(client.delete, repo['_href'])
        repo = client.get(repo['_href'], params={'details': True})

        # Upload an RPM, publish the repo, and count metadata files twice.
        cli_client = cli.Client(self.cfg)
        sudo = () if utils.is_root(self.cfg) else ('sudo', )
        find_repodata_cmd = sudo + (
            'find',
            os.path.join('/var/lib/pulp/published/yum/master/yum_distributor/',
                         str(repo['id'])), '-type', 'd', '-name', 'repodata')
        found = []
        for rpm in rpms:
            utils.upload_import_unit(
                self.cfg,
                rpm,
                {'unit_type_id': 'rpm'},
                repo,
            )
            utils.publish_repo(self.cfg, repo)
            repodata_path = cli_client.run(find_repodata_cmd).stdout.strip()
            found.append(
                cli_client.run(sudo + ('find', repodata_path, '-type',
                                       'f')).stdout.splitlines())
        return found
Пример #41
0
    def test_all(self):
        """Verify uploaded DRPMs have checksums of the requested type.

        Specifically, this method does the following:

        1. Create a yum repository.
        2. Upload a DRPM into the repository with "checksumtype" set to
           "md5".
        3. Assert that "checksumtype" was set to "md5".
        4. Assert that checksum value was calculated according to "md5".

        This test targets:

        * `Pulp #2774 <https://pulp.plan.io/issues/2774>`_
        * `Pulp Smash #663 <https://github.com/PulpQE/pulp-smash/issues/663>`_
        """
        cfg = config.get_config()
        client = api.Client(cfg, api.json_handler)
        repo = client.post(REPOSITORY_PATH, gen_repo())
        self.addCleanup(client.delete, repo['_href'])
        drpm = utils.http_get(DRPM_UNSIGNED_URL)
        utils.upload_import_unit(cfg, drpm, {
            'unit_metadata': {
                'checksumtype': 'md5'
            },
            'unit_type_id': 'drpm',
        }, repo)
        units = utils.search_units(cfg, repo)

        with self.subTest(comment='verify checksumtype'):
            self.assertEqual(units[0]['metadata']['checksumtype'], 'md5')
        with self.subTest(comment='verify checksum'):
            if selectors.bug_is_untestable(2774, cfg.pulp_version):
                self.skipTest('https://pulp.plan.io/issues/2774')
            self.assertEqual(units[0]['metadata']['checksum'],
                             units[0]['metadata']['checksums']['md5'])
Пример #42
0
 def test_post(self):
     """Assert the function makes an HTTP POST request."""
     with mock.patch.object(api, 'Client') as client:
         # post() is called twice, first to start a content upload and
         # second to import and upload. In both cases, a dict is returned.
         # Our dict mocks the first case, and just happens to work in the
         # second case too.
         client.return_value.post.return_value = {
             '_href': 'foo',
             'upload_id': 'bar',
         }
         response = utils.upload_import_unit(
             mock.Mock(),  # server_config
             b'my unit',
             'my unit type id',
             'http://example.com',  # repo_href
         )
     self.assertIs(response, client.return_value.post.return_value)
Пример #43
0
 def test_post(self):
     """Assert the function makes an HTTP POST request."""
     with mock.patch.object(api, 'Client') as client:
         # post() is called twice, first to start a content upload and
         # second to import and upload. In both cases, a dict is returned.
         # Our dict mocks the first case, and just happens to work in the
         # second case too.
         client.return_value.post.return_value = {
             '_href': 'foo',
             'upload_id': 'bar',
         }
         response = utils.upload_import_unit(
             mock.Mock(),  # server_config
             b'my unit',
             'my unit type id',
             'http://example.com',  # repo_href
         )
     self.assertIs(response, client.return_value.post.return_value)