Example #1
0
 def setUp(self):
     self.unit_key = {
         'image_checksum': data.cirros_img_metadata['image_checksum']
     }
     self.source_repo = Repository('repo_source')
     self.dest_repo = Repository('repo_dest')
     self.conduit = mock.MagicMock()
     self.config = PluginCallConfiguration({}, {})
Example #2
0
 def setUp(self):
     self.source_repo = Repository('repo-source')
     self.dest_repo = Repository('repo-dest')
     self.rpm_units = model_factory.rpm_units(2)
     self.category_units = model_factory.category_units(2)
     self.group_units = model_factory.group_units(2)
     self.group1_names = self.group_units[0].metadata[
         'default_package_names']
     self.group2_names = self.group_units[1].metadata[
         'default_package_names']
     self.conduit = mock.MagicMock()
     self.config = PluginCallConfiguration({}, {}, {})
Example #3
0
    def test_relative_path_conflicts_with_both(self):
        repo = Repository('test')
        config = {'relative_url': 'zoo_repo'}
        conflicting_distributor = [{
            'repo_id': 'zoo_repo',
            'config': {
                'relative_url': 'zoo_repo'
            }
        }, {
            'repo_id': 'zoo_repo',
            'config': {}
        }]
        conduit = mock.MagicMock()
        conduit.get_repo_distributors_by_relative_url = mock.MagicMock(
            return_value=conflicting_distributor)
        error_messages = []

        configuration._check_for_relative_path_conflicts(
            repo, config, conduit, error_messages)
        messages = [
            ('Relative URL [zoo_repo] for repository [test] conflicts with existing '
             'relative URL [zoo_repo] for repository [zoo_repo]'),
            ('Relative URL [zoo_repo] for repository [test] conflicts with repo id for '
             'existing repository [zoo_repo]')
        ]
        self.assertEqual(len(error_messages), 2)
        self.assertEqual(error_messages, messages)
Example #4
0
 def test_ensure_tz_specified(self):
     """
     If the timezone is specified, the result should be the same.
     """
     dt = datetime.datetime.now(dateutils.local_tz())
     new_date = Repository._ensure_tz_specified(dt)
     self.assertEquals(new_date.tzinfo, dateutils.utc_tz())
Example #5
0
 def test_ensure_tz_none_object(self):
     """
     Test _ensure_tz_specified with None.
     """
     dt = None
     new_date = Repository._ensure_tz_specified(dt)
     self.assertEquals(new_date, None)
Example #6
0
 def test_ensure_tz_not_specified(self):
     """
     Make sure that a date without a timezone is given one.
     """
     dt = datetime.datetime.utcnow()
     new_date = Repository._ensure_tz_specified(dt)
     self.assertEquals(new_date.tzinfo, dateutils.utc_tz())
Example #7
0
 def test_ensure_tz_specified(self):
     """
     If the timezone is specified, the result should be the same.
     """
     dt = datetime.datetime.now(dateutils.local_tz())
     new_date = Repository._ensure_tz_specified(dt)
     self.assertEquals(new_date.tzinfo, dateutils.utc_tz())
Example #8
0
 def test_ensure_tz_none_object(self):
     """
     Test _ensure_tz_specified with None.
     """
     dt = None
     new_date = Repository._ensure_tz_specified(dt)
     self.assertEquals(new_date, None)
Example #9
0
 def setUp(self):
     super(TestSyncRepo, self).setUp()
     self.repo = Repository('repo1', working_dir='/a/b/c')
     self.repo.repo_obj = model.Repository(repo_id=self.repo.id)
     self.sync_conduit = mock.MagicMock()
     self.config = mock.MagicMock()
     self.importer = DockerImporter()
    def test_publish_repo(self, mock_publisher):
        repo = Repository('test')
        config = PluginCallConfiguration(None, None)
        conduit = RepoPublishConduit(repo.id, 'foo_repo')
        self.distributor.publish_repo(repo, conduit, config)

        mock_publisher.return_value.assert_called_once()
Example #11
0
 def test_ensure_tz_not_specified(self):
     """
     Make sure that a date without a timezone is given one.
     """
     dt = datetime.datetime.utcnow()
     new_date = Repository._ensure_tz_specified(dt)
     self.assertEquals(new_date.tzinfo, dateutils.utc_tz())
