def test_should_not_load_module_after_downloading_when_download_fails(self, install, load):
install.side_effect = MissingPluginException("BOOM")
downloader = DownloadingPluginLoader(Mock())
plugin = downloader.load_plugin(Mock(), "pypi:external_plugin")
self.assertFalse(load.called)
self.assertEquals(plugin, None)
def test_should_load_module_after_downloading_when_download_succeeds(self, _, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
plugin = downloader.load_plugin(project, "pypi:external_plugin")
load.assert_called_with(downloader, project, "pypi:external_plugin")
self.assertEquals(plugin, load.return_value)
def test_should_load_module_after_downloading_with_vcs_when_download_succeeds(self, _, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
plugin = downloader.load_plugin(project, "vcs:external_plugin URL", plugin_module_name="external_plugin_module")
load.assert_called_with("external_plugin_module", "vcs:external_plugin URL")
self.assertEquals(plugin, load.return_value)
def test_should_load_module_after_downloading_with_vcs_when_download_succeeds(self, _, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
plugin = downloader.load_plugin(project, "vcs:external_plugin URL", plugin_module_name="external_plugin_module")
load.assert_called_with("external_plugin_module", "vcs:external_plugin URL")
self.assertEqual(plugin, load.return_value)
def test_should_update_pypi_plugin_with_non_exact_version_before_first_loading_attempt(self, install, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
load.return_value = Mock()
self.assertEquals(load.return_value, downloader.load_plugin(project, "pypi:spam", ">1.2"))
install.assert_called_with(project, "pypi:spam", ">1.2", downloader.logger, None, True, False)
self.assertEquals(install.call_count, 1)
def test_should_force_reinstall_vcs_plugin_before_first_loading_attempt(self, install, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
load.return_value = Mock()
self.assertEquals(load.return_value, downloader.load_plugin(project, "vcs:spam", plugin_module_name="spam"))
install.assert_called_with(project, "vcs:spam", None, downloader.logger, "spam", False, True)
self.assertEquals(install.call_count, 1)
def test_should_import_plugin_when_requiring_plugin_and_plugin_is_found_as_third_party(self, install, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
load.return_value = Mock()
self.assertEquals(load.return_value, downloader.load_plugin(project, "spam"))
install.assert_not_called()
self.assertEquals(install.call_count, 0)
def test_should_update_pypi_plugin_with_non_exact_version_before_first_loading_attempt(self, install, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
load.return_value = Mock()
self.assertEqual(load.return_value, downloader.load_plugin(project, "pypi:spam", ">1.2"))
install.assert_called_with(project, "pypi:spam", ">1.2", downloader.logger, None, True, False)
self.assertEqual(install.call_count, 1)
def test_should_force_reinstall_vcs_plugin_before_first_loading_attempt(self, install, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
load.return_value = Mock()
self.assertEqual(load.return_value, downloader.load_plugin(project, "vcs:spam", plugin_module_name="spam"))
install.assert_called_with(project, "vcs:spam", None, downloader.logger, "spam", False, True)
self.assertEqual(install.call_count, 1)
def test_should_import_plugin_when_requiring_plugin_and_plugin_is_found_as_third_party(self, install, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
load.return_value = Mock()
self.assertEqual(load.return_value, downloader.load_plugin(project, "spam"))
install.assert_not_called()
self.assertEqual(install.call_count, 0)
def test_should_not_update_pypi_plugin_with_exact_version_before_first_loading_attempt(self, install, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
plugin = Mock()
load.side_effect = (MissingPluginException("no spam installed"), plugin)
self.assertEquals(plugin, downloader.load_plugin(project, "pypi:spam", "===1.4"))
install.assert_called_with(project, "pypi:spam", "===1.4", downloader.logger, None)
self.assertEquals(install.call_count, 1)
def test_should_not_update_pypi_plugin_with_exact_version_before_first_loading_attempt(self, install, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
plugin = Mock()
load.side_effect = (MissingPluginException("no spam installed"), plugin)
self.assertEqual(plugin, downloader.load_plugin(project, "pypi:spam", "===1.4"))
install.assert_called_with(project, "pypi:spam", "===1.4", downloader.logger, None)
self.assertEqual(install.call_count, 1)
def test_should_install_upgrade_plugin_with_non_exact_version(self):
logger = Mock()
reactor = Mock()
pyb_env = Mock()
reactor.python_env_registry = {"pybuilder": pyb_env}
reactor.pybuilder_venv = pyb_env
pd = PluginDef("pypi:some-plugin", "~=1.2.3")
downloader = DownloadingPluginLoader(logger)
downloader.install_plugin(reactor, pd)
pyb_env.install_dependencies.assert_called_with([pd.dependency],
package_type="plugin")
def test_should_install_plugin_with_vcs_and_version(self):
logger = Mock()
reactor = Mock()
pyb_env = Mock()
reactor.python_env_registry = {"pybuilder": pyb_env}
reactor.pybuilder_venv = pyb_env
pd = PluginDef("vcs:some-plugin URL", "===1.2.3", "module_name")
downloader = DownloadingPluginLoader(logger)
downloader.install_plugin(reactor, pd)
pyb_env.install_dependencies.assert_called_with([pd.dependency],
package_type="plugin")
def test_should_download_module_from_pypi(self, load):
logger = Mock()
reactor = Mock()
pyb_env = Mock()
reactor.python_env_registry = {"pybuilder": pyb_env}
reactor.pybuilder_venv = pyb_env
pd = PluginDef("pypi:external_plugin")
pl = DownloadingPluginLoader(logger)
pl.install_plugin(reactor, pd)
pyb_env.install_dependencies.assert_called_with(
[Dependency("external_plugin")], package_type="plugin")
def test_should_load_module_after_downloading_with_pypi_when_download_succeeds(
self, load):
logger = Mock()
reactor = Mock()
pyb_env = Mock()
reactor.python_env_registry = {"pybuilder": pyb_env}
reactor.pybuilder_venv = pyb_env
downloader = DownloadingPluginLoader(logger)
pd = PluginDef("pypi:external_plugin")
plugin = downloader.load_plugin(reactor, pd)
load.assert_called_with("external_plugin", pd.name)
self.assertEqual(plugin, load.return_value)
def test_should_import_plugin_when_requiring_plugin_and_plugin_is_found_as_third_party(
self, load):
logger = Mock()
reactor = Mock()
pyb_env = Mock()
reactor.python_env_registry = {"pybuilder": pyb_env}
reactor.pybuilder_venv = pyb_env
load.return_value = Mock()
downloader = DownloadingPluginLoader(logger)
self.assertEqual(load.return_value,
downloader.load_plugin(reactor, PluginDef("spam")))
pyb_env.install_dependencies.assert_not_called()
self.assertEqual(pyb_env.install_dependencies.call_count, 0)
def __init__(self, logger, execution_manager, plugin_loader=None):
self.logger = logger
self.execution_manager = execution_manager
if not plugin_loader:
self.plugin_loader = DispatchingPluginLoader(
self.logger, BuiltinPluginLoader(self.logger),
DownloadingPluginLoader(self.logger))
else:
self.plugin_loader = plugin_loader
self._plugins = []
self._pending_plugin_installs = []
self._plugins_imported = set()
self._deferred_plugins = ModuleTraversalTree()
self._deferred_import = False
self.project = None
self.project_module = None
self._tools = []
python_env_registry = self._python_env_registry = PythonEnvRegistry(
self)
system_pyenv = PythonEnv(sys.exec_prefix, self).populate()
python_env_registry["system"] = system_pyenv
self._sys_path_original = list(sys.path)
def test_should_not_load_module_twice_after_downloading_when_pypi_download_fails(self, install, load):
install.side_effect = MissingPluginException("PyPI Install Boom")
load.side_effect = MissingPluginException("PyPI Load Boom")
downloader = DownloadingPluginLoader(Mock())
self.assertRaises(MissingPluginException, downloader.load_plugin, Mock(), "pypi:external_plugin")
self.assertEqual(load.call_count, 1)
def test_should_not_load_module_twice_after_downloading_when_vcs_download_fails(self, install, load):
install.side_effect = MissingPluginException("VCS Install BOOM")
load.side_effect = MissingPluginException("VCS Load Boom")
downloader = DownloadingPluginLoader(Mock())
self.assertRaises(MissingPluginException, downloader.load_plugin, Mock(), "vcs:external_plugin URL",
plugin_module_name="vcs_module_name")
self.assertEqual(load.call_count, 1)
def test_should_raise_exception_when_requiring_plugin_and_plugin_is_not_found(self, _, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
load.side_effect = MissingPluginException("Load boom")
self.assertRaises(MissingPluginException, downloader.load_plugin, project, "spam")
load.assert_called_with("spam", "spam")
def test_should_fail_with_vcs_when_no_plugin_module_specified(
self, _, load):
project = Mock()
downloader = DownloadingPluginLoader(Mock())
self.assertRaises(UnspecifiedPluginNameException,
downloader.load_plugin, project,
"vcs:external_plugin URL")
def test_should_download_module_from_pypi(self, install, load):
logger = Mock()
project = Mock()
project.get_property.side_effect = lambda x: "index_url" if x == "install_dependencies_index_url" \
else "extra_index_url" if x == "install_dependencies_extra_index_url" else None
load.side_effect = (MissingPluginException("external_plugin"), Mock())
DownloadingPluginLoader(logger).load_plugin(project, "pypi:external_plugin")
install.assert_called_with(project, "pypi:external_plugin", None, logger, None)
def test_should_raise_error_when_protocol_is_invalid(self):
logger = Mock()
reactor = Mock()
pyb_env = Mock()
reactor.python_env_registry = {"pybuilder": pyb_env}
reactor.pybuilder_venv = pyb_env
downloader = DownloadingPluginLoader(logger)
self.assertRaises(MissingPluginException, downloader.install_plugin,
reactor, PluginDef("some-plugin"))
def __init__(self, logger, execution_manager, plugin_loader=None):
self.logger = logger
self.execution_manager = execution_manager
if not plugin_loader:
self.plugin_loader = DispatchingPluginLoader(self.logger,
BuiltinPluginLoader(self.logger),
DownloadingPluginLoader(self.logger))
else:
self.plugin_loader = plugin_loader
self._plugins = []
self.project = None
def __init__(self, logger, execution_manager, plugin_loader=None):
self.logger = logger
self.execution_manager = execution_manager
if not plugin_loader:
builtin_plugin_loader = BuiltinPluginLoader(self.logger)
installed_thirdparty_plugin_loader = ThirdPartyPluginLoader(
self.logger)
downloading_thirdparty_plugin_loader = DownloadingPluginLoader(
self.logger)
self.plugin_loader = DispatchingPluginLoader(
self.logger, builtin_plugin_loader,
installed_thirdparty_plugin_loader,
downloading_thirdparty_plugin_loader)
else:
self.plugin_loader = plugin_loader
self._plugins = []
self.project = None
def test_should_not_load_module_twice_after_downloading_when_pypi_download_fails(
self, load):
logger = Mock()
reactor = Mock()
pyb_env = Mock()
reactor.python_env_registry = {"pybuilder": pyb_env}
reactor.pybuilder_venv = pyb_env
pyb_env.install_dependencies.side_effect = MissingPluginException(
"PyPI Install Boom")
load.side_effect = MissingPluginException("PyPI Load Boom")
downloader = DownloadingPluginLoader(logger)
pd = PluginDef("pypi:external_plugin")
self.assertRaises(MissingPluginException, downloader.load_plugin,
Mock(), pd)
self.assertEqual(load.call_count, 1)
def test_should_download_module_from_pypi(self, install, _):
logger = Mock()
DownloadingPluginLoader(logger).load_plugin(Mock(),
"pypi:external_plugin")
install.assert_called_with("pypi:external_plugin", None, logger)
def test_should_fail_with_vcs_and_no_module_name(self, install, load):
install.side_effect = MissingPluginException("VCS BOOM")
downloader = DownloadingPluginLoader(Mock())
self.assertRaises(UnspecifiedPluginNameException,
downloader.load_plugin, Mock(),
"vcs:external_plugin URL")
