def test__symlink_units_existing_correct_link(self, symlink): """ Make sure that the _symlink_units handles an existing correct link well. """ repo = MagicMock(spec=Repository) repo.working_dir = self.temp_dir progress_report = progress.PublishProgressReport(self.publish_conduit) # There's some logic in _symlink_units to handle preexisting files and symlinks, so let's # create some fakes to see if it does the right thing build_dir = publish._get_or_create_build_dir(repo) unit = self.existing_units[0] expected_symlink_destination = os.path.join("/", "path", unit.unit_key["name"]) os.symlink(expected_symlink_destination, os.path.join(build_dir, unit.unit_key["name"])) # Now let's reset the Mock so that we can make sure it doesn't get called during _symlink symlink.reset_mock() publish._symlink_units(repo, [unit], progress_report) # The call count for symlink should be 0, because the _symlink_units call should have noticed that the # symlink was already correct and thus should have skipped it self.assertEqual(symlink.call_count, 0) expected_symlink_path = os.path.join(build_dir, unit.unit_key["name"]) self.assertTrue(os.path.islink(expected_symlink_path)) self.assertEqual(os.path.realpath(expected_symlink_path), expected_symlink_destination)
def test__symlink_units_os_error(self, readlink): """ Make sure that the _symlink_units handles an OSError correctly, for the case where it doesn't raise EINVAL. We already have a test that raises EINVAL (test__symlink_units places an ordinary file there.) """ os_error = OSError() # This would be an unexpected error for reading a symlink! os_error.errno = errno.ENOSPC readlink.side_effect = os_error repo = MagicMock(spec=Repository) repo.working_dir = self.temp_dir progress_report = progress.PublishProgressReport(self.publish_conduit) # There's some logic in _symlink_units to handle preexisting files and symlinks, so let's # create some fakes to see if it does the right thing build_dir = publish._get_or_create_build_dir(repo) unit = self.existing_units[0] expected_symlink_destination = os.path.join("/", "path", unit.unit_key["name"]) os.symlink(expected_symlink_destination, os.path.join(build_dir, unit.unit_key["name"])) try: publish._symlink_units(repo, [unit], progress_report) self.fail("An OSError should have been raised, but was not!") except OSError, e: self.assertEqual(e.errno, errno.ENOSPC)
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__get_or_create_build_dir_oserror(self, makedirs): """ Let's raise the OSError that this method tries to catch to make sure we raise it appropriately. """ os_error = OSError() os_error.errno = errno.ENOSPC makedirs.side_effect = os_error repo = MagicMock(spec=Repository) repo.working_dir = self.temp_dir # Assert that the build dir does not exist expected_build_dir = os.path.join(self.temp_dir, publish.BUILD_DIRNAME) self.assertFalse(os.path.exists(expected_build_dir)) try: publish._get_or_create_build_dir(repo) self.fail("An OSError should have been raised but was not.") except OSError, e: self.assertEqual(e.errno, errno.ENOSPC)
def test__get_or_create_build_dir(self): """ _get_or_create_build_dir() should create the directory the first time it is called, and should return the path to it both times it is called. """ repo = MagicMock(spec=Repository) repo.working_dir = self.temp_dir # Assert that the build dir does not exist expected_build_dir = os.path.join(self.temp_dir, publish.BUILD_DIRNAME) self.assertFalse(os.path.exists(expected_build_dir)) build_dir = publish._get_or_create_build_dir(repo) # Assert that the build dir is correct and has been created self.assertEqual(build_dir, expected_build_dir) self.assertTrue(os.path.exists(build_dir)) # It should not blow up if we call it again build_dir = publish._get_or_create_build_dir(repo) self.assertEqual(build_dir, expected_build_dir)
def test__symlink_units(self): """ Make sure that the _symlink_units creates all the correct symlinks. """ repo = MagicMock(spec=Repository) repo.working_dir = self.temp_dir progress_report = progress.PublishProgressReport(self.publish_conduit) # There's some logic in _symlink_units to handle preexisting files and symlinks, so let's # create some fakes to see if it does the right thing build_dir = publish._get_or_create_build_dir(repo) os.symlink("/some/weird/path", os.path.join(build_dir, self.existing_units[0].unit_key["name"])) with open(os.path.join(build_dir, self.existing_units[1].unit_key["name"]), "w") as wrong: wrong.write("This is wrong.") publish._symlink_units(repo, self.existing_units, progress_report) build_dir = publish._get_or_create_build_dir(repo) for unit in self.existing_units: expected_symlink_path = os.path.join(build_dir, 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)
def test__get_or_create_build_dir_already_exists(self): """ _get_or_create_build_dir() should correctly handle the situation when the build_dir already exists. """ repo = MagicMock(spec=Repository) repo.working_dir = self.temp_dir # Assert that the build dir does not exist expected_build_dir = os.path.join(self.temp_dir, publish.BUILD_DIRNAME) os.makedirs(expected_build_dir) self.assertTrue(os.path.exists(expected_build_dir)) build_dir = publish._get_or_create_build_dir(repo) # Assert that the build dir is correct and has been created self.assertEqual(build_dir, expected_build_dir) self.assertTrue(os.path.exists(build_dir))