Example #12
0
 def setUp(self):
     self.metadata_files = metadata.MetadataFiles('http://pulpproject.org',
                                                  '/a/b/c',
                                                  DownloaderConfig())
     self.repo = Repository('repo1')
     self.config = PluginCallConfiguration({}, {})
     self.conduit = RepoSyncConduit(self.repo.id, 'yum_importer', 'abc123')
Example #13
0
    def _init_publisher(self):

        repo = Repository(self.repo_id, working_dir=self.working_dir)
        self.repo = repo

        conduit = RepoPublishConduit(repo.id, YUM_DISTRIBUTOR_ID)
        conduit.last_publish = mock.Mock(return_value=None)
        conduit.get_repo_scratchpad = mock.Mock(return_value={})

        config_defaults = {'http': True,
                           'https': True,
                           'relative_url': None,
                           'http_publish_dir': os.path.join(self.published_dir, 'http'),
                           'https_publish_dir': os.path.join(self.published_dir, 'https')}
        config = PluginCallConfiguration(None, None)
        config.default_config.update(config_defaults)

        self.publisher = publish.BaseYumRepoPublisher(repo, conduit, config, YUM_DISTRIBUTOR_ID,
                                                      working_dir=self.working_dir)
        self.publisher.get_checksum_type = mock.Mock(return_value=None)

        # mock out the repomd_file_context, so _publish_<step> can be called
        # outside of the publish() method
        self.publisher.repomd_file_context = mock.MagicMock()
        self.publisher.all_steps = mock.MagicMock()
Example #14
0
 def setUp(self):
     self.repo = Repository('repo_source')
     self.conduit = mock.MagicMock()
     self.config = PluginCallConfiguration({}, {})
     self.mock_unit = mock.Mock(type_id=constants.IMAGE_TYPE_ID,
                                unit_key={'image_id': 'foo'},
                                metadata={})
Example #15
0
    def test_cert_based_auth_ca_no_cert(self, mock_delete_protected_repo):
        repo = Repository('test')
        config = {'auth_ca': 'looks not so legit'}

        configuration.process_cert_based_auth(repo, config)

        mock_delete_protected_repo.assert_called_once_with(repo.id)
Example #16
0
 def setUp(self):
     self.working_dir = tempfile.mkdtemp()
     self.repo = Repository('test')
     self.repo.working_dir = self.working_dir
     self.config = PluginCallConfiguration(None, None)
     self.conduit = RepoPublishConduit(self.repo.id,
                                       TYPE_ID_DISTRIBUTOR_EXPORT)
Example #17
0
    def test_remove_cert_based_auth(self, mock_delete_protected_repo):
        repo = Repository('test')
        config = {}

        configuration.remove_cert_based_auth(repo, config)

        mock_delete_protected_repo.assert_called_once_with(repo.id)
Example #18
0
    def test_validate_config(self, *mock_methods):
        config_kwargs = {'http': True,
                         'https': True,
                         'relative_url': None,
                         'auth_ca': 'CA',
                         'auth_cert': 'CERT',
                         'checksum_type': 'sha256',
                         'http_publish_dir': '/http/path/',
                         'https_publish_dir': 'https/path/',
                         'protected': True,
                         'skip': {'drpms': 1},
                         'skip_pkg_tags': True,
                         'generate_sqlite': False}

        repo = Repository('test')
        config = self._generate_call_config(**config_kwargs)
        conduit = RepoConfigConduit(TYPE_ID_DISTRIBUTOR_YUM)

        valid, reasons = configuration.validate_config(repo, config, conduit)

        for mock_method in mock_methods:
            self.assertEqual(mock_method.call_count, 1)

        self.assertTrue(valid)
        self.assertEqual(reasons, None)
