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_remove_old_packages(self): feed_url = "http://jmatthews.fedorapeople.org/repo_multiple_versions/" repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_remove_old_packages" sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, pkg_dir=self.pkg_dir) ### # Test that old packages are not in rpmList and are never intended to be downloaded # Additionallity verify that already existing packages which are NOT orphaned are also # removed with remove_old functionality ### config = importer_mocks.get_basic_config(feed_url=feed_url, remove_old=False, num_old_packages=0) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) self.assertTrue(status) self.assertEquals(summary["num_synced_new_rpms"], 12) pkgs = self.get_files_in_dir("*.rpm", self.pkg_dir) self.assertEquals(len(pkgs), 12) yumRepoGrinder = importer_rpm.get_yumRepoGrinder(repo.id, repo.working_dir, config) yumRepoGrinder.setup(basepath=repo.working_dir) rpm_items = yumRepoGrinder.getRPMItems() yumRepoGrinder.stop() del yumRepoGrinder self.assertEquals(len(rpm_items), 12) existing_units = [] for rpm in rpm_items: u = Unit( TYPE_ID_RPM, importer_rpm.form_rpm_unit_key(rpm), importer_rpm.form_rpm_metadata(rpm), os.path.join(self.pkg_dir, rpm["pkgpath"], rpm["filename"]), ) existing_units.append(u) config = importer_mocks.get_basic_config(feed_url=feed_url, remove_old=True, num_old_packages=6) sync_conduit = importer_mocks.get_sync_conduit( type_id=TYPE_ID_RPM, existing_units=existing_units, pkg_dir=self.pkg_dir ) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) self.assertTrue(status) self.assertEquals(summary["num_rpms"], 7) self.assertEquals(summary["num_orphaned_rpms"], 5) self.assertEquals(summary["num_synced_new_rpms"], 0) self.assertEquals(summary["num_not_synced_rpms"], 0) pkgs = self.get_files_in_dir("*.rpm", self.pkg_dir) self.assertEquals(len(pkgs), 7) config = importer_mocks.get_basic_config(feed_url=feed_url, remove_old=True, num_old_packages=0) importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) self.assertTrue(status) self.assertEquals(summary["num_rpms"], 1) self.assertEquals(summary["num_orphaned_rpms"], 11) self.assertEquals(summary["num_synced_new_rpms"], 0) self.assertEquals(summary["num_not_synced_rpms"], 0) pkgs = self.get_files_in_dir("*.rpm", self.pkg_dir) self.assertEquals(len(pkgs), 1)
def test_errata_sync_with_repos_that_share_upstream_url(self): # This test is for https://bugzilla.redhat.com/show_bug.cgi?id=870495 feed_url = "http://example.com/test_repo/" # Set up repo_1 and sync it importer_1 = YumImporter() repo_1 = mock.Mock(spec=Repository) repo_1.working_dir = self.working_dir repo_1.id = "test_repo_1" sync_conduit_1 = importer_mocks.get_sync_conduit() config_1 = importer_mocks.get_basic_config(feed_url=feed_url) self.simulate_sync(repo_1, self.repo_dir) importer_errata_1 = errata.ImporterErrata() status_1, summary_1, details_1 = importer_errata_1.sync(repo_1, sync_conduit_1, config_1) self.assertTrue(status_1) self.assertTrue(summary_1 is not None) self.assertTrue(details_1 is not None) self.assertEquals(summary_1["num_new_errata"], 52) self.assertEquals(summary_1["num_existing_errata"], 0) self.assertEquals(summary_1["num_orphaned_errata"], 0) self.assertEquals(details_1["num_bugfix_errata"], 36) self.assertEquals(details_1["num_security_errata"], 7) self.assertEquals(details_1["num_enhancement_errata"], 9) # We should have called save_unit() once for each errata, in sync(). self.assertEqual(len(sync_conduit_1.save_unit.mock_calls), 52) # Now let's set up another repo with the same URL, and then sync. We should get the same # errata. importer_2 = YumImporter() repo_2 = mock.Mock(spec=Repository) working_dir_2 = os.path.join(self.temp_dir, "working_2") os.makedirs(working_dir_2) repo_2.working_dir = working_dir_2 repo_2.id = "test_repo_2" unit_key = {'id': "RHBA-2007:0112"} metadata = {'updated' : "2007-03-14 00:00:00", 'pkglist': [{'name': 'RHEL Virtualization (v. 5 for 32-bit x86)'}]} existing_units = [Unit(TYPE_ID_ERRATA, unit_key, metadata, '')] existing_units[0].updated = metadata['updated'] sync_conduit_2 = importer_mocks.get_sync_conduit(existing_units=existing_units) config_2 = importer_mocks.get_basic_config(feed_url=feed_url) self.simulate_sync(repo_2, self.repo_dir) importer_errata_2 = errata.ImporterErrata() status_2, summary_2, details_2 = importer_errata_2.sync(repo_2, sync_conduit_2, config_2) self.assertTrue(status_2) self.assertTrue(summary_2 is not None) self.assertTrue(details_2 is not None) self.assertEquals(summary_2["num_new_errata"], 51) self.assertEquals(summary_2["num_existing_errata"], 1) self.assertEquals(summary_2["num_orphaned_errata"], 0) self.assertEquals(details_2["num_bugfix_errata"], 35) self.assertEquals(details_2["num_security_errata"], 7) self.assertEquals(details_2["num_enhancement_errata"], 9) # There should be the same number of calls to save_unit() as there are errata, # because sync() calls it once for each of the 51 new erratum, and get_new_errata_units() # also calls it once for the one errata that already existed self.assertEqual(len(sync_conduit_2.save_unit.mock_calls), 52)
def test_sync_of_orphaned_data(self): # Sync repo with some initial data # Modify the underlying directory to make it look like source has changed # Re-sync # Verify orphaned groups/categories were removed ic = ImporterComps() repo_src_dir = os.path.join(self.data_dir, "test_orphaned_data_initial") feed_url = "file://%s" % (repo_src_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) repo = mock.Mock(spec=Repository) repo.id = "test_sync_of_orphaned_data" repo.working_dir = self.working_dir # Simulate a repo sync, copy the source contents to the repo.working_dir self.simulate_sync(repo, repo_src_dir) sync_conduit = importer_mocks.get_sync_conduit() status, summary, details = ic.sync(repo, sync_conduit, config) self.assertTrue(status) self.assertEqual(summary["num_available_groups"], 3) self.assertEqual(summary["num_available_categories"], 2) self.assertEqual(summary["num_new_groups"], 3) self.assertEqual(summary["num_new_categories"], 2) self.assertEqual(summary["num_orphaned_groups"], 0) self.assertEqual(summary["num_orphaned_categories"], 0) self.assertTrue(summary["time_total_sec"] > 0) # # Simulate the existing_units # avail_groups, avail_cats = comps.get_available(repo_src_dir) existing_cats, existing_cat_units = comps.get_new_category_units(avail_cats, {}, sync_conduit, repo) existing_groups, existing_group_units = comps.get_new_group_units(avail_groups, {}, sync_conduit, repo) self.assertEquals(len(existing_cats), 2) self.assertEquals(len(existing_groups), 3) existing_units = [] existing_units.extend(existing_group_units.values()) existing_units.extend(existing_cat_units.values()) self.assertEquals(len(existing_units), (len(existing_cats) + len(existing_groups))) # # Now we will simulate a change to the feed and pass in our existing units # repo_src_dir = os.path.join(self.data_dir, "test_orphaned_data_final") feed_url = "file://%s" % (repo_src_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) sync_conduit = importer_mocks.get_sync_conduit(existing_units=existing_units) self.simulate_sync(repo, repo_src_dir) status, summary, details = ic.sync(repo, sync_conduit, config) self.assertTrue(status) self.assertEqual(summary["num_available_groups"], 2) self.assertEqual(summary["num_available_categories"], 1) self.assertEqual(summary["num_new_groups"], 0) self.assertEqual(summary["num_new_categories"], 0) self.assertEqual(summary["num_orphaned_groups"], 1) self.assertEqual(summary["num_orphaned_categories"], 1) self.assertTrue(summary["time_total_sec"] > 0)
def test_bandwidth_limit(self): # This test assumes an available bandwidth of more than 100KB for 2 threads feed_url = 'http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/test_bandwidth_repo_smaller/' expected_size_bytes = 209888 # 5 1MB RPMs are in this repo expected_num_packages = 2 num_threads = 2 max_speed = 25 # KB/sec repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_bandwidth_limit" sync_conduit = importer_mocks.get_sync_conduit(existing_units=[], pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config(feed_url=feed_url, num_threads=num_threads, max_speed=max_speed) start = time.time() importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) end = time.time() self.assertTrue(status) self.assertEquals(summary["num_synced_new_rpms"], expected_num_packages) self.assertEquals(summary["num_resynced_rpms"], 0) self.assertEquals(summary["num_not_synced_rpms"], 0) self.assertEquals(summary["num_orphaned_rpms"], 0) self.assertEquals(details["size_total"], expected_size_bytes) expected = (float(expected_size_bytes)/(num_threads*max_speed*1000)) actual_A = end - start self.assertTrue(actual_A > expected) # # Clean up and resync with no bandwidth limit # Ensure result is quicker than above # max_speed = 0 self.clean() self.init() repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_bandwidth_limit" sync_conduit = importer_mocks.get_sync_conduit(existing_units=[], pkg_dir=self.pkg_dir) config = importer_mocks.get_basic_config(feed_url=feed_url, num_threads=num_threads, max_speed=max_speed) start = time.time() importerRPM = importer_rpm.ImporterRPM() status, summary, details = importerRPM.sync(repo, sync_conduit, config) end = time.time() self.assertTrue(status) self.assertEquals(summary["num_synced_new_rpms"], expected_num_packages) self.assertEquals(summary["num_resynced_rpms"], 0) self.assertEquals(summary["num_not_synced_rpms"], 0) self.assertEquals(summary["num_orphaned_rpms"], 0) self.assertEquals(details["size_total"], expected_size_bytes)
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_basic_sync_groups(self): global updated_progress updated_progress = None def set_progress(status_type, progress): global updated_progress updated_progress = progress ic = ImporterComps() repo_src_dir = os.path.join(self.data_dir, "pulp_unittest") feed_url = "file://%s" % (repo_src_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) repo = mock.Mock(spec=Repository) repo.id = "test_basic_sync_groups" repo.working_dir = self.working_dir # Simulate a repo sync, copy the source contents to the repo.working_dir self.simulate_sync(repo, repo_src_dir) sync_conduit = importer_mocks.get_sync_conduit(pkg_dir=self.pkg_dir) status, summary, details = ic.sync(repo, sync_conduit, config, set_progress) self.assertTrue(status) self.assertEqual(summary["num_available_groups"], 3) self.assertEqual(summary["num_available_categories"], 2) self.assertEqual(summary["num_new_groups"], 3) self.assertEqual(summary["num_new_categories"], 2) self.assertEqual(summary["num_orphaned_groups"], 0) self.assertEqual(summary["num_orphaned_categories"], 0) self.assertTrue(summary["time_total_sec"] > 0)
def test_sync_groups_no_metadata_present(self): global updated_progress updated_progress = None def set_progress(status_type, progress): global updated_progress updated_progress = progress ic = ImporterComps() feed_url = "file://%s/simple_repo_no_comps" % (self.data_dir) config = importer_mocks.get_basic_config(feed_url=feed_url) repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_sync_groups_no_metadata_present" sync_conduit = importer_mocks.get_sync_conduit(pkg_dir=self.pkg_dir) status, summary, details = ic.sync(repo, sync_conduit, config, set_progress) self.assertTrue(status) self.assertEqual(updated_progress["state"], "FINISHED") self.assertEqual(summary["num_available_groups"], 0) self.assertEqual(summary["num_available_categories"], 0) self.assertEqual(summary["num_orphaned_groups"], 0) self.assertEqual(summary["num_orphaned_categories"], 0) self.assertEqual(summary["num_new_groups"], 0) self.assertEqual(summary["num_new_categories"], 0) self.assertTrue(summary["time_total_sec"] > 0)
def test_skip_packagegroups(self): global updated_progress updated_progress = None def set_progress(progress): global updated_progress updated_progress = progress yi = YumImporter() skip = ["packagegroup"] repo_src_dir = os.path.join(self.data_dir, "pulp_unittest") feed_url = "file://%s" % (repo_src_dir) config = importer_mocks.get_basic_config(feed_url=feed_url,skip_content_types=skip) repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_skip_packagegroup" # Simulate a repo sync, copy the source contents to the repo.working_dir self.simulate_sync(repo, repo_src_dir) sync_conduit = importer_mocks.get_sync_conduit(pkg_dir=self.pkg_dir) sync_conduit.set_progress = mock.Mock() sync_conduit.set_progress = set_progress status, summary, details = yi._sync_repo(repo, sync_conduit, config) self.assertTrue(status) self.assertEqual(updated_progress["comps"]["state"], "SKIPPED")
def test_progress_sync(self): global updated_progress updated_progress = None def set_progress(progress): global updated_progress updated_progress = progress feed_url = "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/pulp_unittest/" importer = YumImporter() repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_progress_sync" sync_conduit = importer_mocks.get_sync_conduit(pkg_dir=self.pkg_dir) sync_conduit.set_progress = mock.Mock() sync_conduit.set_progress.side_effect = set_progress config = importer_mocks.get_basic_config(feed_url=feed_url) status, summary, details = importer._sync_repo(repo, sync_conduit, config) self.assertTrue(status) self.assertEquals(summary["packages"]["num_synced_new_rpms"], 3) self.assertTrue(updated_progress is not None) self.assertTrue("metadata" in updated_progress) self.assertTrue(updated_progress["metadata"].has_key("state")) self.assertTrue("errata" in updated_progress) self.assertTrue(updated_progress["errata"].has_key("state")) self.assertTrue("content" in updated_progress) self.assertTrue(updated_progress["content"].has_key("state")) self.assertEquals(updated_progress["content"]["state"], "FINISHED") for key in importer_rpm.PROGRESS_REPORT_FIELDS: self.assertTrue(key in updated_progress["content"])
def test_repo_scratchpad_settings(self): global repo_scratchpad repo_scratchpad = {} def set_repo_scratchpad(data): global repo_scratchpad repo_scratchpad = data def get_repo_scratchpad(): global repo_scratchpad return repo_scratchpad feed_url = "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/test_drpm_repo/" importer = YumImporter() repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_repo_scratchpad" sync_conduit = importer_mocks.get_sync_conduit(pkg_dir=self.pkg_dir) sync_conduit.set_repo_scratchpad = mock.Mock() sync_conduit.set_repo_scratchpad.side_effect = set_repo_scratchpad sync_conduit.get_repo_scratchpad = mock.Mock() sync_conduit.get_repo_scratchpad.side_effect = get_repo_scratchpad config = importer_mocks.get_basic_config(feed_url=feed_url) importer._sync_repo(repo, sync_conduit, config) print "SCRATCHPAD %s" % repo_scratchpad self.assertEquals(repo_scratchpad['checksum_type'], 'sha256') self.assertTrue(repo_scratchpad.has_key("repodata")) self.assertTrue(repo_scratchpad["repodata"].has_key("prestodelta"))
def test_local_sync_with_packages_in_subdir(self): feed_url = "file://%s/repo_packages_in_subdirs/" % (self.data_dir) repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_local_sync_with_packages_in_subdir" 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) self.assertEquals(summary["num_synced_new_rpms"], 3) self.assertEquals(summary["num_resynced_rpms"], 0) self.assertEquals(summary["num_not_synced_rpms"], 0) self.assertEquals(summary["num_orphaned_rpms"], 0) self.assertEquals(details["size_total"], 6868) # Confirm regular RPM files exist under self.pkg_dir pkgs = self.get_files_in_dir("*.rpm", self.pkg_dir) self.assertEquals(len(pkgs), 3) for p in pkgs: self.assertTrue(os.path.isfile(p)) # Confirm symlinks to RPMs exist under repo.working_dir sym_links = self.get_files_in_dir("*.rpm", repo.working_dir) self.assertEquals(len(pkgs), 3) for link in sym_links: self.assertTrue(os.path.islink(link))
def test_drpm_sync(self): feed_url = "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/test_drpm_repo/" 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) self.assertTrue(summary is not None) self.assertTrue(details is not None) self.assertEquals(summary["num_synced_new_drpms"], 18) self.assertEquals(summary["num_resynced_drpms"], 0) self.assertEquals(summary["num_orphaned_drpms"], 0) # validate drpms on filesystem def get_drpm_list(dir): dpkgs = [] for root, dirs, files in os.walk(dir): for file in files: dpkgs.append("%s/%s" % (root, file)) return dpkgs dpkgs = filter(lambda x: x.endswith(".drpm"), get_drpm_list(self.pkg_dir)) self.assertEquals(len(dpkgs), 18) # Confirm symlinks sym_links = filter(lambda x: x.endswith(".drpm"), get_drpm_list(repo.working_dir)) self.assertEquals(len(sym_links), 18) for link in sym_links: self.assertTrue(os.path.islink(link))
def setUp(self): self.config = importer_mocks.get_basic_config( feed_url='http://fake.com/iso_feed/', max_speed=500.0, num_threads=5, ssl_client_cert="Trust me, I'm who I say I am.", ssl_client_key="Secret Key", ssl_ca_cert="Uh, I guess that's the right server.", proxy_url='http://proxy.com', proxy_port=1234, proxy_user="******", proxy_password='******') self.temp_dir = tempfile.mkdtemp() self.pkg_dir = os.path.join(self.temp_dir, 'content') os.mkdir(self.pkg_dir) # These checksums correspond to the checksums of the files that our curl mocks will generate. Our # curl mocks do not have a test4.iso, so that one is to test removal of old ISOs during sync self.existing_units = [ Unit(TYPE_ID_ISO, {'name': 'test.iso', 'size': 16, 'checksum': 'f02d5a72cd2d57fa802840a76b44c6c6920a8b8e6b90b20e26c03876275069e0'}, {}, '/path/test.iso'), Unit(TYPE_ID_ISO, {'name': 'test2.iso', 'size': 22, 'checksum': 'c7fbc0e821c0871805a99584c6a384533909f68a6bbe9a2a687d28d9f3b10c16'}, {}, '/path/test2.iso'), Unit(TYPE_ID_ISO, {'name': 'test4.iso', 'size': 4, 'checksum': 'sum4'}, {}, '/path/test4.iso')] self.sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_ISO, pkg_dir=self.pkg_dir, existing_units=self.existing_units) self.iso_sync_run = ISOSyncRun(self.sync_conduit, self.config)
def test_remove_packages(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_remove_packages" 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(status) self.assertEquals(summary["num_synced_new_rpms"], 3) self.assertEquals(len(self.get_files_in_dir("*.rpm", self.pkg_dir)), 3) self.assertEquals(len(self.get_files_in_dir("*.rpm", repo.working_dir)), 3) expected_rpms = self.get_expected_rpms_from_pulp_unittest(repo.id) # Confirm that both the RPM and the Symlink for each expected rpm does exist # Then run remove_unit # Confirm that both the RPM and the Symlink have been deleted from the file system for rpm in expected_rpms.values(): rpm_save_path = os.path.join(rpm["pkgpath"], rpm["filename"]) self.assertTrue(os.path.exists(rpm_save_path)) symlink_save_path = os.path.join(rpm["savepath"], rpm["filename"]) self.assertTrue(os.path.lexists(symlink_save_path)) unit = Unit(TYPE_ID_RPM, importer_rpm.form_rpm_unit_key(rpm), importer_rpm.form_rpm_metadata(rpm), rpm_save_path) importer_rpm.remove_unit(sync_conduit, unit) self.assertTrue(os.path.exists(rpm_save_path)) self.assertTrue(os.path.exists(symlink_save_path))
def test_cancel_sync(self): global updated_progress updated_progress = None def set_progress(progress): global updated_progress updated_progress = progress class SyncThread(threading.Thread): def __init__(self, importer, repo, sync_conduit, config): threading.Thread.__init__(self) self.importer = importer self.repo = repo self.sync_conduit = sync_conduit self.config = config self.status = None self.summary = None self.details = None self.finished = False def run(self): status, summary, details = self.importer._sync_repo(self.repo, self.sync_conduit, self.config) self.status = status self.summary = summary self.details = details self.finished = True feed_url = "http://repos.fedorapeople.org/repos/pulp/pulp/v1/testing/6Server/x86_64/" repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_cancel_sync" sync_conduit = importer_mocks.get_sync_conduit(existing_units=[], pkg_dir=self.pkg_dir) sync_conduit.set_progress = mock.Mock() sync_conduit.set_progress.side_effect = set_progress config = importer_mocks.get_basic_config(feed_url=feed_url, num_threads=1, max_speed=25) importer = YumImporter() sync_thread = SyncThread(importer, repo, sync_conduit, config) sync_thread.start() # Wait to confirm that sync has started and we are downloading packages # We are intentionally setting the 'config' to use 1 thread and max_speed to be low so we will # have a chance to cancel the sync before it completes for i in range(30): if updated_progress and updated_progress.has_key("content") and updated_progress["content"].has_key("state") \ and updated_progress["content"]["state"] == "IN_PROGRESS": break time.sleep(1) self.assertEquals(updated_progress["metadata"]["state"], "FINISHED") self.assertEquals(updated_progress["content"]["state"], "IN_PROGRESS") ### ### Issue Cancel ### importer.cancel_sync_repo(None, None) # Wait for cancel of sync for i in range(45): if sync_thread.finished: break time.sleep(1) self.assertEquals(updated_progress["content"]["state"], "CANCELED") self.assertFalse(sync_thread.status)
def test_sync_no_feed(self): repo = mock.MagicMock(spec=Repository) pkg_dir = os.path.join(self.temp_dir, 'content') sync_conduit = importer_mocks.get_sync_conduit(type_id=ids.TYPE_ID_ISO, pkg_dir=pkg_dir) config = {importer_constants.KEY_FEED: None} config = importer_mocks.get_basic_config(**config) # Now run the sync self.assertRaises(ValueError, self.iso_importer.sync_repo, repo, sync_conduit, config)
def test_get_existing_errata(self): unit_key = dict() unit_key['id'] = "RHBA-2007:0112" metadata = {'updated' : "2007-03-13 00:00:00"} existing_units = [Unit(TYPE_ID_ERRATA, unit_key, metadata, '')] sync_conduit = importer_mocks.get_sync_conduit(existing_units=existing_units) created_existing_units = errata.get_existing_errata(sync_conduit) self.assertEquals(len(created_existing_units), 1) self.assertEquals(len(existing_units), len(created_existing_units))
def test_upload_unit_validate_unset(self, remove, validate): """ Assert correct behavior from upload_unit() when the validation setting is not set. This should default to validating the upload. """ # Set up the test file_data = 'This is a file.\n' working_dir = os.path.join(self.temp_dir, "working") os.mkdir(working_dir) pkg_dir = os.path.join(self.temp_dir, 'content') os.mkdir(pkg_dir) repo = mock.MagicMock(spec=Repository) repo.working_dir = working_dir # Set the checksum incorrect. The upload should be unsuccessful since the default is to # validate unit_key = {'name': 'test.iso', 'size': 16, 'checksum': 'Wrong'} metadata = {} temp_file_location = os.path.join(self.temp_dir, 'test.iso') with open(temp_file_location, 'w') as temp_file: temp_file.write(file_data) sync_conduit = importer_mocks.get_sync_conduit(type_id=ids.TYPE_ID_ISO, pkg_dir=pkg_dir) # validate isn't set, so default should happen config = importer_mocks.get_basic_config() # Run the upload. This should report a failure report = self.iso_importer.upload_unit(repo, ids.TYPE_ID_ISO, unit_key, metadata, temp_file_location, sync_conduit, config) self.assertEqual(report['success_flag'], False) self.assertEqual( report['summary'], ('Downloading <test.iso> failed checksum validation. The manifest specified the ' 'checksum to be Wrong, but it was ' 'f02d5a72cd2d57fa802840a76b44c6c6920a8b8e6b90b20e26c03876275069e0.')) # The conduit's init_unit method should have been called expected_rel_path = os.path.join(unit_key['name'], unit_key['checksum'], str(unit_key['size']), unit_key['name']) sync_conduit.init_unit.assert_called_once_with(ids.TYPE_ID_ISO, unit_key, metadata, expected_rel_path) # The file should have been moved to its final destination self.assertFalse(os.path.exists(temp_file_location)) would_be_destination = os.path.join(pkg_dir, expected_rel_path) self.assertFalse(os.path.exists(would_be_destination)) # The file should have been removed remove.assert_called_once_with(would_be_destination) # validate() should have been called with the full_validation=True flag iso = validate.mock_calls[0][1][0] validate.assert_called_once_with(iso, full_validation=True) # The conduit's save_unit method should have been called self.assertEqual(sync_conduit.save_unit.call_count, 0)
def test_sync_calls_sync(self, mock_sync_run): repo = Repository('repo1') sync_conduit = importer_mocks.get_sync_conduit(type_id=ids.TYPE_ID_ISO, pkg_dir='/a/b/c') config = importer_mocks.get_basic_config(**{ importer_constants.KEY_FEED: 'http://fake.com/iso_feed/'}) self.iso_importer.sync_repo(repo, sync_conduit, config) # make sure the sync workflow is called with the right stuff mock_sync_run.assert_called_once_with(sync_conduit, config) mock_sync_run.return_value.perform_sync.assert_called_once_with()
def test_get_existing_units(self): unit_key = {} for k in UNIT_KEY_RPM: unit_key[k] = "test_value" existing_units = [Unit(TYPE_ID_RPM, unit_key, "test_metadata", os.path.join(self.pkg_dir, "test_rel_path"))] sync_conduit = importer_mocks.get_sync_conduit(existing_units=existing_units, pkg_dir=self.pkg_dir) actual_existing_units = importer_rpm.get_existing_units(sync_conduit) self.assertEquals(len(actual_existing_units), 1) self.assertEquals(len(existing_units), len(actual_existing_units)) lookup_key = importer_rpm.form_lookup_key(unit_key) self.assertEqual(existing_units[0], actual_existing_units[lookup_key])
def test_feedless_repo_sync(self): repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_feedless_repo_sync" sync_conduit = importer_mocks.get_sync_conduit(type_id=TYPE_ID_RPM, pkg_dir=self.pkg_dir) sync_conduit.set_progress = mock.Mock() config = importer_mocks.get_basic_config() importer = YumImporter() status, summary, details = importer._sync_repo(repo, sync_conduit, config) self.assertFalse(status) self.assertEquals(summary['error'], "Cannot perform repository sync on a repository with no feed")
def test_upload_unit_validate_false(self, validate): """ Assert correct behavior from upload_unit() when the validation setting is False. """ # Set up the test file_data = 'This is a file.\n' working_dir = os.path.join(self.temp_dir, "working") os.mkdir(working_dir) pkg_dir = os.path.join(self.temp_dir, 'content') os.mkdir(pkg_dir) repo = mock.MagicMock(spec=Repository) repo.working_dir = working_dir # Set the checksum incorrect. The upload should be successful no matter what since # validation will be set to False unit_key = {'name': 'test.iso', 'size': 16, 'checksum': 'Wrong'} metadata = {} temp_file_location = os.path.join(self.temp_dir, 'test.iso') with open(temp_file_location, 'w') as temp_file: temp_file.write(file_data) sync_conduit = importer_mocks.get_sync_conduit(type_id=ids.TYPE_ID_ISO, pkg_dir=pkg_dir) config = importer_mocks.get_basic_config(**{importer_constants.KEY_VALIDATE: 'false'}) # Run the upload. This should be successful, since we have set validation off. report = self.iso_importer.upload_unit(repo, ids.TYPE_ID_ISO, unit_key, metadata, temp_file_location, sync_conduit, config) # The import should have been successful self.assertEqual(report['success_flag'], True) self.assertEqual(report['summary'], None) # The conduit's init_unit method should have been called expected_rel_path = os.path.join(unit_key['name'], unit_key['checksum'], str(unit_key['size']), unit_key['name']) sync_conduit.init_unit.assert_called_once_with(ids.TYPE_ID_ISO, unit_key, metadata, expected_rel_path) # The file should have been moved to its final destination self.assertFalse(os.path.exists(temp_file_location)) expected_destination = os.path.join(pkg_dir, expected_rel_path) self.assertTrue(os.path.exists(expected_destination)) with open(expected_destination) as iso_file: self.assertEqual(iso_file.read(), file_data) # validate() should still have been called, but with the full_validation=False flag # We need to get the ISO itself for our assertion, since it is technically the first # argument iso = validate.mock_calls[0][1][0] validate.assert_called_once_with(iso, full_validation=False) # The conduit's save_unit method should have been called self.assertEqual(sync_conduit.save_unit.call_count, 1) saved_unit = sync_conduit.save_unit.mock_calls[0][1][0] self.assertEqual(saved_unit.unit_key, unit_key)
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_update_errata_units(self): # existing errata is older than available; should purge and resync available_errata = errata.get_available_errata(self.repo_dir) self.assertEqual(52, len(available_errata)) unit_key = dict() unit_key['id'] = "RHBA-2007:0112" metadata = {'updated' : "2007-03-13 00:00:00"} existing_units = [Unit(TYPE_ID_ERRATA, unit_key, metadata, '')] existing_units[0].updated = "2007-03-13 00:00:00" sync_conduit = importer_mocks.get_sync_conduit(existing_units=existing_units) created_existing_units = errata.get_existing_errata(sync_conduit) self.assertEquals(len(created_existing_units), 1) new_errata, new_units, sync_conduit = errata.get_new_errata_units(available_errata, sync_conduit) self.assertEquals(len(available_errata), len(new_errata))
def get_pkg_group_or_category(self, repo, type_id): repo_src_dir = os.path.join(self.data_dir, "test_comps_import_with_dots_in_pkg_names") sync_conduit = importer_mocks.get_sync_conduit() avail_groups, avail_cats = comps.get_available(repo_src_dir) if type_id == TYPE_ID_PKG_GROUP: groups, group_units = comps.get_new_group_units(avail_groups, {}, sync_conduit, repo) self.assertTrue(len(group_units) > 0) return group_units.values()[0] elif type_id == TYPE_ID_PKG_CATEGORY: cats, cat_units = comps.get_new_category_units(avail_cats, {}, sync_conduit, repo) self.assertTrue(len(cat_units) > 0) return cat_units.values()[0] else: return None
def test_link_errata_rpm_units(self): feed_url = "file://%s/test_errata_local_sync/" % self.data_dir repo = mock.Mock(spec=Repository) repo.working_dir = self.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' : "2007-03-13 00:00:00"} unit_key_a = {'id' : '','name' :'patb', 'version' :'0.1', 'release' : '2', 'epoch':'0', 'arch' : 'noarch', 'checksumtype' : 'sha', 'checksum': '017c12050a97cf6095892498750c2a39d2bf535e'} unit_key_b = {'id' : '', 'name' :'emoticons', 'version' :'0.1', 'release' :'2', 'epoch':'0','arch' : 'noarch', 'checksumtype' :'sha', 'checksum' : '663c89b0d29bfd5479d8736b716d50eed9495dbb'} existing_units = [] for unit in [unit_key_a, unit_key_b]: existing_units.append(Unit(TYPE_ID_RPM, unit, metadata, '')) 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) self.assertEquals(len(details['link_report']['linked_units']), 2)
def test_srpm_sync(self): feed_url = "http://pkilambi.fedorapeople.org/test_srpm_repo/" repo = mock.Mock(spec=Repository) repo.working_dir = self.working_dir repo.id = "test_srpm_sync" 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(status) self.assertTrue(summary is not None) self.assertTrue(details is not None) self.assertEquals(summary["num_rpms"], 3) self.assertEquals(summary["num_synced_new_srpms"], 3) self.assertEquals(summary["num_synced_new_rpms"], 0)
def test_upload_unit_named_PULP_MANIFEST(self, remove): """ We had a bug[0] due to the ISOImporter allowing units to be uploaded named PULP_MANIFEST. This test asserts that that is no longer allowed. [0] https://bugzilla.redhat.com/show_bug.cgi?id=973678 """ # Set up the test file_data = 'This is a PULP_MANIFEST file. The upload should be rejected.\n' working_dir = os.path.join(self.temp_dir, "working") os.mkdir(working_dir) pkg_dir = os.path.join(self.temp_dir, 'content') os.mkdir(pkg_dir) repo = mock.MagicMock(spec=Repository) repo.working_dir = working_dir # We'll set validation off so the checksum doesn't matter unit_key = {'name': 'PULP_MANIFEST', 'size': len(file_data), 'checksum': "Doesn't matter"} metadata = {} temp_file_location = os.path.join(self.temp_dir, unit_key['name']) with open(temp_file_location, 'w') as temp_file: temp_file.write(file_data) sync_conduit = importer_mocks.get_sync_conduit(type_id=ids.TYPE_ID_ISO, pkg_dir=pkg_dir) # Just so we don't have to care about the checksum config = importer_mocks.get_basic_config(**{importer_constants.KEY_VALIDATE: 'false'}) report = self.iso_importer.upload_unit(repo, ids.TYPE_ID_ISO, unit_key, metadata, temp_file_location, sync_conduit, config) self.assertEqual(report['success_flag'], False) self.assertEqual(report['summary'], 'An ISO may not be named PULP_MANIFEST, as it ' 'conflicts with the name of the manifest during publishing.') # init_unit() should have been called expected_rel_path = os.path.join(unit_key['name'], unit_key['checksum'], str(unit_key['size']), unit_key['name']) sync_conduit.init_unit.assert_called_once_with(ids.TYPE_ID_ISO, unit_key, metadata, expected_rel_path) # The file should have been deleted self.assertFalse(os.path.exists(temp_file_location)) would_be_destination = os.path.join(pkg_dir, expected_rel_path) self.assertFalse(os.path.exists(would_be_destination)) # The file should have been removed from there remove.assert_called_once_with(would_be_destination) # The conduit's save_unit method should not have been called self.assertEqual(sync_conduit.save_unit.call_count, 0)
def test_upload_unit_validate_true_bad_checksum(self, remove, validate): """ Test behavior with a bad checksum. """ # Set up the test file_data = 'This is a file.\n' error_message = 'uh oh' validate.side_effect = ValueError(error_message) working_dir = os.path.join(self.temp_dir, "working") os.mkdir(working_dir) pkg_dir = os.path.join(self.temp_dir, 'content') os.mkdir(pkg_dir) repo = mock.MagicMock(spec=Repository) repo.working_dir = working_dir # Set the checksum incorrect. The upload should fail. unit_key = {'name': 'test.iso', 'size': 16, 'checksum': 'Wrong'} metadata = {} temp_file_location = os.path.join(self.temp_dir, 'test.iso') with open(temp_file_location, 'w') as temp_file: temp_file.write(file_data) sync_conduit = importer_mocks.get_sync_conduit(type_id=ids.TYPE_ID_ISO, pkg_dir=pkg_dir) config = importer_mocks.get_basic_config(**{importer_constants.KEY_VALIDATE: 'true'}) # Run the upload. This should fail due to the bad checksum report = self.iso_importer.upload_unit(repo, ids.TYPE_ID_ISO, unit_key, metadata, temp_file_location, sync_conduit, config) self.assertEqual(report['success_flag'], False) self.assertEqual(report['summary'], error_message) # The conduit's init_unit method should have been called expected_rel_path = os.path.join(unit_key['name'], unit_key['checksum'], str(unit_key['size']), unit_key['name']) sync_conduit.init_unit.assert_called_once_with(ids.TYPE_ID_ISO, unit_key, metadata, expected_rel_path) # The file should have been deleted self.assertFalse(os.path.exists(temp_file_location)) would_be_destination = os.path.join(pkg_dir, expected_rel_path) self.assertFalse(os.path.exists(would_be_destination)) # The file should have been removed from there remove.assert_called_once_with(would_be_destination) # validate() should have been called with the full_validation=True flag validate.assert_called_once_with(full_validation=True) # The conduit's save_unit method should not have been called self.assertEqual(sync_conduit.save_unit.call_count, 0)