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.'
)