Example #19
0
    def test_uses_passed_available_units_when_requested(self, mock_find_units, mock_associate):
        """
        Assert that if the step is constructed with available_units passed in, the step's parent's
        available_units attribute is ignored.
        """
        demo_1 = self.DemoModel(key_field='a')
        demo_2 = self.DemoModel(key_field='b')
        demo_3 = self.DemoModel(key_field='c')
        self.parent.available_units = [demo_1, demo_2]
        available_units = [demo_1, demo_2, demo_3]
        fake_repo = Repository(id='fake-repo', repo_obj='fake_repo')
        step = publish_step.GetLocalUnitsStep('fake_importer_type', repo=fake_repo,
                                              available_units=available_units)
        step.parent = self.parent
        step.conduit = MagicMock()
        existing_demo = self.DemoModel(key_field='b', id='foo')
        mock_find_units.return_value = [existing_demo]

        step.process_main()

        # The parent step's available units only has demo 1 and 2, so this asserts that that is
        # being ignored and the correct available_units is being used instead.
        mock_find_units.assert_called_once_with((demo_1, demo_2, demo_3))
        # the one that exists is associated
        mock_associate.assert_called_once_with('fake_repo', existing_demo)
        # the two that do not exist yet are added to the download list
        self.assertEqual(step.units_to_download, [demo_1, demo_3])
Example #20
0
 def setUp(self):
     super(TestGetLocalUnitsStep, self).setUp()
     self.parent = MagicMock()
     fake_repo = Repository(id='fake-repo', repo_obj='fake_repo')
     self.step = publish_step.GetLocalUnitsStep('fake_importer_type', repo=fake_repo)
     self.step.parent = self.parent
     self.step.conduit = MagicMock()
     self.parent.available_units = []
Example #21
0
    def test_get_repo_relative_path_repo_id(self):
        repo_id = 'Highlander'
        repo = Repository(repo_id)
        config = self._generate_call_config()

        relative_dir = configuration.get_repo_relative_path(repo, config)

        self.assertEqual(relative_dir, repo_id)
Example #22
0
    def test_publish_repo(self, mock_publish):
        repo = Repository('test')
        config = PluginCallConfiguration(None, None)
        conduit = RepoPublishConduit(repo.id, TYPE_ID_DISTRIBUTOR_YUM)

        self.distributor.publish_repo(repo, conduit, config)

        mock_publish.Publisher.return_value.publish.assert_called_once()
Example #23
0
    def test_validate_config(self, mock_validate_config):
        repo = Repository('test')
        config = PluginCallConfiguration(None, None)
        conduit = RepoConfigConduit(TYPE_ID_DISTRIBUTOR_YUM)

        self.distributor.validate_config(repo, config, conduit)

        mock_validate_config.assert_called_once_with(repo, config, conduit)
Example #24
0
    def setUp(self):
        self.working_dir = tempfile.mkdtemp(prefix='puppet-sync-tests')
        self.repo = Repository('test-repo', working_dir=self.working_dir)
        self.conduit = MockConduit()
        self.config = PluginCallConfiguration({}, {
            constants.CONFIG_FEED: FEED,
        })

        self.method = SynchronizeWithPuppetForge(self.repo, self.conduit,
                                                 self.config)
Example #25
0
 def test_init_no_values(self):
     repo = Repository('foo')
     self.assertEquals('foo', repo.id)
     self.assertEquals(None, repo.display_name)
     self.assertEquals(None, repo.description)
     self.assertEquals(None, repo.notes)
     self.assertEquals(None, repo.working_dir)
     self.assertEquals({}, repo.content_unit_counts)
     self.assertEquals(None, repo.last_unit_added)
     self.assertEquals(None, repo.last_unit_removed)
Example #26
0
    def test_get_repo_relative_path_configured(self):
        repo_id = 'Spaniard'
        repo = Repository(repo_id)
        configured_relative_url = '/there/can/be/only/one/'
        config = self._generate_call_config(relative_url=configured_relative_url)

        relative_url = configuration.get_repo_relative_path(repo, config)

        # get_relative_path should strip off the leading '/'
        self.assertEqual(relative_url, configured_relative_url[1:])
Example #27
0
    def setUp(self):
        self.working_dir = tempfile.mkdtemp(prefix='working_')

        self.repo_id = 'publish-test-repo'
        self.repo = Repository(self.repo_id, working_dir=self.working_dir)
        self.conduit = RepoPublishConduit(self.repo_id, 'test_plugin_id')
        self.conduit.get_repo_scratchpad = Mock(return_value={})

        self.config = PluginCallConfiguration(None, None)
        self.pluginstep = PluginStep("base-step", repo=self.repo, conduit=self.conduit,
                                     config=self.config, plugin_type='test_plugin_type')
