def test_publish(self): repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "test_publish" num_units = 10 relative_url = "rel_a/rel_b/rel_c/" existing_units = self.get_units(count=num_units) 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, relative_url=relative_url, http=False, https=True) distributor = YumDistributor() distributor.process_repo_auth_certificate_bundle = mock.Mock() status, msg = distributor.validate_config(repo, config, None) self.assertTrue(status) report = distributor.publish_repo(repo, publish_conduit, config) self.assertTrue(report.success_flag) summary = report.summary self.assertEqual(summary["num_package_units_attempted"], num_units) self.assertEqual(summary["num_package_units_published"], num_units) self.assertEqual(summary["num_package_units_errors"], 0) # Verify we did not attempt to publish to http expected_repo_http_publish_dir = os.path.join(self.http_publish_dir, relative_url) self.assertFalse(os.path.exists(expected_repo_http_publish_dir)) expected_repo_https_publish_dir = os.path.join(self.https_publish_dir, relative_url).rstrip('/') self.assertEqual(summary["https_publish_dir"], expected_repo_https_publish_dir) self.assertTrue(os.path.exists(expected_repo_https_publish_dir)) details = report.details self.assertEqual(len(details["errors"]), 0) # # Add a verification of the publish directory # self.assertTrue(os.path.exists(summary["https_publish_dir"])) self.assertTrue(os.path.islink(summary["https_publish_dir"].rstrip("/"))) source_of_link = os.readlink(expected_repo_https_publish_dir.rstrip("/")) self.assertEquals(source_of_link, repo.working_dir) # # Verify the expected units # for u in existing_units: expected_link = os.path.join(expected_repo_https_publish_dir, u.metadata["relativepath"]) self.assertTrue(os.path.exists(expected_link)) actual_target = os.readlink(expected_link) expected_target = u.storage_path self.assertEqual(actual_target, expected_target) # # Now test flipping so https is disabled and http is enabled # config = distributor_mocks.get_basic_config(https_publish_dir=self.https_publish_dir, http_publish_dir=self.http_publish_dir, relative_url=relative_url, http=True, https=False) report = distributor.publish_repo(repo, publish_conduit, config) self.assertTrue(report.success_flag) # Verify we did publish to http self.assertTrue(os.path.exists(expected_repo_http_publish_dir)) # Verify we did not publish to https self.assertFalse(os.path.exists(expected_repo_https_publish_dir)) # Verify we cleaned up the misc dirs under the https dir self.assertEquals(len(os.listdir(self.https_publish_dir)), 0)
def test_config_relative_path(self): http = True https = False relative_url = 123 config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https) state, msg = self.distributor.validate_config(self.repo, config, self.config_conduit) self.assertFalse(state) relative_url = "test_path" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https) state, msg = self.distributor.validate_config(self.repo, config, self.config_conduit) self.assertTrue(state) # For https://bugzilla.redhat.com/show_bug.cgi?id=874241 we will assert that crazy characters don't validate relative_url = '@#%^&*()' config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https) state, msg = self.distributor.validate_config(self.repo, config, self.config_conduit) self.assertFalse(state) self.assertEqual(msg, 'relative_url must contain only alphanumerics, underscores, and dashes.') # relative_url should be allowed to be empty string relative_url = "" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https) state, msg = self.distributor.validate_config(self.repo, config, self.config_conduit) self.assertTrue(state) # relative_url should be allowed to have a forward slash character relative_url = "/jdob/repos/awesome-repo" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https) state, msg = self.distributor.validate_config(self.repo, config, self.config_conduit) self.assertTrue(state)
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_validate_config_iso_prefix(self): repo = mock.Mock(spec=Repository) repo.id = "testrepo" distributor = ISODistributor() # test invalid iso prefix config = distributor_mocks.get_basic_config(http=True, https=False, iso_prefix="my_iso*_name_/") state, msg = distributor.validate_config(repo, config, []) self.assertFalse(state) # test valid iso prefix config = distributor_mocks.get_basic_config(http=True, https=False, iso_prefix="My_iso_name-01") state, msg = distributor.validate_config(repo, config, []) self.assertTrue(state)
def test_config_protected(self): http = True https = False relative_url = "test_path" protected = "false" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, protected=protected) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertFalse(state) protected = True config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, protected=protected) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertTrue(state)
def test_config_https(self): http = True https = "False" relative_url = "test_path" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertFalse(state) https = True config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertTrue(state)
def test_config_generate_metadata(self): http = True https = False relative_url = "test_path" generate_metadata = "false" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, generate_metadata=generate_metadata) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertFalse(state) generate_metadata = True config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, generate_metadata=generate_metadata) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertTrue(state)
def test_config_skip_content_types(self): http = True https = False relative_url = "test_path" skip_content_types = "fake" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, skip=skip_content_types) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertFalse(state) skip_content_types = [] config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, skip=skip_content_types) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertTrue(state)
def test_config_checksum_type(self): http = True https = False relative_url = "test_path" checksum_type = "fake" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, checksum_type=checksum_type) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertFalse(state) checksum_type = "sha" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, checksum_type=checksum_type) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertTrue(state)
def test_skip_types_export(self): repo = mock.Mock(spec=Repository) repo.id = "testrepo" repo.working_dir = self.repo_working_dir distributor = ISODistributor() config = distributor_mocks.get_basic_config(http=True, https=False, skip=["rpm", "errata", "packagegroup"]) publish_conduit = distributor_mocks.get_publish_conduit(existing_units=[], pkg_dir=self.pkg_dir) report = distributor.publish_repo(repo, publish_conduit, config) print report.summary summary_keys = { "rpm": ["num_package_units_attempted", "num_package_units_exported", "num_package_units_errors"], "distribution": [ "num_distribution_units_attempted", "num_distribution_units_exported", "num_distribution_units_errors", ], "packagegroup": ["num_package_groups_exported", "num_package_categories_exported"], "erratum": ["num_errata_units_exported"], } # check rpm,packagegroup,erratum info is skipped for key in summary_keys["rpm"] + summary_keys["packagegroup"] + summary_keys["erratum"]: self.assertTrue(key not in report.summary) # check distro info is present and not skipped for key in summary_keys["distribution"]: self.assertTrue(key in report.summary)
def test_yum_generate_metadata(self): global metadata_progress_status metadata_progress_status = {} def set_progress(progress): global metadata_progress_status metadata_progress_status = progress def progress_callback(type_id, status): metadata_progress_status[type_id] = status mock_publish_conduit.set_progress(metadata_progress_status) mock_repo = mock.Mock(spec=Repository) mock_repo.id = "test_repo" repo_scratchpad = {"checksum_type" : "sha", "repodata" : {}} mock_repo.working_dir = os.path.join(self.temp_dir, "test_yum_repo_metadata") # Confirm required and optional are successful units_to_write= mock.Mock() units_to_write.metadata = {} units_to_write.metadata["repodata"] = {} units_to_write.metadata["repodata"]["primary"] = """<package type="rpm"><name>feedless</name><arch>noarch</arch><version epoch="0" ver="1.0" rel="1"/><checksum type="sha" pkgid="YES">c1181097439ae4c69793c91febd8513475fb7ed6</checksum><summary>dummy testing pkg</summary><description>A dumb 1Mb pkg.</description><packager/><url/><time file="1299184404" build="1299168170"/><size package="1050973" installed="2097152" archive="1048976"/><location href="feedless-1.0-1.noarch.rpm"/><format><rpm:license>GPLv2</rpm:license><rpm:vendor/><rpm:group>Application</rpm:group><rpm:buildhost>pulp-qe-rhel5.usersys.redhat.com</rpm:buildhost><rpm:sourcerpm>feedless-1.0-1.src.rpm</rpm:sourcerpm><rpm:header-range start="456" end="1846"/><rpm:provides><rpm:entry name="feedless" flags="EQ" epoch="0" ver="1.0" rel="1"/></rpm:provides><rpm:requires><rpm:entry name="rpmlib(CompressedFileNames)" flags="LE" epoch="0" ver="3.0.4" rel="1" pre="1"/><rpm:entry name="rpmlib(PayloadFilesHavePrefix)" flags="LE" epoch="0" ver="4.0" rel="1" pre="1"/></rpm:requires></format></package>""" units_to_write.metadata["repodata"]["filelists"] = """<package pkgid="c1181097439ae4c69793c91febd8513475fb7ed6" name="feedless" arch="noarch"><version epoch="0" ver="1.0" rel="1"/><file>/tmp/rpm_test/feedless/key</file><file type="dir">/tmp/rpm_test/feedless</file></package>""" units_to_write.metadata["repodata"]["other"] = """<package pkgid="c1181097439ae4c69793c91febd8513475fb7ed6" name="feedless" arch="noarch"><version epoch="0" ver="1.0" rel="1"/></package>""" optional_kwargs = {"use_createrepo" : False} config = distributor_mocks.get_basic_config(**optional_kwargs) mock_publish_conduit = distributor_mocks.get_publish_conduit() mock_publish_conduit.set_progress = mock.Mock() mock_publish_conduit.set_progress.side_effect = set_progress status, errors = metadata.generate_yum_metadata(mock_repo.working_dir, mock_publish_conduit, config, progress_callback=progress_callback, repo_scratchpad=repo_scratchpad) self.assertEquals(status, True) self.assertEquals(metadata_progress_status['metadata']['state'], "FINISHED")
def test_cancel_generate_repodata(self): global metadata_progress_status metadata_progress_status = {} def set_progress(progress): global metadata_progress_status metadata_progress_status = progress def progress_callback(type_id, status): metadata_progress_status[type_id] = status mock_publish_conduit.set_progress(metadata_progress_status) mock_repo = mock.Mock(spec=Repository) mock_repo.id = "test_repo" mock_repo.scratchpad = {"checksum_type" : "sha"} mock_repo.working_dir = os.path.join(self.temp_dir, "test_yum_repo_metadata") # Confirm required and optional are successful units_to_write= mock.Mock() units_to_write.metadata = {} units_to_write.metadata["repodata"] = {} repo_scratchpad = {"checksum_type" : "sha", "repodata" : {}} optional_kwargs = {} config = distributor_mocks.get_basic_config(**optional_kwargs) mock_publish_conduit = distributor_mocks.get_publish_conduit() mock_publish_conduit.set_progress = mock.Mock() mock_publish_conduit.set_progress.side_effect = set_progress status, errors = metadata.generate_yum_metadata(mock_repo.working_dir, mock_publish_conduit, config, progress_callback=progress_callback, is_cancelled=True, repo_scratchpad=repo_scratchpad) self.assertEquals(status, False) self.assertEquals(metadata_progress_status['metadata']['state'], "CANCELED")
def test__copy_to_hosted_location(self): """ Test the operation of _copy_to_hosted_location(). """ repo = MagicMock(spec=Repository) repo.id = "lebowski" repo.working_dir = self.temp_dir progress_report = progress.PublishProgressReport(self.publish_conduit) config = distributor_mocks.get_basic_config( **{constants.CONFIG_SERVE_HTTP: True, constants.CONFIG_SERVE_HTTPS: True} ) # Let's put a dummy file and a dummy symlink in the build_dir, so we can make sure they get # copied to the right places. build_dir = publish._get_or_create_build_dir(repo) with open(os.path.join(build_dir, "the_dude.txt"), "w") as the_dude: the_dude.write("Let's go bowling.") os.symlink("/symlink/path", os.path.join(build_dir, "symlink")) # This should copy our dummy file to the monkey patched folders from our setUp() method. publish._copy_to_hosted_location(repo, config, progress_report) # Make sure that the_dude.txt got copied to the right places expected_http_path = os.path.join(constants.ISO_HTTP_DIR, "lebowski", "the_dude.txt") expected_https_path = os.path.join(constants.ISO_HTTPS_DIR, "lebowski", "the_dude.txt") self.assertTrue(os.path.exists(expected_http_path)) self.assertTrue(os.path.exists(expected_https_path)) # Now make sure our symlink is also in place, and points to the correct location expected_http_symlink_path = os.path.join(constants.ISO_HTTP_DIR, "lebowski", "symlink") expected_https_symlink_path = os.path.join(constants.ISO_HTTPS_DIR, "lebowski", "symlink") self.assertTrue(os.path.islink(expected_http_symlink_path)) self.assertTrue(os.path.islink(expected_https_symlink_path)) self.assertEqual(os.path.realpath(expected_http_symlink_path), "/symlink/path") self.assertEqual(os.path.realpath(expected_https_symlink_path), "/symlink/path")
def test_consumer_payload(self): PAYLOAD_FIELDS = [ "server_name", "relative_path", "protocols", "gpg_keys", "client_cert", "ca_cert", "repo_name", ] http = True https = True relative_url = "/pub/content/" gpgkey = ["test_gpg_key"] auth_cert = open(os.path.join(self.data_dir, "cert.crt")).read() auth_ca = open(os.path.join(self.data_dir, "ca.key")).read() config = distributor_mocks.get_basic_config( relative_url=relative_url, http=http, https=https, auth_cert=auth_cert, auth_ca=auth_ca, gpgkey=gpgkey ) distributor = YumDistributor() repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "test_payload" repo.display_name = "Nice Repo" payload = distributor.create_consumer_payload(repo, config) for field in PAYLOAD_FIELDS: print field self.assertTrue(field in payload) self.assertTrue("http" in payload["protocols"]) self.assertTrue("https" in payload["protocols"]) print payload
def test_generate_metadata(self): mock_repo = mock.Mock(spec=Repository) mock_repo.id = "test_repo" mock_repo.scratchpad = {"checksum_type": "sha"} mock_repo.working_dir = os.path.join(self.data_dir, "test_repo_metadata") # Confirm required and optional are successful optional_kwargs = {"generate_metadata": 1} config = distributor_mocks.get_basic_config(**optional_kwargs) mock_publish_conduit = distributor_mocks.get_publish_conduit() status, errors = metadata.generate_metadata(mock_repo, mock_publish_conduit, config) self.assertEquals(status, True) optional_kwargs = {"generate_metadata": 0} config = distributor_mocks.get_basic_config(**optional_kwargs) mock_publish_conduit = distributor_mocks.get_publish_conduit() status, errors = metadata.generate_metadata(mock_repo, mock_publish_conduit, config) self.assertEquals(status, False)
def test_yum_plugin_generate_yum_metadata_checksum_from_conduit_sha1_conversion(self, mock_YumMetadataGenerator, mock_distributor_manager): repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "test_publish" num_units = 10 relative_url = "rel_a/rel_b/rel_c/" existing_units = self.get_units(count=num_units) publish_conduit = distributor_mocks.get_publish_conduit(type_id="rpm", existing_units=existing_units, pkg_dir=self.pkg_dir) publish_conduit.repo_id = 'foo' publish_conduit.distributor_id = TYPE_ID_DISTRIBUTOR_YUM config = distributor_mocks.get_basic_config(https_publish_dir=self.https_publish_dir, relative_url=relative_url, http=False, https=True) distributor = YumDistributor() distributor.process_repo_auth_certificate_bundle = mock.Mock() config_conduit = mock.Mock(spec=RepoConfigConduit) config_conduit.get_repo_distributors_by_relative_url.return_value = MockCursor([]) metadata.generate_yum_metadata(repo.id, repo.working_dir, publish_conduit, config, repo_scratchpad={'checksum_type': 'sha'}) mock_YumMetadataGenerator.assert_called_with(ANY, checksum_type='sha1', skip_metadata_types=ANY, is_cancelled=ANY, group_xml_path=ANY, updateinfo_xml_path=ANY, custom_metadata_dict=ANY) mock_distributor_manager.return_value.update_distributor_config.\ assert_called_with(ANY, ANY, {'checksum_type': 'sha1'})
def test_yum_plugin_generate_yum_metadata_checksum_default(self, mock_YumMetadataGenerator, mock_distributor_manager): repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "test_publish" num_units = 10 relative_url = "rel_a/rel_b/rel_c/" existing_units = self.get_units(count=num_units) publish_conduit = distributor_mocks.get_publish_conduit(type_id="rpm", existing_units=existing_units, checksum_type=None, pkg_dir=self.pkg_dir) config = distributor_mocks.get_basic_config(https_publish_dir=self.https_publish_dir, relative_url=relative_url, http=False, https=True) distributor = YumDistributor() distributor.process_repo_auth_certificate_bundle = mock.Mock() config_conduit = mock.Mock(spec=RepoConfigConduit) config_conduit.get_repo_distributors_by_relative_url.return_value = MockCursor([]) metadata.generate_yum_metadata(repo.id, repo.working_dir, publish_conduit, config) mock_YumMetadataGenerator.assert_called_with(ANY, checksum_type=metadata.DEFAULT_CHECKSUM, skip_metadata_types=ANY, is_cancelled=ANY, group_xml_path=ANY, updateinfo_xml_path=ANY, custom_metadata_dict=ANY) self.assertFalse(mock_distributor_manager.called)
def test_basic_repo_publish_rel_path_conflict(self): repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "test_basic_repo_publish_rel_path_conflict" num_units = 10 relative_url = "rel_a/rel_b/rel_a/" config = distributor_mocks.get_basic_config(https_publish_dir=self.https_publish_dir, relative_url=relative_url, http=False, https=True) url_a = relative_url config_a = PluginCallConfiguration({"relative_url":url_a}, {}) repo_a = RelatedRepository("repo_a_id", [config_a]) config_conduit = mock.Mock(spec=RepoConfigConduit) conduit_return_cursor = MockCursor([{'repo_id': 'repo_a_id', 'config': {'relative_url': "rel_a/rel_b/rel_a/"}}]) config_conduit.get_repo_distributors_by_relative_url.return_value = conduit_return_cursor # Simple check of direct conflict of a duplicate - varieties of duplicates are tested via the conduit tests related_repos = [repo_a] distributor = YumDistributor() distributor.process_repo_auth_certificate_bundle = mock.Mock() status, msg = distributor.validate_config(repo, config, config_conduit) self.assertFalse(status) expected_msg = "Relative url '%s' conflicts with existing relative_url of '%s' from repo '%s'" % \ (relative_url, url_a, repo_a.id) self.assertEqual(expected_msg, msg) # Ensure this test can handle a large number of repos """
def test_distributor_removed(self, delete_protected_repo, mock_factory): """ Make sure the distributor_removed() method cleans up the published files. """ # Create and publish repo to both http and https directories repo = mock.Mock(spec=Repository) repo.id = 'about_to_be_removed' repo.working_dir = self.repo_working_dir existing_units = self.get_units(count=5) publish_conduit = distributor_mocks.get_publish_conduit(type_id="rpm", existing_units=existing_units, pkg_dir=self.pkg_dir) config = distributor_mocks.get_basic_config(http_publish_dir=self.http_publish_dir, https_publish_dir=self.https_publish_dir, http=True, https=True) distributor = YumDistributor() publish_conduit.repo_id = repo.id publish_conduit.distributor_id = 'foo' report = distributor.publish_repo(repo, publish_conduit, config) publishing_paths = [os.path.join(directory, repo.id) \ for directory in [self.http_publish_dir, self.https_publish_dir]] # The publishing paths should exist self.assertTrue(all([os.path.exists(directory) for directory in publishing_paths])) delete_protected_repo.reset_mock() distributor.distributor_removed(repo, config) # Neither publishing path should exist now self.assertFalse(all([os.path.exists(directory) for directory in publishing_paths])) # delete_protected_repo should have been called delete_protected_repo.assert_called_once_with(repo.id)
def test_publish_repo(self): repo = MagicMock(spec=Repository) repo.id = 'lebowski' repo.working_dir = self.temp_dir publish_conduit = distributor_mocks.get_publish_conduit(existing_units=self.existing_units) config = distributor_mocks.get_basic_config(**{constants.CONFIG_SERVE_HTTP: True, constants.CONFIG_SERVE_HTTPS: True}) # We haven't implemented reporting yet, so we don't yet assert anything about the report # here. report = self.iso_distributor.publish_repo(repo, publish_conduit, config) # Let's verify that the publish directory looks right publishing_paths = [os.path.join(directory, 'lebowski') \ for directory in [constants.ISO_HTTP_DIR, constants.ISO_HTTPS_DIR]] for publishing_path in publishing_paths: for unit in self.existing_units: expected_symlink_path = os.path.join(publishing_path, unit.unit_key['name']) self.assertTrue(os.path.islink(expected_symlink_path)) expected_symlink_destination = os.path.join('/', 'path', unit.unit_key['name']) self.assertEqual(os.path.realpath(expected_symlink_path), expected_symlink_destination) # Now let's have a look at the PULP_MANIFEST file to make sure it was generated and # published correctly. manifest_filename = os.path.join(publishing_path, constants.ISO_MANIFEST_FILENAME) manifest_rows = [] with open(manifest_filename) as manifest_file: manifest = csv.reader(manifest_file) for row in manifest: manifest_rows.append(row) expected_manifest_rows = [['test.iso', 'sum1', '1'], ['test2.iso', 'sum2', '2'], ['test3.iso', 'sum3', '3']] self.assertEqual(manifest_rows, expected_manifest_rows)
def test_no_cert(self): """ Assert that certificates are not required. """ config = get_basic_config(**{}) # This should not raise an Exception configuration._validate_ssl_cert(config, constants.CONFIG_SSL_AUTH_CA_CERT)
def test_bool_valid(self): """ If the bool is valid, it should return successfully. """ config = get_basic_config(**{'setting_name': 'false'}) # This should not raise an Exception configuration_utils.validate_non_required_bool(config, 'setting_name')
def test_bool_not_set(self): """ If the bool is not set, it should be cool. """ config = get_basic_config() # This should not raise an Exception, since the setting is not required configuration_utils.validate_non_required_bool(config, 'setting_name')
def test_config_auth_ca(self): if not M2CRYPTO_HAS_CRL_SUPPORT: return http = True https = False relative_url = "test_path" auth_ca = "fake" config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, auth_ca=auth_ca) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertFalse(state) auth_ca = open(os.path.join(self.data_dir, "valid_ca.crt")).read() config = distributor_mocks.get_basic_config(relative_url=relative_url, http=http, https=https, auth_ca=auth_ca) state, msg = self.distributor.validate_config(self.repo, config, []) self.assertTrue(state)
def test_bad_cert(self): """ Assert that a bad cert raises an error. """ config = get_basic_config(**{constants.CONFIG_SSL_AUTH_CA_CERT: 'You cannot be serious.'}) try: configuration._validate_ssl_cert(config, constants.CONFIG_SSL_AUTH_CA_CERT) self.fail('The validator should have raised an Exception, but it did not.') except configuration_utils.ValidationError, e: self.assertEqual(str(e), 'The SSL certificate <ssl_auth_ca_cert> is not a valid certificate.')
def test_validate_passes(self): """ Test that validate() handles a good config correctly. """ config = get_basic_config(**{constants.CONFIG_SERVE_HTTP: True, constants.CONFIG_SERVE_HTTPS: False}) valid, msg = configuration.validate(config) # We passed a valid config, so validate() should have indicated that everything was cool self.assertTrue(valid) self.assertEqual(msg, None)
def test_good_cert(self, validate_cert): """ Assert that a good cert passes the check. """ cert = 'Good Cert (well, once mock is done with it!)' config = get_basic_config(**{constants.CONFIG_SSL_AUTH_CA_CERT: cert}) # This should not raise an Exception configuration._validate_ssl_cert(config, constants.CONFIG_SSL_AUTH_CA_CERT) # Make sure the mock was called validate_cert.assert_called_once_with(cert)
def test_validate_fails(self): """ Test that validate() handles a bad config correctly. """ config = get_basic_config(**{constants.CONFIG_SERVE_HTTP: True, constants.CONFIG_SERVE_HTTPS: False, constants.CONFIG_SSL_AUTH_CA_CERT: 'Invalid cert.'}) valid, msg = configuration.validate(config) # We passed a valid config, so validate() should have indicated that everything was cool self.assertFalse(valid) self.assertEqual(msg, 'The SSL certificate <ssl_auth_ca_cert> is not a valid certificate.')
def test_bool_not_valid(self): """ If the bool is not valid, it should return an error. """ config = get_basic_config(**{'setting_name': 'Not true or false.'}) try: configuration_utils.validate_non_required_bool(config, 'setting_name') self.fail('The validation should have failed, but it did not.') except configuration_utils.ValidationError, e: self.assertEqual(str(e), 'The configuration parameter <setting_name> may only be set to a ' 'boolean value, but is currently set to <Not true or false.>.')
def test_publish_progress(self): global progress_status progress_status = None group_progress_status = None def set_progress(progress): global progress_status progress_status = progress PROGRESS_FIELDS = ["num_success", "num_error", "items_left", "items_total", "error_details"] publish_conduit = distributor_mocks.get_publish_conduit(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) distributor = GroupISODistributor() repo = mock.Mock(spec=Repository) repo.working_dir = self.repo_working_dir repo.id = "test_progress_sync" repo_group = mock.Mock(spec=RepositoryGroup) repo_group.id = "test_group" repo_group.repo_ids = [repo.id,] repo_group.working_dir = self.group_working_dir publish_conduit.set_progress = mock.Mock() publish_conduit.set_progress.side_effect = set_progress distributor.publish_group(repo_group, publish_conduit, config) print distributor.group_progress_status self.assertTrue(progress_status is not None) self.assertEqual(progress_status['group-id'], repo_group.id) self.assertTrue("rpms" in progress_status['repositories'][repo.id]) self.assertTrue(progress_status['repositories'][repo.id]["rpms"].has_key("state")) self.assertEqual(progress_status['repositories'][repo.id]["rpms"]["state"], "FINISHED") for field in PROGRESS_FIELDS: self.assertTrue(field in progress_status['repositories'][repo.id]["rpms"]) self.assertTrue("distribution" in progress_status['repositories'][repo.id]) self.assertTrue(progress_status['repositories'][repo.id]["distribution"].has_key("state")) self.assertEqual(progress_status['repositories'][repo.id]["distribution"]["state"], "FINISHED") for field in PROGRESS_FIELDS: self.assertTrue(field in progress_status['repositories'][repo.id]["distribution"]) self.assertTrue("errata" in progress_status['repositories'][repo.id]) self.assertTrue(progress_status['repositories'][repo.id]["errata"].has_key("state")) self.assertEqual(progress_status['repositories'][repo.id]["errata"]["state"], "FINISHED") self.assertTrue("isos" in progress_status) self.assertTrue(progress_status["isos"].has_key("state")) self.assertEqual(progress_status["isos"]["state"], "FINISHED") ISO_PROGRESS_FIELDS = ["num_success", "num_error", "items_left", "items_total", "error_details", "written_files", "current_file", "size_total", "size_left"] for field in ISO_PROGRESS_FIELDS: self.assertTrue( field in progress_status["isos"]) self.assertTrue("publish_http" in progress_status) self.assertEqual(progress_status["publish_http"]["state"], "FINISHED") self.assertTrue("publish_https" in progress_status) self.assertEqual(progress_status["publish_https"]["state"], "SKIPPED")
def test_bad_cert(self): """ Assert that a bad cert raises an error. """ config = get_basic_config( **{constants.CONFIG_SSL_AUTH_CA_CERT: 'You cannot be serious.'}) try: configuration._validate_ssl_cert(config, constants.CONFIG_SSL_AUTH_CA_CERT) self.fail( 'The validator should have raised an Exception, but it did not.' ) except configuration_utils.ValidationError, e: self.assertEqual( str(e), 'The SSL certificate <ssl_auth_ca_cert> is not a valid certificate.' )
def test_validate_fails(self): """ Test that validate() handles a bad config correctly. """ config = get_basic_config( **{ constants.CONFIG_SERVE_HTTP: True, constants.CONFIG_SERVE_HTTPS: False, constants.CONFIG_SSL_AUTH_CA_CERT: 'Invalid cert.' }) valid, msg = configuration.validate(config) # We passed a valid config, so validate() should have indicated that everything was cool self.assertFalse(valid) self.assertEqual( msg, 'The SSL certificate <ssl_auth_ca_cert> is not a valid certificate.' )