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)