Example #28
0
    def test_sync_calls_sync(self, mock_sync_run):
        repo = Repository('repo1')
        sync_conduit = importer_mocks.get_sync_conduit(pkg_dir='/a/b/c')
        config = importer_mocks.get_basic_config(
            **{importer_constants.KEY_FEED: 'http://fake.com/iso_feed/'})

        self.iso_importer.sync_repo(repo, sync_conduit, config)

        # make sure the sync workflow is called with the right stuff
        mock_sync_run.assert_called_once_with(sync_conduit, config)
        mock_sync_run.return_value.perform_sync.assert_called_once_with()
Example #29
0
    def test_cert_based_auth_ca_and_cert(self, mock_write_consumer_cert_bundle,
                                         mock_add_protected_repo):
        repo = Repository('test')
        config = {'auth_ca': 'looks legit',
                  'auth_cert': '1234567890'}
        bundle = {'ca': config['auth_ca'], 'cert': config['auth_cert']}

        configuration.process_cert_based_auth(repo, config)

        mock_write_consumer_cert_bundle.assert_called_once_with(repo.id, bundle)
        mock_add_protected_repo.assert_called_once_with(repo.id, repo.id)
Example #30
0
    def setUp(self):
        self.working_dir = tempfile.mkdtemp(prefix='puppet-sync-tests')
        self.repo = Repository('test-repo', working_dir=self.working_dir)
        self.conduit = MockConduit()
        self.config = PluginCallConfiguration({}, {
            constants.CONFIG_FEED: FEED,
        })
        self.is_cancelled_call = mock.MagicMock().is_cancelled_call

        self.run = PuppetModuleSyncRun(self.repo, self.conduit, self.config,
                                       self.is_cancelled_call)
Example #31
0
    def test_relative_path_conflicts_none(self):
        repo = Repository('test')
        config = {}
        conduit = mock.MagicMock()
        conduit.get_repo_distributors_by_relative_url = mock.MagicMock(return_value=[])
        error_messages = []

        configuration._check_for_relative_path_conflicts(repo, config, conduit, error_messages)

        self.assertEqual(conduit.get_repo_distributors_by_relative_url.call_count, 1)
        self.assertEqual(len(error_messages), 0)
 def setUp(self):
     self.temp_dir = tempfile.mkdtemp()
     self.working_directory = os.path.join(self.temp_dir, 'working')
     self.publish_directory = os.path.join(self.temp_dir, 'publish')
     self.content_directory = os.path.join(self.temp_dir, 'content')
     os.makedirs(self.working_directory)
     os.makedirs(self.publish_directory)
     os.makedirs(self.content_directory)
     repo = Repository('foo_repo_id', working_dir=self.working_directory)
     config = PluginCallConfiguration(None, None)
     conduit = RepoPublishConduit(repo.id, 'foo_repo')
     self.parent = PublishStep('test-step', repo, conduit, config)
Example #33
0
    def setUp(self):
        self.working_directory = tempfile.mkdtemp()
        self.source_dir = os.path.join(self.working_directory, 'src')
        self.target_dir = os.path.join(self.working_directory, 'target')

        os.makedirs(self.source_dir)
        os.makedirs(self.target_dir)
        self.repo = Repository(id='foo', working_dir=self.target_dir)
        config = PluginCallConfiguration(None, None)
        conduit = RepoPublishConduit(self.repo.id, 'foo_repo')
        conduit.get_repo_scratchpad = Mock(return_value={})
        self.parent = steps.PluginStep('test-step', self.repo, conduit, config)
Example #34
0
 def test_finalize(self, mock_repo_controller):
     repo = Repository('repo1')
     repo.repo_obj = model.Repository(repo_id=repo.id)
     step = publish_step.SaveUnitsStep('foo_type', repo=repo)
     step.finalize()
     mock_repo_controller.rebuild_content_unit_counts.assert_called_once_with(repo.repo_obj)