def to_plugin_unit(pulp_unit, type_def): """ Parses the raw dictionary of a content unit into its plugin representation. @param pulp_unit: raw dictionary of unit metadata @type pulp_unit: dict @param type_def: Pulp stored definition for the unit type @type type_def: pulp.server.db.model.content.ContentType @return: plugin unit representation of the given unit @rtype: pulp.plugins.model.Unit """ # Copy so we don't mangle the original unit pulp_unit = dict(pulp_unit) key_list = type_def['unit_key'] unit_key = {} for k in key_list: unit_key[k] = pulp_unit.pop(k) storage_path = pulp_unit.pop('_storage_path', None) unit_id = pulp_unit.pop('_id', None) u = Unit(type_def['id'], unit_key, pulp_unit, storage_path) u.id = unit_id return u
def to_plugin_unit(pulp_unit, unit_type_id, unit_key_fields): """ Parses the raw dictionary of a content unit into its plugin representation. :param pulp_unit: raw dictionary of unit metadata :type pulp_unit: dict :param unit_type_id: unique identifier for the type of unit :type unit_type_id: str :param unit_key_fields: collection of keys required for the type's unit key :type unit_key_fields: list or tuple :return: plugin unit representation of the given unit :rtype: pulp.plugins.model.Unit """ # Copy so we don't mangle the original unit pulp_unit = dict(pulp_unit) unit_key = {} for k in unit_key_fields: unit_key[k] = pulp_unit.pop(k) storage_path = pulp_unit.pop('_storage_path', None) unit_id = pulp_unit.pop('_id', None) u = Unit(unit_type_id, unit_key, pulp_unit, storage_path) u.id = unit_id return u
def test_handle_erratum_with_link(self, mock_link): # Setup unit_key = {'id': 'test-erratum'} metadata = {'a': 'a'} config = PluginCallConfiguration({}, {}) mock_repo = mock.MagicMock() mock_conduit = mock.MagicMock() inited_unit = Unit(models.Errata.TYPE, unit_key, metadata, None) saved_unit = Unit(models.Errata.TYPE, unit_key, metadata, None) saved_unit.id = 'ihaveanidnow' mock_conduit.init_unit.return_value = inited_unit mock_conduit.save_unit.return_value = saved_unit # Test upload._handle_erratum(mock_repo, models.Errata.TYPE, unit_key, metadata, None, mock_conduit, config) # Verify mock_conduit.init_unit.assert_called_once_with(models.Errata.TYPE, unit_key, metadata, None) mock_conduit.save_unit.assert_called_once_with(inited_unit) mock_link.assert_called_once() self.assertEqual(mock_link.call_args[0][0], mock_conduit) self.assertTrue(isinstance(mock_link.call_args[0][1], models.Errata)) # it is very important that this is the saved_unit, and not the inited_unit, # because the underlying link logic requires it to have an "id". self.assertTrue(mock_link.call_args[0][2] is saved_unit)
def test_resolve_deps(self): repo = mock.Mock(spec=Repository) repo.working_dir = "/tmp/test_resolve_deps" repo.id = "test_resolve_deps" unit_key_a = {'id' : '','name' :'pulp-server', 'version' :'0.0.309', 'release' : '1.fc17', 'epoch':'0', 'arch' : 'noarch', 'checksumtype' : 'sha256', 'checksum': 'ee5afa0aaf8bd2130b7f4a9b35f4178336c72e95358dd33bda8acaa5f28ea6e9', 'type_id' : 'rpm'} unit_key_a_obj = Unit(RPM_TYPE_ID, unit_key_a, {}, '') unit_key_a_obj.metadata = constants.PULP_SERVER_RPM_METADATA unit_key_b = {'id' : '', 'name' :'pulp-rpm-server', 'version' :'0.0.309', 'release' :'1.fc17', 'epoch':'0','arch' : 'noarch', 'checksumtype' :'sha256', 'checksum': '1e6c3a3bae26423fe49d26930b986e5f5ee25523c13f875dfcd4bf80f770bf56', 'type_id' : 'rpm', } unit_key_b_obj = Unit(RPM_TYPE_ID, unit_key_b, {}, '') unit_key_b_obj.metadata = constants.PULP_RPM_SERVER_RPM_METADATA existing_units = [] for unit in [unit_key_a_obj, unit_key_b_obj]: existing_units.append(unit) conduit = importer_mocks.get_dependency_conduit(type_id=RPM_TYPE_ID, existing_units=existing_units, pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config() importer = YumImporter() units = [Unit(RPM_TYPE_ID, unit_key_b, {}, '')] result = importer.resolve_dependencies(repo, units, conduit, config) self.assertEqual(len(list(itertools.chain(*result['resolved'].values()))), 1) self.assertEqual(len(list(itertools.chain(*result['unresolved'].values()))), 0)
def test_distribution_exports(self): feed_url = "file://%s/pulp_unittest/" % self.data_dir repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "pulp_unittest" repo.checksumtype = 'sha' sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, existing_units=[], pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) dunit_key = {} dunit_key['id'] = "ks-TestFamily-TestVariant-16-x86_64" dunit_key['version'] = "16" dunit_key['arch'] = "x86_64" dunit_key['family'] = "TestFamily" dunit_key['variant'] = "TestVariant" metadata = { "files" : [{"checksumtype" : "sha256", "relativepath" : "images/fileA.txt", "fileName" : "fileA.txt", "downloadurl" : "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/pulp_unittest//images/fileA.txt", "item_type" : "tree_file", "savepath" : "%s/testr1/images" % self.repo_working_dir, "checksum" : "22603a94360ee24b7034c74fa13d70dd122aa8c4be2010fc1361e1e6b0b410ab", "filename" : "fileA.txt", "pkgpath" : "%s/ks-TestFamily-TestVariant-16-x86_64/images" % self.pkg_dir, "size" : 0 }, { "checksumtype" : "sha256", "relativepath" : "images/fileB.txt", "fileName" : "fileB.txt", "downloadurl" : "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/pulp_unittest//images/fileB.txt", "item_type" : "tree_file", "savepath" : "%s/testr1/images" % self.repo_working_dir, "checksum" : "8dc89e9883c098443f6616e60a8e489254bf239eeade6e4b4943b7c8c0c345a4", "filename" : "fileB.txt", "pkgpath" : "%s/ks-TestFamily-TestVariant-16-x86_64/images" % self.pkg_dir, "size" : 0 }, { "checksumtype" : "sha256", "relativepath" : "images/fileC.iso", "fileName" : "fileC.iso", "downloadurl" : "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/pulp_unittest//images/fileC.iso", "item_type" : "tree_file", "savepath" : "%s/testr1/images" % self.repo_working_dir, "checksum" : "099f2bafd533e97dcfee778bc24138c40f114323785ac1987a0db66e07086f74", "filename" : "fileC.iso", "pkgpath" : "%s/ks-TestFamily-TestVariant-16-x86_64/images" % self.pkg_dir, "size" : 0 } ],} distro_unit = Unit(distribution.TYPE_ID_DISTRO, dunit_key, metadata, '') distro_unit.storage_path = "%s/ks-TestFamily-TestVariant-16-x86_64" % self.pkg_dir symlink_dir = "%s/%s" % (self.repo_working_dir, "isos") iso_distributor = ISODistributor() publish_conduit = distributor_mocks.get_publish_conduit(existing_units=[distro_unit], pkg_dir=self.pkg_dir) config = distributor_mocks.get_basic_config(https_publish_dir=self.https_publish_dir, http=False, https=True) repo_exporter = RepoExporter(symlink_dir) # status, errors = iso_distributor._export_distributions([distro_unit], symlink_dir) status, errors = repo_exporter.export_distributions([distro_unit]) print status, errors self.assertTrue(status) for file in metadata['files']: print os.path.isfile("%s/%s" % (symlink_dir, file['relativepath'])) self.assertTrue(os.path.isfile("%s/%s" % (symlink_dir, file['relativepath'])))
def test_unit_applicable_true(self): rpm_unit_key = self.create_profile_entry("emoticons", 0, "0.1", "2", "x86_64", "Test Vendor") rpm_unit = Unit(TYPE_ID_RPM, rpm_unit_key, {}, None) # Let's give it an id, so we can assert for it later rpm_unit.id = "a_test_id" test_repo = profiler_mocks.get_repo("test_repo_id") conduit = profiler_mocks.get_profiler_conduit(repo_units=[rpm_unit], repo_bindings=[test_repo]) prof = YumProfiler() unit_profile = self.test_consumer.profiles[TYPE_ID_RPM] bound_repo_id = "test_repo_id" report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit) self.assertEqual(report_list, {TYPE_ID_RPM: [rpm_unit.id], TYPE_ID_ERRATA: []})
def existing_units(self): units = [] # for unit in [self.UNIT_KEY_A, self.UNIT_KEY_B]: # unit = Unit(TYPE_ID_RPM, unit, {}, '') # units.append(unit) unit = Unit(TYPE_ID_RPM, self.UNIT_KEY_A, {}, '') unit.metadata = constants.PULP_SERVER_RPM_METADATA units.append(unit) unit = Unit(TYPE_ID_RPM, self.UNIT_KEY_B, {}, '') unit.metadata = constants.PULP_RPM_SERVER_RPM_METADATA units.append(unit) return units
def test_orphaned_distributions(self): feed_url = "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/pulp_unittest/" repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_repo" sync_conduit = importer_mocks.get_sync_conduit(pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) self.assertTrue(status) dunit_key = {} dunit_key['id'] = "ks-TestFamily-TestVariant-16-x86_64" dunit_key['version'] = "16" dunit_key['arch'] = "x86_64" dunit_key['family'] = "TestFamily" dunit_key['variant'] = "TestVariant" metadata = { "files" : [{"checksumtype" : "sha256", "relativepath" : "images/fileA.txt", "fileName" : "fileA.txt", "downloadurl" : "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/pulp_unittest//images/fileA.txt", "item_type" : "tree_file", "savepath" : "%s/testr1/images" % self.working_dir, "checksum" : "22603a94360ee24b7034c74fa13d70dd122aa8c4be2010fc1361e1e6b0b410ab", "filename" : "fileA.txt", "pkgpath" : "%s/ks-TestFamily-TestVariant-16-x86_64/images" % self.pkg_dir, "size" : 0 }, { "checksumtype" : "sha256", "relativepath" : "images/fileB.txt", "fileName" : "fileB.txt", "downloadurl" : "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/pulp_unittest//images/fileB.txt", "item_type" : "tree_file", "savepath" : "%s/testr1/images" % self.working_dir, "checksum" : "8dc89e9883c098443f6616e60a8e489254bf239eeade6e4b4943b7c8c0c345a4", "filename" : "fileB.txt", "pkgpath" : "%s/ks-TestFamily-TestVariant-16-x86_64/images" % self.pkg_dir, "size" : 0 }, { "checksumtype" : "sha256", "relativepath" : "images/fileC.iso", "fileName" : "fileC.iso", "downloadurl" : "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/pulp_unittest//images/fileC.iso", "item_type" : "tree_file", "savepath" : "%s/testr1/images" % self.working_dir, "checksum" : "099f2bafd533e97dcfee778bc24138c40f114323785ac1987a0db66e07086f74", "filename" : "fileC.iso", "pkgpath" : "%s/ks-TestFamily-TestVariant-16-x86_64/images" % self.pkg_dir, "size" : 0 } ],} distro_unit = Unit(distribution.TYPE_ID_DISTRO, dunit_key, metadata, '') distro_unit.storage_path = "%s/ks-TestFamily-TestVariant-16-x86_64" % self.pkg_dir new_feed_url = "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/zoo/" sync_conduit = importer_mocks.get_sync_conduit(pkg_dir=self.pkg_dir, existing_units=[distro_unit]) config = importer_mocks.get_basic_config(feed_url=new_feed_url) status, summary, details = importerRPM.sync(repo, sync_conduit, config) print status, summary, details self.assertTrue(status) self.assertTrue(summary is not None) self.assertTrue(details is not None) self.assertEquals(summary["num_orphaned_distributions"], 1)
def test_link_unit(self, mock_link): # Setup from_unit = Unit('t1', {'k' : 'v1'}, {'m' : 'm'}, 'p') from_unit.id = 'from-unit' to_unit = Unit('t2', {'k' : 'v2'}, {'m' : 'm'}, 'p') to_unit.id = 'to-unit' # Test self.mixin.link_unit(from_unit, to_unit) # Verify self.assertEqual(1, mock_link.call_count) self.assertEqual(mock_link.call_args[0][0], from_unit.type_id) self.assertEqual(mock_link.call_args[0][1], from_unit.id) self.assertEqual(mock_link.call_args[0][2], to_unit.type_id) self.assertEqual(mock_link.call_args[0][3], [to_unit.id])
def test_link_unit(self, mock_link): # Setup from_unit = Unit("t1", {"k": "v1"}, {"m": "m"}, "p") from_unit.id = "from-unit" to_unit = Unit("t2", {"k": "v2"}, {"m": "m"}, "p") to_unit.id = "to-unit" # Test self.mixin.link_unit(from_unit, to_unit) # Verify self.assertEqual(1, mock_link.call_count) self.assertEqual(mock_link.call_args[0][0], from_unit.type_id) self.assertEqual(mock_link.call_args[0][1], from_unit.id) self.assertEqual(mock_link.call_args[0][2], to_unit.type_id) self.assertEqual(mock_link.call_args[0][3], [to_unit.id])
def test_unit_not_applicable_not_in_repo(self): # Errata refers to RPMs which ARE part of our test consumer's profile, # but are not in the repo. errata_obj = self.get_test_errata_object() errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None) errata_unit.id = 'an_errata' test_repo = profiler_mocks.get_repo("test_repo_id") prof = YumProfiler() errata_rpms = prof._get_rpms_from_errata(errata_unit) conduit = profiler_mocks.get_profiler_conduit(repo_units=[errata_unit], repo_bindings=[test_repo], errata_rpms=errata_rpms) unit_profile = self.test_consumer.profiles[TYPE_ID_RPM] bound_repo_id = "test_repo_id" report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit) self.assertEqual(report_list, {TYPE_ID_RPM: [], TYPE_ID_ERRATA: []})
def test_repo_export_isos(self): feed_url = "file://%s/pulp_unittest/" % self.data_dir repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "pulp_unittest" repo.checksumtype = 'sha' sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, existing_units=[], pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) unit_key_a = {'id' : '','name' :'pulp-dot-2.0-test', 'version' :'0.1.2', 'release' : '1.fc11', 'epoch':'0', 'arch' : 'x86_64', 'checksumtype' : 'sha256', 'checksum': '435d92e6c09248b501b8d2ae786f92ccfad69fab8b1bc774e2b66ff6c0d83979', 'type_id' : 'rpm'} unit_a = Unit(TYPE_ID_RPM, unit_key_a, {}, '') unit_a.storage_path = "%s/pulp-dot-2.0-test/0.1.2/1.fc11/x86_64/435d92e6c09248b501b8d2ae786f92ccfad69fab8b1bc774e2b66ff6c0d83979/pulp-dot-2.0-test-0.1.2-1.fc11.x86_64.rpm" % self.pkg_dir unit_key_b = {'id' : '', 'name' :'pulp-test-package', 'version' :'0.2.1', 'release' :'1.fc11', 'epoch':'0','arch' : 'x86_64', 'checksumtype' :'sha256', 'checksum': '4dbde07b4a8eab57e42ed0c9203083f1d61e0b13935d1a569193ed8efc9ecfd7', 'type_id' : 'rpm', } unit_b = Unit(TYPE_ID_RPM, unit_key_b, {}, '') unit_b.storage_path = "%s/pulp-test-package/0.2.1/1.fc11/x86_64/4dbde07b4a8eab57e42ed0c9203083f1d61e0b13935d1a569193ed8efc9ecfd7/pulp-test-package-0.2.1-1.fc11.x86_64.rpm" % self.pkg_dir unit_key_c = {'id' : '', 'name' :'pulp-test-package', 'version' :'0.3.1', 'release' :'1.fc11', 'epoch':'0','arch' : 'x86_64', 'checksumtype' :'sha256', 'checksum': '6bce3f26e1fc0fc52ac996f39c0d0e14fc26fb8077081d5b4dbfb6431b08aa9f', 'type_id' : 'rpm', } unit_c = Unit(TYPE_ID_RPM, unit_key_c, {}, '') unit_c.storage_path = "%s/pulp-test-package/0.3.1/1.fc11/x86_64/6bce3f26e1fc0fc52ac996f39c0d0e14fc26fb8077081d5b4dbfb6431b08aa9f/pulp-test-package-0.3.1-1.fc11.x86_64.rpm" % self.pkg_dir existing_units = [] for unit in [unit_a, unit_b, unit_c]: existing_units.append(unit) sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, existing_units=existing_units, pkg_dir=self.pkg_dir) importerErrata = errata.ImporterErrata() importerErrata.sync(repo, sync_conduit, config) repo.working_dir = "%s/%s" % (self.repo_working_dir, "export") iso_distributor = ISODistributor() publish_conduit = distributor_mocks.get_publish_conduit(existing_units=existing_units, pkg_dir=self.pkg_dir) # test https publish config = distributor_mocks.get_basic_config(http_publish_dir=self.http_publish_dir, https_publish_dir=self.https_publish_dir, http=False, https=True, generate_metadata=True) report = iso_distributor.publish_repo(repo, publish_conduit, config) print report self.assertTrue(os.path.exists("%s/%s" % (self.https_publish_dir, repo.id))) self.assertEquals(len(os.listdir(self.http_publish_dir)), 0) # test http publish config = distributor_mocks.get_basic_config(http_publish_dir=self.http_publish_dir, https_publish_dir=self.https_publish_dir, http=True, https=False) report = iso_distributor.publish_repo(repo, publish_conduit, config) self.assertTrue(os.path.exists("%s/%s" % (self.http_publish_dir, repo.id))) self.assertEquals(len(os.listdir(self.https_publish_dir)), 0) isos_list = os.listdir("%s/%s" % (self.http_publish_dir, repo.id)) self.assertEqual(len(isos_list), 1) # make sure the iso name defaults to repoid self.assertTrue( isos_list[-1].startswith(repo.id)) # test isoprefix: iso_prefix = "mock-iso-prefix" config = distributor_mocks.get_basic_config(http_publish_dir=self.http_publish_dir, https_publish_dir=self.https_publish_dir, http=True, https=False, iso_prefix=iso_prefix) report = iso_distributor.publish_repo(repo, publish_conduit, config) self.assertTrue(os.path.exists("%s/%s" % (self.http_publish_dir, repo.id))) self.assertEquals(len(os.listdir(self.https_publish_dir)), 0) isos_list = os.listdir("%s/%s" % (self.http_publish_dir, repo.id)) self.assertEqual(len(isos_list), 2) print isos_list # make sure the iso name uses the prefix self.assertTrue( isos_list[-1].startswith(iso_prefix))
def test_unit_applicable(self): # Errata refers to RPMs which ARE part of our test consumer's profile, # AND in the repo. errata_obj = self.get_test_errata_object() errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None) errata_unit.id = "an_errata" rpm_unit_key = self.create_profile_entry("emoticons", 0, "0.1", "2", "x86_64", "Test Vendor") rpm_unit = Unit(TYPE_ID_RPM, rpm_unit_key, {}, None) # Let's give it an id, so we can assert for it later rpm_unit.id = "a_test_id" test_repo = profiler_mocks.get_repo("test_repo_id") prof = YumProfiler() errata_rpms = prof._get_rpms_from_errata(errata_unit) conduit = profiler_mocks.get_profiler_conduit( repo_units=[errata_unit, rpm_unit], repo_bindings=[test_repo], errata_rpms=errata_rpms ) unit_profile = self.test_consumer.profiles[TYPE_ID_RPM] bound_repo_id = "test_repo_id" report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit) self.assertEqual(report_list, {TYPE_ID_RPM: ["a_test_id"], TYPE_ID_ERRATA: ["an_errata"]})
def test_link_unit_bidirectional(self, mock_link): # Setup from_unit = Unit('t1', {'k' : 'v1'}, {'m' : 'm'}, 'p') from_unit.id = 'from-unit' to_unit = Unit('t2', {'k' : 'v2'}, {'m' : 'm'}, 'p') to_unit.id = 'to-unit' # Test self.mixin.link_unit(from_unit, to_unit, bidirectional=True) # Verify self.assertEqual(2, mock_link.call_count) call_1_args = mock_link.call_args_list[0][0] self.assertEqual(call_1_args[0], from_unit.type_id) self.assertEqual(call_1_args[1], from_unit.id) self.assertEqual(call_1_args[2], to_unit.type_id) self.assertEqual(call_1_args[3], [to_unit.id]) call_2_args = mock_link.call_args_list[1][0] self.assertEqual(call_2_args[0], to_unit.type_id) self.assertEqual(call_2_args[1], to_unit.id) self.assertEqual(call_2_args[2], from_unit.type_id) self.assertEqual(call_2_args[3], [from_unit.id])
def test_link_unit_bidirectional(self, mock_link): # Setup from_unit = Unit("t1", {"k": "v1"}, {"m": "m"}, "p") from_unit.id = "from-unit" to_unit = Unit("t2", {"k": "v2"}, {"m": "m"}, "p") to_unit.id = "to-unit" # Test self.mixin.link_unit(from_unit, to_unit, bidirectional=True) # Verify self.assertEqual(2, mock_link.call_count) call_1_args = mock_link.call_args_list[0][0] self.assertEqual(call_1_args[0], from_unit.type_id) self.assertEqual(call_1_args[1], from_unit.id) self.assertEqual(call_1_args[2], to_unit.type_id) self.assertEqual(call_1_args[3], [to_unit.id]) call_2_args = mock_link.call_args_list[1][0] self.assertEqual(call_2_args[0], to_unit.type_id) self.assertEqual(call_2_args[1], to_unit.id) self.assertEqual(call_2_args[2], from_unit.type_id) self.assertEqual(call_2_args[3], [from_unit.id])
def test_generate_isos(self): repo = mock.Mock(spec=Repository) repo.id = "test_repo_for_export" repo.working_dir = self.repo_iso_working_dir + "/" + repo.id unit_key_a = {'id' : '','name' :'pulp-dot-2.0-test', 'version' :'0.1.2', 'release' : '1.fc11', 'epoch':'0', 'arch' : 'x86_64', 'checksumtype' : 'sha256', 'checksum': '435d92e6c09248b501b8d2ae786f92ccfad69fab8b1bc774e2b66ff6c0d83979', 'type_id' : 'rpm'} unit_a = Unit(TYPE_ID_RPM, unit_key_a, {'updated' : ''}, '') unit_a.storage_path = "%s/pulp-dot-2.0-test/0.1.2/1.fc11/x86_64/435d92e6c09248b501b8d2ae786f92ccfad69fab8b1bc774e2b66ff6c0d83979/pulp-dot-2.0-test-0.1.2-1.fc11.x86_64.rpm" % self.pkg_dir unit_key_b = {'id' : '', 'name' :'pulp-test-package', 'version' :'0.2.1', 'release' :'1.fc11', 'epoch':'0','arch' : 'x86_64', 'checksumtype' :'sha256', 'checksum': '4dbde07b4a8eab57e42ed0c9203083f1d61e0b13935d1a569193ed8efc9ecfd7', 'type_id' : 'rpm', } unit_b = Unit(TYPE_ID_RPM, unit_key_b, {'updated' : ''}, '') unit_b.storage_path = "%s/pulp-test-package/0.2.1/1.fc11/x86_64/4dbde07b4a8eab57e42ed0c9203083f1d61e0b13935d1a569193ed8efc9ecfd7/pulp-test-package-0.2.1-1.fc11.x86_64.rpm" % self.pkg_dir unit_key_c = {'id' : '', 'name' :'pulp-test-package', 'version' :'0.3.1', 'release' :'1.fc11', 'epoch':'0','arch' : 'x86_64', 'checksumtype' :'sha256', 'checksum': '6bce3f26e1fc0fc52ac996f39c0d0e14fc26fb8077081d5b4dbfb6431b08aa9f', 'type_id' : 'rpm', } unit_c = Unit(TYPE_ID_RPM, unit_key_c, {'updated' : ''}, '') unit_c.storage_path = "%s/pulp-test-package/0.3.1/1.fc11/x86_64/6bce3f26e1fc0fc52ac996f39c0d0e14fc26fb8077081d5b4dbfb6431b08aa9f/pulp-test-package-0.3.1-1.fc11.x86_64.rpm" % self.pkg_dir existing_units = [] for unit in [unit_a, unit_b, unit_c]: existing_units.append(unit) global progress_status progress_status = None def set_progress(progress): global progress_status progress_status = progress publish_conduit = distributor_mocks.get_publish_conduit(pkg_dir=self.pkg_dir, existing_units=existing_units) config = distributor_mocks.get_basic_config(https_publish_dir=self.https_publish_dir, http_publish_dir=self.http_publish_dir, generate_metadata=True, http=True, https=False, iso_prefix="test-isos") distributor = ISODistributor() def cleanup(repo_working_dir): return iso_util.cleanup_working_dir = mock.Mock() iso_util.cleanup_working_dir.side_effect = cleanup publish_conduit.set_progress = mock.Mock() publish_conduit.set_progress.side_effect = set_progress progress_status = distributor.init_progress() distributor.publish_repo(repo, publish_conduit, config) self.assertTrue("isos" in progress_status) self.assertTrue(progress_status["isos"].has_key("state")) self.assertEqual(progress_status["isos"]["state"], "FINISHED") self.assertEqual(progress_status["isos"]["num_success"], 1) self.assertTrue(progress_status["isos"]["size_total"] is not None) self.assertEqual(progress_status["isos"]["size_left"], 0) self.assertEqual(progress_status["isos"]["items_total"], 1) self.assertEqual(progress_status["isos"]["items_left"], 0) self.assertTrue(os.path.exists("%s/%s" % (self.http_publish_dir, repo.id))) self.assertEquals(len(os.listdir(self.https_publish_dir)), 0) isos_list = os.listdir("%s/%s" % (self.http_publish_dir, repo.id)) self.assertEqual(len(isos_list), 1) # make sure the iso name defaults to repoid self.assertTrue( isos_list[0].startswith("test-isos"))
def process_main(self): """ given the passed-in unit keys, determine which of them already exist in pulp, and save those with the conduit found on the parent. """ # any units that are already in pulp units_we_already_had = set() # for any unit that is already in pulp, save it into the repo for unit_dict in self.content_query_manager.get_multiple_units_by_keys_dicts( self.unit_type, self.parent.available_units, self.unit_key_fields): unit = self._dict_to_unit(unit_dict) self.get_conduit().save_unit(unit) units_we_already_had.add(unit) for unit_key in self.parent.available_units: # build a temp Unit instance just to use its comparison feature unit = Unit(self.unit_type, unit_key, {}, '') if unit not in units_we_already_had: self.units_to_download.append(unit_key)
def test_link_errata_to_rpms(self): # Setup mock_conduit = mock.MagicMock() mock_conduit.get_units.return_value = ['a', 'b'] sample_errata_file = os.path.join(DATA_DIR, 'RHBA-2010-0836.erratum.xml') with open(sample_errata_file) as f: errata = packages.package_list_generator(f, updateinfo.PACKAGE_TAG, updateinfo.process_package_element) errata = list(errata)[0] errata_unit = Unit(models.Errata.TYPE, errata.unit_key, errata.metadata, None) # Test upload._link_errata_to_rpms(mock_conduit, errata, errata_unit) # Verify self.assertEqual(2, mock_conduit.get_units.call_count) # once each for RPM and SRPM self.assertEqual(4, mock_conduit.link_unit.call_count) # twice each for RPM and SRPM
def add_unit(self, request, unit): """ Add the specified unit to the child inventory using the conduit. The conduit will automatically associate the unit to the repository to which it's pre-configured. :param request: A synchronization request. :type request: SyncRequest :param unit: The unit to be added. :type unit: dict """ try: new_unit = Unit( type_id=unit['type_id'], unit_key=unit['unit_key'], metadata=unit['metadata'], storage_path=unit['storage_path']) request.conduit.save_unit(new_unit) request.progress.unit_added(details=new_unit.storage_path) except Exception: _log.exception(unit['unit_id']) request.summary.errors.append(AddUnitError(request.repo_id))
def test_unit_applicable_updated_rpm_already_installed( self, m_get_unique_pkglists): # Errata refers to RPMs already installed, i.e. the consumer has these exact NEVRA already errata_obj = self.get_test_errata_object() errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None) errata_rpms = errata_obj.pkglist[0]['packages'] m_get_unique_pkglists.return_value = [[errata_rpms]] test_repo = profiler_mocks.get_repo("test_repo_id") prof = YumProfiler() conduit = profiler_mocks.get_profiler_conduit( repo_units=[errata_unit], repo_bindings=[test_repo], errata_rpms=errata_rpms) unit_profile = self.test_consumer_been_updated.profiles[TYPE_ID_RPM] bound_repo_id = "test_repo_id" report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit) self.assertEqual(report_list, {TYPE_ID_RPM: [], TYPE_ID_ERRATA: []})
def test_process_unit(self): step = publish.PublishRpmAndDrpmStepIncremental() self.publisher.add_child(step) unit_key = {'name': 'foo', 'version': '1', 'release': '2', 'arch': 'flux'} metadata = {'filename': 'bar.txt', 'repodata': 'baz', '_test': 'hidden'} storage_path = os.path.join(self.working_dir, 'foo') touch(storage_path) test_unit = Unit('foo_type', unit_key, metadata.copy(), storage_path) step.process_main(test_unit) modified_metadata = metadata.copy() modified_metadata.pop('repodata') modified_metadata.pop('_test') modified_metadata[server_constants.PULP_USER_METADATA_FIELDNAME] = {} unit_file = os.path.join(self.working_dir, 'foo-1-2.flux.json') self.assertTrue(os.path.exists(unit_file)) with open(unit_file) as file_handle: loaded = json.load(file_handle) compare_dict(loaded, { 'unit_key': unit_key, 'unit_metadata': modified_metadata })
def test_unit_applicable_same_name_diff_arch(self): # Errata refers to RPMs that are x86_64, the test consumer is i386 # the rpms installed share the same name as the errata, but the client arch is different # so this errata is marked as unapplicable errata_obj = self.get_test_errata_object() errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None) test_repo = profiler_mocks.get_repo("test_repo_id") prof = YumProfiler() errata_rpms = prof._get_rpms_from_errata(errata_unit) conduit = profiler_mocks.get_profiler_conduit( repo_units=[errata_unit], repo_bindings=[test_repo], errata_rpms=errata_rpms) unit_profile = self.test_consumer_i386.profiles[TYPE_ID_RPM] bound_repo_id = "test_repo_id" report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit) self.assertEqual(report_list, {TYPE_ID_RPM: [], TYPE_ID_ERRATA: []})
def _generate_drpm(self, name): unit_key = {'epoch': '0', 'version': '1', 'release': '1', 'filename': name, 'checksumtype': 'sha256', 'checksum': '1234567890'} unit_metadata = {'new_package': name, 'arch': 'noarch', 'oldepoch': '0', 'oldversion': '1', 'oldrelease': '0', 'sequence': '0987654321', 'size': 5} storage_path = os.path.join(self.working_dir, 'content', name) self._touch(storage_path) return Unit(TYPE_ID_DRPM, unit_key, unit_metadata, storage_path)
def test_handle_for_category(self): # Setup unit_key = {'id': 'test-category', 'repo_id': 'test-repo'} metadata = {} config = PluginCallConfiguration({}, {}) mock_repo = mock.MagicMock() mock_conduit = mock.MagicMock() inited_unit = Unit(models.PackageCategory.TYPE, unit_key, metadata, None) mock_conduit.init_unit.return_value = inited_unit # Test upload._handle_group_category(mock_repo, models.PackageCategory.TYPE, unit_key, metadata, None, mock_conduit, config) # Verify mock_conduit.init_unit.assert_called_once_with(models.PackageCategory.TYPE, unit_key, metadata, None) mock_conduit.save_unit.assert_called_once() saved_unit = mock_conduit.save_unit.call_args[0][0] self.assertEqual(inited_unit, saved_unit)
def test_link_unit(self, mock_link): # Setup from_unit = Unit('t1', {'k': 'v1'}, {'m': 'm'}, 'p') from_unit.id = 'from-unit' to_unit = Unit('t2', {'k': 'v2'}, {'m': 'm'}, 'p') to_unit.id = 'to-unit' # Test self.mixin.link_unit(from_unit, to_unit) # Verify self.assertEqual(1, mock_link.call_count) self.assertEqual(mock_link.call_args[0][0], from_unit.type_id) self.assertEqual(mock_link.call_args[0][1], from_unit.id) self.assertEqual(mock_link.call_args[0][2], to_unit.type_id) self.assertEqual(mock_link.call_args[0][3], [to_unit.id])
def test_get_rpms_from_errata(self): errata_obj = self.get_test_errata_object() errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None) prof = YumProfiler() rpms = prof._get_rpms_from_errata(errata_unit) # Expected data: # [{'src': 'xen-3.0.3-80.el5_3.3.src.rpm', 'name': 'emoticons', # 'sum': ('md5', '366bb5e73a5905eacb82c96e0578f92b'), # 'filename': 'emoticons-0.1-2.x86_64.rpm', 'epoch': '0', # 'version': '0.1', 'release': '2', 'arch': 'x86_64'}, # {'src': 'xen-3.0.3-80.el5_3.3.src.rpm', 'name': 'patb', # 'sum': ('md5', 'f3c197a29d9b66c5b65c5d62b25db5b4'), # 'filename': 'patb-0.1-2.x86_64.rpm', 'epoch': '0' # 'version': '0.1', 'release': '2', 'arch': 'x86_64'}] self.assertEqual(len(rpms), 2) self.assertTrue(rpms[0]["name"] in ['emoticons', 'patb']) self.assertTrue(rpms[1]["name"] in ['emoticons', 'patb']) for r in rpms: for key in ["name", "filename", "epoch", "version", "release"]: self.assertTrue(key in r) self.assertTrue(r[key])
def test_yum_md_file(self, mock_copyfile): mock_conduit = mock.MagicMock( spec_set=ImportUnitConduit('', '', '', '')) model = model_factory.yum_md_file() unit = Unit(model.TYPE, model.unit_key, model.metadata, '/foo/bar') associate._associate_unit(self.repo, mock_conduit, unit) expected_key = { 'repo_id': self.repo.id, 'data_type': model.unit_key['data_type'] } self.assertEqual(mock_conduit.init_unit.call_args[0][0], model.TYPE) self.assertEqual(mock_conduit.init_unit.call_args[0][1], expected_key) self.assertEqual(mock_conduit.init_unit.call_args[0][2], model.metadata) mock_conduit.save_unit.assert_called_once_with( mock_conduit.init_unit.return_value) mock_copyfile.assert_called_once_with( unit.storage_path, mock_conduit.init_unit.return_value.storage_path)
def _generate_rpm(self, name): unit_key = { 'name': name, 'epoch': 0, 'version': 1, 'release': 0, 'arch': 'noarch', 'checksumtype': 'sha256', 'checksum': '1234657890' } unit_metadata = { 'repodata': { 'filelists': 'FILELISTS', 'other': 'OTHER', 'primary': 'PRIMARY' } } storage_path = os.path.join(self.metadata_file_dir, name) return Unit(TYPE_ID_RPM, unit_key, unit_metadata, storage_path)
def test_handle_yum_metadata_file(self): # Setup unit_key = {'data_type': 'product-id', 'repo_id': 'test-repo'} metadata = { 'local_path': 'repodata/productid', 'checksum': 'abcdef', 'checksumtype': 'sha256' } config = PluginCallConfiguration({}, {}) mock_repo = mock.MagicMock() mock_conduit = mock.MagicMock() inited_unit = Unit(models.YumMetadataFile.TYPE, unit_key, metadata, self.upload_dest_filename) mock_conduit.init_unit.return_value = inited_unit # Test upload._handle_yum_metadata_file(mock_repo, models.YumMetadataFile.TYPE, unit_key, metadata, self.upload_source_filename, mock_conduit, config) # Verify # File was moved correctly self.assertTrue(not os.path.exists(self.upload_source_filename)) self.assertTrue(os.path.exists(self.upload_dest_filename)) # Conduit calls expected_relative_path = 'test-repo/repodata/productid' mock_conduit.init_unit.assert_called_once_with( models.YumMetadataFile.TYPE, unit_key, metadata, expected_relative_path) mock_conduit.save_unit.assert_called_once() saved_unit = mock_conduit.save_unit.call_args[0][0] self.assertEqual(inited_unit, saved_unit)
def test_get_rpms_from_errata_no_epoch(self): """ Test that we default to '0' for the epoch if one doesn't exist. """ errata_obj = self.get_test_errata_object(eid='RHEA-2010:8888') errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None) prof = YumProfiler() rpms = prof._get_rpms_from_errata(errata_unit) # Expected data: # [{'src': 'xen-3.0.3-80.el5_3.3.src.rpm', 'name': 'emoticons', # 'sum': ('md5', '366bb5e73a5905eacb82c96e0578f92b'), # 'filename': 'emoticons-0.1-2.x86_64.rpm', 'epoch': '0', # 'version': '0.1', 'release': '2', 'arch': 'x86_64'}, # {'src': 'xen-3.0.3-80.el5_3.3.src.rpm', 'name': 'patb', # 'sum': ('md5', 'f3c197a29d9b66c5b65c5d62b25db5b4'), # 'filename': 'patb-0.1-2.x86_64.rpm', 'epoch': '0', # 'version': '0.1', 'release': '2', 'arch': 'x86_64'}] self.assertEqual(len(rpms), 2) self.assertTrue(rpms[0]["name"] in ['emoticons', 'patb']) self.assertTrue(rpms[1]["name"] in ['emoticons', 'patb']) for r in rpms: self.assertTrue('epoch' in r) self.assertTrue(r['epoch'] == '0')
def test_process_main_file_size_failure(self, mock_shutil, mock_stat): """ Test that we error if the file size does not match the metadata """ unit_key = {'name': 'foo', 'version': '1.5', 'architecture': 'x86_64'} unit_key_hash = sync.get_key_hash(unit_key) deb_data = { unit_key_hash: { 'file_name': 'foo.deb', 'file_size': '5' } } self.step.parent = mock.MagicMock(deb_data=deb_data) self.step.parent.step_get_local_units.units_to_download = [unit_key] mock_stat.return_value.st_size = 7 initialized_unit = Unit(constants.DEB_TYPE_ID, unit_key, {}, 'some/directory') self.step.conduit.init_unit.return_value = initialized_unit try: self.step.process_main() self.fail('This should have raised an exception') except exceptions.PulpCodedValidationException as e: self.assertEquals(e.error_code, error_codes.DEB1001)
def test_get_relpath_from_unit(self): distributor = YumDistributor() test_unit = Unit("rpm", "unit_key", {}, "") test_unit.unit_key = {"fileName" : "test_1"} rel_path = util.get_relpath_from_unit(test_unit) self.assertEqual(rel_path, "test_1") test_unit.unit_key = {} test_unit.storage_path = "test_0" rel_path = util.get_relpath_from_unit(test_unit) self.assertEqual(rel_path, "test_0") test_unit.metadata["filename"] = "test_2" rel_path = util.get_relpath_from_unit(test_unit) self.assertEqual(rel_path, "test_2") test_unit.metadata["relativepath"] = "test_3" rel_path = util.get_relpath_from_unit(test_unit) self.assertEqual(rel_path, "test_3")
def test_export_rpm(self): feed_url = "file://%s/test_repo_for_export/" % (self.data_dir) repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "test_repo_for_export" sync_conduit = importer_mocks.get_sync_conduit(existing_units=[], pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) self.assertTrue(summary is not None) self.assertTrue(details is not None) self.assertTrue(status) unit_key_a = {'id' : '','name' :'pulp-dot-2.0-test', 'version' :'0.1.2', 'release' : '1.fc11', 'epoch':'0', 'arch' : 'x86_64', 'checksumtype' : 'sha256', 'checksum': '435d92e6c09248b501b8d2ae786f92ccfad69fab8b1bc774e2b66ff6c0d83979', 'type_id' : 'rpm'} unit_a = Unit(TYPE_ID_RPM, unit_key_a, {}, '') unit_a.storage_path = "%s/pulp-dot-2.0-test/0.1.2/1.fc11/x86_64/435d92e6c09248b501b8d2ae786f92ccfad69fab8b1bc774e2b66ff6c0d83979/pulp-dot-2.0-test-0.1.2-1.fc11.x86_64.rpm" % self.pkg_dir unit_key_b = {'id' : '', 'name' :'pulp-test-package', 'version' :'0.2.1', 'release' :'1.fc11', 'epoch':'0','arch' : 'x86_64', 'checksumtype' :'sha256', 'checksum': '4dbde07b4a8eab57e42ed0c9203083f1d61e0b13935d1a569193ed8efc9ecfd7', 'type_id' : 'rpm', } unit_b = Unit(TYPE_ID_RPM, unit_key_b, {}, '') unit_b.storage_path = "%s/pulp-test-package/0.2.1/1.fc11/x86_64/4dbde07b4a8eab57e42ed0c9203083f1d61e0b13935d1a569193ed8efc9ecfd7/pulp-test-package-0.2.1-1.fc11.x86_64.rpm" % self.pkg_dir unit_key_c = {'id' : '', 'name' :'pulp-test-package', 'version' :'0.3.1', 'release' :'1.fc11', 'epoch':'0','arch' : 'x86_64', 'checksumtype' :'sha256', 'checksum': '6bce3f26e1fc0fc52ac996f39c0d0e14fc26fb8077081d5b4dbfb6431b08aa9f', 'type_id' : 'rpm', } unit_c = Unit(TYPE_ID_RPM, unit_key_c, {}, '') unit_c.storage_path = "%s/pulp-test-package/0.3.1/1.fc11/x86_64/6bce3f26e1fc0fc52ac996f39c0d0e14fc26fb8077081d5b4dbfb6431b08aa9f/pulp-test-package-0.3.1-1.fc11.x86_64.rpm" % self.pkg_dir existing_units = [] for unit in [unit_a, unit_b, unit_c]: existing_units.append(unit) symlink_dir = "%s/%s" % (self.repo_working_dir, "isos") iso_distributor = ISODistributor() publish_conduit = distributor_mocks.get_publish_conduit(existing_units=existing_units, pkg_dir=self.pkg_dir) config = distributor_mocks.get_basic_config(https_publish_dir=self.https_publish_dir, http=False, https=True) print symlink_dir # status, errors = iso_distributor._export_rpms(existing_units, symlink_dir) repo_exporter = RepoExporter(symlink_dir) status, errors = repo_exporter.export_rpms(existing_units) print status, errors self.assertTrue(status) self.assertEquals(len(os.listdir(symlink_dir)), 3)
def test_link_unit_bidirectional(self, mock_link): # Setup from_unit = Unit('t1', {'k': 'v1'}, {'m': 'm'}, 'p') from_unit.id = 'from-unit' to_unit = Unit('t2', {'k': 'v2'}, {'m': 'm'}, 'p') to_unit.id = 'to-unit' # Test self.mixin.link_unit(from_unit, to_unit, bidirectional=True) # Verify self.assertEqual(2, mock_link.call_count) call_1_args = mock_link.call_args_list[0][0] self.assertEqual(call_1_args[0], from_unit.type_id) self.assertEqual(call_1_args[1], from_unit.id) self.assertEqual(call_1_args[2], to_unit.type_id) self.assertEqual(call_1_args[3], [to_unit.id]) call_2_args = mock_link.call_args_list[1][0] self.assertEqual(call_2_args[0], to_unit.type_id) self.assertEqual(call_2_args[1], to_unit.id) self.assertEqual(call_2_args[2], from_unit.type_id) self.assertEqual(call_2_args[3], [from_unit.id])
from gettext import gettext as _ import os import unittest from xml.etree import cElementTree as ElementTree import mock from pulp.plugins.model import Unit from pulp_python.common import constants from pulp_python.plugins.distributors import steps _GET_UNITS_RETURN = [ Unit(constants.PACKAGE_TYPE_ID, { 'name': 'nectar', 'version': '1.2.0' }, { '_filename': 'nectar-1.2.0.tar.gz', '_checksum': 'abcde', '_checksum_type': 'made_up' }, '/path/to/nectar-1.2.0.tar.gz'), Unit(constants.PACKAGE_TYPE_ID, { 'name': 'nectar', 'version': '1.3.1' }, { '_filename': 'nectar-1.3.1.tar.gz', '_checksum': 'fghij', '_checksum_type': 'made_up' }, '/path/to/nectar-1.3.1.tar.gz'), Unit(constants.PACKAGE_TYPE_ID, { 'name': 'pulp_python_plugins', 'version': '0.0.0' }, {
def side_effect(type_id, unit_key, metadata, relative_path): if relative_path and pkg_dir: relative_path = os.path.join(pkg_dir, relative_path) unit = Unit(type_id, unit_key, metadata, relative_path) return unit
def init_unit(self, type_id, unit_key, unit_metadata, relative_path): storage_path = os.path.join(MOCK_PULP_STORAGE_LOCATION, relative_path) return Unit(type_id, unit_key, unit_metadata, storage_path)
def test_handle_package(self, mock_generate, mock_nevra): # Setup unit_key = { 'name': 'walrus', 'epoch': '1', 'version': '5.21', 'release': '1', 'arch': 'noarch', 'checksumtype': 'sha256', 'checksum': 'e837a635cc99f967a70f34b268baa52e0f412c1502e08e924ff5b09f1f9573f2', } metadata = {'filename': ''} mock_generate.return_value = unit_key, metadata user_unit_key = {'version': '100'} user_metadata = {'extra-meta': 'e'} config = PluginCallConfiguration({}, {}) mock_repo = mock.MagicMock() mock_conduit = mock.MagicMock() inited_unit = Unit(models.RPM.TYPE, unit_key, metadata, self.upload_dest_filename) mock_conduit.init_unit.return_value = inited_unit # Test upload._handle_package(mock_repo, models.RPM.TYPE, user_unit_key, user_metadata, self.upload_src_filename, mock_conduit, config) # Verify # File was moved as part of the import self.assertTrue(os.path.exists(self.upload_dest_filename)) self.assertTrue(not os.path.exists(self.upload_src_filename)) # Mock calls mock_generate.assert_called_once_with(models.RPM.TYPE, self.upload_src_filename, user_metadata) full_unit_key = dict(unit_key) full_metadata = dict(metadata) full_unit_key.update(user_unit_key) full_metadata.update(user_metadata) expected_relative_path = models.RPM(metadata=full_metadata, **full_unit_key).relative_path mock_conduit.init_unit.assert_called_once_with(models.RPM.TYPE, full_unit_key, full_metadata, expected_relative_path) mock_nevra.assert_called_once_with(full_unit_key, models.RPM.TYPE, mock_repo.id) mock_conduit.save_unit.assert_called_once() saved_unit = mock_conduit.save_unit.call_args[0][0] self.assertEqual(inited_unit, saved_unit)
def get_repo_units(self, repo_id, content_type_id, additional_unit_fields=None, only_unit_fields=None): """ Searches for units in the given repository with given content type and returns a plugin unit containing unit id, unit key and any additional fields requested. :param repo_id: repo id :type repo_id: str :param content_type_id: content type id of the units :type content_type_id: str :param additional_unit_fields: additional fields from the unit metadata to be added in the result :type additional_unit_fields: list of str :return: list of unit instances :rtype: list of pulp.plugins.model.Unit """ additional_unit_fields = additional_unit_fields or [] try: if only_unit_fields is None: unit_key_fields = units_controller.get_unit_key_fields_for_type( content_type_id) else: unit_key_fields = only_unit_fields serializer = units_controller.get_model_serializer_for_type( content_type_id) # Query repo association manager to get all units of given type # associated with given repo. Limit data by requesting only the fields # that are needed. query_manager = managers.repo_unit_association_query_manager() unit_fields = list(unit_key_fields) + list(additional_unit_fields) criteria = UnitAssociationCriteria(association_fields=['unit_id'], unit_fields=unit_fields) units = query_manager.get_units_by_type(repo_id, content_type_id, criteria) # Convert units to plugin units with unit_key and required metadata values for each unit all_units = [] for unit in units: if serializer: serializer.serialize(unit['metadata']) unit_key = {} metadata = {} for k in unit_key_fields: unit_key[k] = unit['metadata'].pop(k) # Add unit_id and any additional unit fields requested by plugins metadata['unit_id'] = unit.pop('unit_id') for field in additional_unit_fields: metadata[field] = unit['metadata'].pop(field, None) u = Unit(content_type_id, unit_key, metadata, None) all_units.append(u) return all_units except Exception, e: _logger.exception( _('Exception from server getting units from repo [%s]' % repo_id)) raise self.exception_class(e), None, sys.exc_info()[2]
def test_group_publish_isos(self): feed_url = "file://%s/pulp_unittest/" % self.data_dir repo_1 = mock.Mock(spec=Repository) repo_1.id = "test_repo_for_export_1" repo_1.working_dir = self.repo_working_dir repo_1.checksumtype = 'sha' repo_2 = mock.Mock(spec=Repository) repo_2.id = "test_repo_for_export_2" repo_2.working_dir = self.repo_working_dir repo_2.checksumtype = 'sha' sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, existing_units=[], pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo_1, sync_conduit, config) status, summary, details = importerRPM.sync(repo_2, sync_conduit, config) unit_key_a = {'id' : '','name' :'pulp-dot-2.0-test', 'version' :'0.1.2', 'release' : '1.fc11', 'epoch':'0', 'arch' : 'x86_64', 'checksumtype' : 'sha256', 'checksum': '435d92e6c09248b501b8d2ae786f92ccfad69fab8b1bc774e2b66ff6c0d83979', 'type_id' : 'rpm'} unit_a = Unit(TYPE_ID_RPM, unit_key_a, {}, '') unit_a.storage_path = "%s/pulp-dot-2.0-test/0.1.2/1.fc11/x86_64/435d92e6c09248b501b8d2ae786f92ccfad69fab8b1bc774e2b66ff6c0d83979/pulp-dot-2.0-test-0.1.2-1.fc11.x86_64.rpm" % self.pkg_dir unit_key_b = {'id' : '', 'name' :'pulp-test-package', 'version' :'0.2.1', 'release' :'1.fc11', 'epoch':'0','arch' : 'x86_64', 'checksumtype' :'sha256', 'checksum': '4dbde07b4a8eab57e42ed0c9203083f1d61e0b13935d1a569193ed8efc9ecfd7', 'type_id' : 'rpm', } unit_b = Unit(TYPE_ID_RPM, unit_key_b, {}, '') unit_b.storage_path = "%s/pulp-test-package/0.2.1/1.fc11/x86_64/4dbde07b4a8eab57e42ed0c9203083f1d61e0b13935d1a569193ed8efc9ecfd7/pulp-test-package-0.2.1-1.fc11.x86_64.rpm" % self.pkg_dir unit_key_c = {'id' : '', 'name' :'pulp-test-package', 'version' :'0.3.1', 'release' :'1.fc11', 'epoch':'0','arch' : 'x86_64', 'checksumtype' :'sha256', 'checksum': '6bce3f26e1fc0fc52ac996f39c0d0e14fc26fb8077081d5b4dbfb6431b08aa9f', 'type_id' : 'rpm', } unit_c = Unit(TYPE_ID_RPM, unit_key_c, {}, '') unit_c.storage_path = "%s/pulp-test-package/0.3.1/1.fc11/x86_64/6bce3f26e1fc0fc52ac996f39c0d0e14fc26fb8077081d5b4dbfb6431b08aa9f/pulp-test-package-0.3.1-1.fc11.x86_64.rpm" % self.pkg_dir existing_units = [] for unit in [unit_a, unit_b, unit_c]: existing_units.append(unit) sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, existing_units=existing_units, pkg_dir=self.pkg_dir) importerErrata = errata.ImporterErrata() importerErrata.sync(repo_1, sync_conduit, config) importerErrata.sync(repo_2, sync_conduit, config) repo_group = mock.Mock(spec=RepositoryGroup) repo_group.id = "test_group" repo_group.repo_ids = [repo_1.id, repo_2.id] repo_group.working_dir = self.group_working_dir global progress_status progress_status = None def set_progress(progress): global progress_status progress_status = progress publish_conduit = distributor_mocks.get_publish_conduit(existing_units=existing_units, pkg_dir=self.pkg_dir) config = distributor_mocks.get_basic_config(https_publish_dir=self.https_publish_dir, http_publish_dir=self.http_publish_dir, generate_metadata=True, http=True, https=False, iso_prefix="test-isos") distributor = GroupISODistributor() def cleanup(repo_working_dir): return iso_util.cleanup_working_dir.cleanup = mock.Mock() iso_util.cleanup_working_dir.side_effect = cleanup publish_conduit.set_progress = mock.Mock() publish_conduit.set_progress.side_effect = set_progress distributor.publish_group(repo_group, publish_conduit, config) self.assertTrue("isos" in progress_status) self.assertTrue(progress_status["isos"].has_key("state")) self.assertEqual(progress_status["isos"]["state"], "FINISHED") self.assertTrue(os.path.exists("%s/%s" % (self.http_publish_dir, repo_group.id))) self.assertEquals(len(os.listdir(self.https_publish_dir)), 0) isos_list = os.listdir("%s/%s" % (self.http_publish_dir, repo_group.id)) print isos_list self.assertEqual(len(isos_list), 1) # make sure the iso name defaults to repoid self.assertTrue( isos_list[0].startswith("test-isos"))
def test_install_units_unit_not_in_repo(self): """ This tests that if an erratum unit is requested to be installed, we do not attempt to install any RPM units that are not available in repos. For example, if an erratum contains packages for RHEL6 and RHEL7, we do not want to ask a RHEL6 consumer to install RHEL7 packages that are unavailable on that host. This is a related issue to errata applicability but is slightly different since the API caller wants to install a particular erratum, and is not trying to determine which errata are applicable. Note also that RHEA-2014:9999 has emoticons-0.1 and patb-0.1 in different package collections; this is atypical and would likely not be seen in the wild. I set it up like this to ensure the package list from the erratum was being flattened during comparisons. More detail is available in https://pulp.plan.io/issues/770 """ repo_id = "test_repo_id" # this erratum has four RPMs but only two are available errata_obj = self.get_test_errata_object(eid='RHEA-2014:9999') errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None) existing_units = [errata_unit] test_repo = profiler_mocks.get_repo(repo_id) # create two RPM units that match what is in the erratum. There are # higher versioned RPMs in the erratum that are not available; these # should not be installed. rpm_units = [] rpm_unit_key_1 = self.create_profile_entry("emoticons", 0, "0.1", "2", "x86_64", "Test Vendor") rpm_units.append(Unit(TYPE_ID_RPM, rpm_unit_key_1, {}, None)) rpm_unit_key_2 = self.create_profile_entry("patb", 0, "0.1", "2", "x86_64", "Test Vendor") rpm_units.append(Unit(TYPE_ID_RPM, rpm_unit_key_2, {}, None)) existing_units += rpm_units conduit = profiler_mocks.get_profiler_conduit( existing_units=existing_units, repo_bindings=[test_repo], repo_units=rpm_units) def mocked_get_units(repo_id, criteria=None): """ Override the default get_units in profiler_mocks. This method is specific to this particular unit test. The default get_units() in profiler_mocks only checks the criteria's type_id and not any other fields. :param repo_id: repo ID (unused) :type repo_id: not used :param criteria: unit association criteria :type criteria: pulp.server.db.model.criteria.UnitAssociationCriteria """ if TYPE_ID_ERRATA in criteria.type_ids: return [errata_unit] elif criteria['unit_filters']['name'] == 'emoticons' and \ criteria['unit_filters']['version'] == '0.1': return [rpm_units[0]] elif criteria['unit_filters']['name'] == 'patb' and \ criteria['unit_filters']['version'] == '0.1': return [rpm_units[1]] else: return [] conduit.get_units.side_effect = mocked_get_units example_errata = { "unit_key": errata_unit.unit_key, "type_id": TYPE_ID_ERRATA } prof = YumProfiler() translated_units = prof.install_units(self.test_consumer, [example_errata], None, None, conduit) # check repo_id passed to the conduit get_units() self.assertEqual(conduit.get_units.call_args_list[0][0][0].id, repo_id) # validate translated units self.assertEqual(len(translated_units), 2) self.assertEqual(translated_units[0]['unit_key']['filename'], 'patb-0.1-2.x86_64.rpm') self.assertEqual(translated_units[1]['unit_key']['filename'], 'emoticons-0.1-2.x86_64.rpm') expected = prof._get_rpms_from_errata(errata_unit) for u in translated_units: rpm_unit_key = u["unit_key"] self.assertTrue(rpm_unit_key in expected)
def _dict_to_unit(self, unit_dict): return Unit('fake_unit_type', unit_dict, {}, '')
def wrapper(*args, **kwargs): models = f(*args, **kwargs) return [ Unit(model.TYPE, model.unit_key, model.metadata, '') for model in models ]
def get_units(self): return [ Unit('T', {1: 1}, {2: 2}, 'path_1'), Unit('T', {1: 2}, {2: 2}, 'path_2'), Unit('T', {1: 3}, {2: 2}, 'path_3'), ]
def test_install_units_with_superseding_versions(self): """ Verify that errata installing multiple versions of a package installs the latest package In this test, there are three errata to install. Two provide the same package, but one errata has a higher version. The third errata installs two unrelated packages. Only the most recent package versions should be installed. """ profiler = YumProfiler() # "older" errata is associated with lower version rpm errata_obj_old = self.get_test_errata_object(eid='grinder_test_2') errata_old = Unit(TYPE_ID_ERRATA, {"errata_id": errata_obj_old["id"]}, errata_obj_old, None) rpm_key_old = self.create_profile_entry("grinder_test_package", 0, "2.0", "1.fc14", "noarch", "Test Vendor") # "newer" errata is associated with higher version rpm errata_obj_new = self.get_test_errata_object(eid='grinder_test_3') errata_new = Unit(TYPE_ID_ERRATA, {"errata_id": errata_obj_new["id"]}, errata_obj_new, None) rpm_key_new = self.create_profile_entry("grinder_test_package", 0, "3.0", "1.fc14", "noarch", "Test Vendor") # "unrelated" errata is a different package, a control errata_obj_unr = self.get_test_errata_object(eid='RHEA-2010:9999') errata_unr = Unit(TYPE_ID_ERRATA, {"errata_id": errata_obj_unr["id"]}, errata_obj_unr, None) rpm_key_unr_1 = self.create_profile_entry("emoticons", 0, "0.1", "2", "x86_64", "Test Vendor") rpm_key_unr_2 = self.create_profile_entry("patb", 0, "0.1", "2", "x86_64", "Test Vendor") # units list for the conduit rpm_keys = [rpm_key_old, rpm_key_new, rpm_key_unr_1, rpm_key_unr_2] rpm_units = [ Unit(TYPE_ID_RPM, rpm_key, {}, None) for rpm_key in rpm_keys ] existing_units = [errata_old, errata_new, errata_unr] + rpm_units # Set the profile to indicate that the errata apply by including fake unit keys of # installed packages with lower versions that need to be upgraded rpm_keys_installed = [ self.create_profile_entry("grinder_test_package", 0, "1.0", "1.fc14", "noarch", "Test Vendor"), self.create_profile_entry("emoticons", 0, "0.0", "1", "x86_64", "Test Vendor"), self.create_profile_entry("patb", 0, "0.0", "2", "x86_64", "Test Vendor") ] profiles = {TYPE_ID_RPM: rpm_keys_installed} # put together all the args for install_units and call it consumer = Consumer(self.consumer_id, profiles) errata = [ { "unit_key": errata_old.unit_key, "type_id": TYPE_ID_ERRATA }, { "unit_key": errata_new.unit_key, "type_id": TYPE_ID_ERRATA }, { "unit_key": errata_unr.unit_key, "type_id": TYPE_ID_ERRATA }, ] test_repo = profiler_mocks.get_repo("test_repo_id") conduit = profiler_mocks.get_profiler_conduit( existing_units=existing_units, repo_bindings=[test_repo], repo_units=rpm_units) translated_units = profiler.install_units(consumer, errata, None, None, conduit) # validate translated units: # - the unrelated rpms should still be present # - the rpm from the "newer" errata should still be present # - the rpm from the "older" errata should have been removed # - the total number of units present is 3 translated_filenames = [ u['unit_key']['filename'] for u in translated_units ] self.assertTrue('emoticons-0.1-2.x86_64.rpm' in translated_filenames) self.assertTrue('patb-0.1-2.x86_64.rpm' in translated_filenames) self.assertTrue('grinder_test_package-3.0-1.fc14.noarch.rpm' in translated_filenames) self.assertTrue('grinder_test_package-2.0-1.fc14.noarch.rpm' not in translated_filenames) self.assertEqual(len(translated_units), 3)
def test_iso_export_by_date_range(self): feed_url = "file://%s/test_errata_local_sync/" % self.data_dir repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "test_errata_local_sync" repo.checksumtype = "sha" sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, existing_units=[], pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) metadata = {} existing_units = [] unit_key_a = { "id": "", "name": "patb", "version": "0.1", "release": "2", "epoch": "0", "arch": "x86_64", "checksumtype": "sha", "checksum": "017c12050a97cf6095892498750c2a39d2bf535e", } rpm_unit_a = Unit(TYPE_ID_RPM, unit_key_a, metadata, "") rpm_unit_a.storage_path = ( "%s/patb/0.1/2/noarch/017c12050a97cf6095892498750c2a39d2bf535e/patb-0.1-2.noarch.rpm" % self.pkg_dir ) existing_units.append(rpm_unit_a) unit_key_b = { "id": "", "name": "emoticons", "version": "0.1", "release": "2", "epoch": "0", "arch": "x86_64", "checksumtype": "sha", "checksum": "663c89b0d29bfd5479d8736b716d50eed9495dbb", } rpm_unit_b = Unit(TYPE_ID_RPM, unit_key_b, metadata, "") rpm_unit_b.storage_path = ( "%s/emoticons/0.1/2/noarch/663c89b0d29bfd5479d8736b716d50eed9495dbb/emoticons-0.1-2.noarch.rpm" % self.pkg_dir ) existing_units.append(rpm_unit_b) sync_conduit = importer_mocks.get_sync_conduit( type_id=TYPE_ID_RPM, existing_units=existing_units, pkg_dir=self.pkg_dir ) importerErrata = errata.ImporterErrata() status, summary, details = importerErrata.sync(repo, sync_conduit, config) unit_key = dict() unit_key["id"] = "RHEA-2010:9999" mdata = { "description": "test", "from_str": "*****@*****.**", "issued": "2010-03-30 08:07:30", "pkglist": [ { "name": "RHEL Virtualization (v. 5 for 32-bit x86)", "packages": [ { "arch": "x86_64", "epoch": "0", "filename": "patb-0.1-2.x86_64.rpm", "name": "patb", "release": "2", "src": "", "sum": ("sha", "017c12050a97cf6095892498750c2a39d2bf535e"), "version": "0.1", }, { "arch": "x86_64", "epoch": "0", "filename": "emoticons-0.1-2.x86_64.rpm", "name": "emoticons", "release": "2", "src": "", "sum": ("sha", "663c89b0d29bfd5479d8736b716d50eed9495dbb"), "version": "0.1", }, ], "short": "rhel-i386-server-vt-5", } ], "pushcount": 1, "reboot_suggested": False, "references": [], "release": "", "rights": "", "status": "final", "summary": "", "title": "emoticons enhancement fix and enhancement update", "updated": "2010-03-30 08:07:30", "version": "1", "type": "enhancement", "severity": "Low", "solution": "", } unit_key_2 = dict() unit_key_2["id"] = "RHEA-2008:9999" mdata_2 = { "description": "test", "from_str": "*****@*****.**", "issued": "2008-03-30 00:00:00", "pkglist": [ { "name": "RHEL Virtualization (v. 5 for 32-bit x86)", "packages": [ { "arch": "x86_64", "epoch": "0", "filename": "patb-0.1-2.x86_64.rpm", "name": "patb", "release": "2", "src": "", "sum": ("sha", "017c12050a97cf6095892498750c2a39d2bf535e"), "version": "0.1", }, { "arch": "x86_64", "epoch": "0", "filename": "emoticons-0.1-2.x86_64.rpm", "name": "emoticons", "release": "2", "src": "", "sum": ("sha", "663c89b0d29bfd5479d8736b716d50eed9495dbb"), "version": "0.1", }, ], "short": "rhel-i386-server-vt-5", } ], "pushcount": 1, "reboot_suggested": False, "references": [], "release": "", "rights": "", "status": "final", "summary": "", "title": "emoticons enhancement fix and enhancement update", "updated": "2008-03-30 00:00:00", "version": "1", "type": "enhancement", "severity": "Low", "solution": "", } errata_unit = [Unit(TYPE_ID_ERRATA, unit_key, mdata, ""), Unit(TYPE_ID_ERRATA, unit_key_2, mdata_2, "")] existing_units += errata_unit print existing_units repo.working_dir = "%s/%s" % (self.repo_working_dir, "export") iso_distributor = ISODistributor() publish_conduit = distributor_mocks.get_publish_conduit(existing_units=existing_units, pkg_dir=self.pkg_dir) # test http publish config = distributor_mocks.get_basic_config( http_publish_dir=self.http_publish_dir, https_publish_dir=self.https_publish_dir, http=True, https=False, start_date="2009-03-30 08:07:30", end_date="2012-03-30 08:07:30", generate_metadata=True, ) def cleanup(rpm_working_dir): return iso_util.cleanup_working_dir = mock.Mock() iso_util.cleanup_working_dir.side_effect = cleanup report = iso_distributor.publish_repo(repo, publish_conduit, config) ftypes = util.get_repomd_filetypes("%s/%s" % (repo.working_dir, "repodata/repomd.xml")) self.assertTrue("updateinfo" in ftypes) updateinfo_path = "%s/%s" % (repo.working_dir, "updateinfo.xml") self.assertTrue(os.path.exists(updateinfo_path)) elist = updateinfo.get_errata(updateinfo_path) self.assertEquals(len(elist), 1) self.assertTrue(unit_key_2["id"] not in elist[0]) self.assertEquals(elist[0]["id"], unit_key["id"]) self.assertEquals(elist[0]["issued"], mdata["issued"]) self.assertTrue(os.path.exists("%s/%s" % (self.http_publish_dir, repo.id))) self.assertEquals(len(os.listdir(self.https_publish_dir)), 0) isos_list = os.listdir("%s/%s" % (self.http_publish_dir, repo.id)) self.assertEqual(len(isos_list), 1)
def test_associate_from_repo_no_criteria(self): # Setup source_repo_id = 'source-repo' dest_repo_id = 'dest-repo' self.repo_manager.create_repo(source_repo_id) self.importer_manager.set_importer(source_repo_id, 'mock-importer', {}) self.repo_manager.create_repo(dest_repo_id) self.importer_manager.set_importer(dest_repo_id, 'mock-importer', {}) self.content_manager.add_content_unit('mock-type', 'unit-1', {'key-1': 'unit-1'}) self.content_manager.add_content_unit('mock-type', 'unit-2', {'key-1': 'unit-2'}) self.content_manager.add_content_unit('mock-type', 'unit-3', {'key-1': 'unit-3'}) self.manager.associate_unit_by_id(source_repo_id, 'mock-type', 'unit-1', OWNER_TYPE_USER, 'admin') self.manager.associate_unit_by_id(source_repo_id, 'mock-type', 'unit-2', OWNER_TYPE_USER, 'admin') self.manager.associate_unit_by_id(source_repo_id, 'mock-type', 'unit-3', OWNER_TYPE_USER, 'admin') fake_user = User('associate-user', '') manager_factory.principal_manager().set_principal(principal=fake_user) mock_plugins.MOCK_IMPORTER.import_units.return_value = [ Unit('mock-type', {'k': 'v'}, {}, '') ] # Test results = self.manager.associate_from_repo(source_repo_id, dest_repo_id) associated = results['units_successful'] # Verify self.assertEqual(1, len(associated)) self.assertEqual(associated[0]['type_id'], 'mock-type') self.assertEqual(associated[0]['unit_key'], {'k': 'v'}) self.assertEqual(1, mock_plugins.MOCK_IMPORTER.import_units.call_count) args = mock_plugins.MOCK_IMPORTER.import_units.call_args[0] kwargs = mock_plugins.MOCK_IMPORTER.import_units.call_args[1] self.assertTrue(isinstance(args[0], Repository)) # repository transfer object self.assertEqual(args[0].id, 'source-repo') # repo importing units from self.assertEqual(args[1].id, 'dest-repo') # repo importing units into self.assertEqual(None, kwargs['units']) # units to import self.assertTrue(isinstance(args[3], PluginCallConfiguration)) # config conduit = args[2] self.assertTrue(isinstance(conduit, ImportUnitConduit)) self.assertEqual(conduit.association_owner_type, OWNER_TYPE_USER) self.assertEqual(conduit.association_owner_id, fake_user.login) # Clean Up manager_factory.principal_manager().set_principal(principal=None)
def test_associate_from_repo_with_criteria(self): # Setup source_repo_id = 'source-repo' dest_repo_id = 'dest-repo' self.repo_manager.create_repo(source_repo_id) self.importer_manager.set_importer(source_repo_id, 'mock-importer', {}) self.repo_manager.create_repo(dest_repo_id) self.importer_manager.set_importer(dest_repo_id, 'mock-importer', {}) self.content_manager.add_content_unit('mock-type', 'unit-1', { 'key-1': 'unit-1', 'key-2': 'foo', 'key-3': 'bar' }) self.content_manager.add_content_unit('mock-type', 'unit-2', { 'key-1': 'unit-2', 'key-2': 'foo', 'key-3': 'bar' }) self.content_manager.add_content_unit('mock-type', 'unit-3', { 'key-1': 'unit-3', 'key-2': 'foo', 'key-3': 'bar' }) self.manager.associate_unit_by_id(source_repo_id, 'mock-type', 'unit-1') self.manager.associate_unit_by_id(source_repo_id, 'mock-type', 'unit-2') self.manager.associate_unit_by_id(source_repo_id, 'mock-type', 'unit-3') mock_plugins.MOCK_IMPORTER.import_units.return_value = [ Unit('mock-type', {'k': 'v'}, {}, '') ] # Test overrides = {'abc': '123'} criteria = UnitAssociationCriteria(type_ids=['mock-type'], unit_filters={'key-1': 'unit-2'}, unit_fields=['key-1', 'key-2']) results = self.manager.associate_from_repo( source_repo_id, dest_repo_id, criteria=criteria, import_config_override=overrides) associated = results['units_successful'] # Verify self.assertEqual(1, len(associated)) self.assertEqual(associated[0]['type_id'], 'mock-type') self.assertEqual(associated[0]['unit_key'], {'k': 'v'}) self.assertEqual(1, mock_plugins.MOCK_IMPORTER.import_units.call_count) args = mock_plugins.MOCK_IMPORTER.import_units.call_args[0] kwargs = mock_plugins.MOCK_IMPORTER.import_units.call_args[1] for k, v in overrides.items(): self.assertEqual(args[3].get(k), v) # make sure the criteria's "unit_fields" are being respected by giving # us key-2, but not key-3 self.assertTrue('key-2' in kwargs['units'][0].metadata) self.assertTrue('key-3' not in kwargs['units'][0].metadata) self.assertEqual(1, len(kwargs['units'])) self.assertEqual(kwargs['units'][0].id, 'unit-2')
def test_iso_export_by_date_range(self): feed_url = "file://%s/test_errata_local_sync/" % self.data_dir repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "test_errata_local_sync" repo.checksumtype = 'sha' sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, existing_units=[], pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) metadata = {'updated' : '2010-03-30 08:07:30'} existing_units = [] unit_key_a = {'id' : '','name' :'patb', 'version' :'0.1', 'release' : '2', 'epoch':'0', 'arch' : 'x86_64', 'checksumtype' : 'sha', 'checksum': '017c12050a97cf6095892498750c2a39d2bf535e'} rpm_unit_a = Unit(TYPE_ID_RPM, unit_key_a, metadata, '') rpm_unit_a.storage_path = "%s/patb/0.1/2/noarch/017c12050a97cf6095892498750c2a39d2bf535e/patb-0.1-2.noarch.rpm" % self.pkg_dir existing_units.append(rpm_unit_a) unit_key_b = {'id' : '', 'name' :'emoticons', 'version' :'0.1', 'release' :'2', 'epoch':'0','arch' : 'x86_64', 'checksumtype' :'sha', 'checksum' : '663c89b0d29bfd5479d8736b716d50eed9495dbb'} rpm_unit_b = Unit(TYPE_ID_RPM, unit_key_b, metadata, '') rpm_unit_b.storage_path = "%s/emoticons/0.1/2/noarch/663c89b0d29bfd5479d8736b716d50eed9495dbb/emoticons-0.1-2.noarch.rpm" % self.pkg_dir existing_units.append(rpm_unit_b) sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, existing_units=existing_units, pkg_dir=self.pkg_dir) importerErrata = errata.ImporterErrata() status, summary, details = importerErrata.sync(repo, sync_conduit, config) unit_key = dict() unit_key['id'] = "RHEA-2010:9999" mdata = { 'description' : "test", 'from_str': '*****@*****.**', 'issued': '2010-03-30 08:07:30', 'pkglist': [{'name': 'RHEL Virtualization (v. 5 for 32-bit x86)', 'packages': [{'arch': 'x86_64', 'epoch': '0', 'filename': 'patb-0.1-2.x86_64.rpm', 'name': 'patb', 'release': '2', 'src': '', 'sum': ('sha', '017c12050a97cf6095892498750c2a39d2bf535e'), 'version': '0.1'}, {'arch': 'x86_64', 'epoch': '0', 'filename': 'emoticons-0.1-2.x86_64.rpm', 'name': 'emoticons', 'release': '2', 'src': '', 'sum': ('sha', '663c89b0d29bfd5479d8736b716d50eed9495dbb'), 'version': '0.1'}], 'short': 'rhel-i386-server-vt-5'}], 'pushcount': 1, 'reboot_suggested': False, 'references': [], 'release': '', 'rights': '', 'status': 'final', 'summary': '', 'title': 'emoticons enhancement fix and enhancement update', 'updated': '2010-03-30 08:07:30', 'version': '1', 'type' : 'enhancement', 'severity' : 'Low', 'solution' : ''} unit_key_2 = dict() unit_key_2['id'] = "RHEA-2008:9999" mdata_2 = { 'description' : "test", 'from_str': '*****@*****.**', 'issued': '2008-03-30 00:00:00', 'pkglist': [{'name': 'RHEL Virtualization (v. 5 for 32-bit x86)', 'packages': [{'arch': 'x86_64', 'epoch': '0', 'filename': 'patb-0.1-2.x86_64.rpm', 'name': 'patb', 'release': '2', 'src': '', 'sum': ('sha', '017c12050a97cf6095892498750c2a39d2bf535e'), 'version': '0.1'}, {'arch': 'x86_64', 'epoch': '0', 'filename': 'emoticons-0.1-2.x86_64.rpm', 'name': 'emoticons', 'release': '2', 'src': '', 'sum': ('sha', '663c89b0d29bfd5479d8736b716d50eed9495dbb'), 'version': '0.1'}], 'short': 'rhel-i386-server-vt-5'}], 'pushcount': 1, 'reboot_suggested': False, 'references': [], 'release': '', 'rights': '', 'status': 'final', 'summary': '', 'title': 'emoticons enhancement fix and enhancement update', 'updated': '2008-03-30 00:00:00', 'version': '1', 'type' : 'enhancement', 'severity' : 'Low', 'solution' : ''} errata_unit = [Unit(TYPE_ID_ERRATA, unit_key, mdata, ''), Unit(TYPE_ID_ERRATA, unit_key_2, mdata_2, '')] existing_units += errata_unit print existing_units repo.working_dir = "%s/%s" % (self.repo_working_dir, "export") iso_distributor = ISODistributor() publish_conduit = distributor_mocks.get_publish_conduit(existing_units=existing_units, pkg_dir=self.pkg_dir) # test http publish config = distributor_mocks.get_basic_config(http_publish_dir=self.http_publish_dir, https_publish_dir=self.https_publish_dir, http=True, https=False, start_date="2009-03-30 08:07:30", end_date="2012-03-30 08:07:30", generate_metadata=True) def cleanup(rpm_working_dir): return iso_util.cleanup_working_dir = mock.Mock() iso_util.cleanup_working_dir.side_effect = cleanup report = iso_distributor.publish_repo(repo, publish_conduit, config) ftypes = util.get_repomd_filetypes("%s/%s" % (repo.working_dir, "repodata/repomd.xml")) self.assertTrue("updateinfo" in ftypes) updateinfo_path = util.get_repomd_filetype_path("%s/%s" % (repo.working_dir, "repodata/repomd.xml"), "updateinfo") updateinfo_path = os.path.join(repo.working_dir, updateinfo_path) self.assertTrue(os.path.exists(updateinfo_path)) elist = updateinfo.get_errata(updateinfo_path) self.assertEquals(len(elist), 1) self.assertTrue(unit_key_2['id'] not in elist[0]) self.assertEquals(elist[0]['id'], unit_key['id']) self.assertEquals(elist[0]['issued'], mdata['issued']) self.assertTrue(os.path.exists("%s/%s" % (self.http_publish_dir, repo.id))) self.assertEquals(len(os.listdir(self.https_publish_dir)), 0) isos_list = os.listdir("%s/%s" % (self.http_publish_dir, repo.id)) self.assertEqual(len(isos_list), 1)