class InstallRuntimeDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project("unittest", ".")
self.project.set_property("dir_install_logs", "any_directory")
self.logger = mock(Logger)
when(pybuilder.plugins.python.install_dependencies_plugin
).execute_command(any_value(), any_value(),
shell=True).thenReturn(0)
def tearDown(self):
unstub()
def test_should_install_multiple_dependencies(self):
self.project.depends_on("spam")
self.project.depends_on("eggs")
self.project.depends_on_requirements("requirements.txt")
install_runtime_dependencies(self.logger, self.project)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command("pip install 'spam'", any_value(), shell=True)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command("pip install 'eggs'", any_value(), shell=True)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command("pip install '-rrequirements.txt'",
any_value(),
shell=True)
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project("unittest", ".")
self.project.set_property("dir_install_logs", "any_directory")
self.logger = mock(Logger)
when(
pybuilder.plugins.python.install_dependencies_plugin).execute_command(any_value(), any_value(),
shell=True).thenReturn(0)
def tearDown(self):
unstub()
def test_should_install_single_dependency_without_version(self):
self.project.depends_on("spam")
self.project.build_depends_on("eggs")
install_dependencies(self.logger, self.project)
verify(
pybuilder.plugins.python.install_dependencies_plugin).execute_command("pip install 'spam'",
any_value(), shell=True)
verify(
pybuilder.plugins.python.install_dependencies_plugin).execute_command("pip install 'eggs'",
any_value(), shell=True)
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project("unittest", ".")
self.project.set_property("dir_install_logs", "any_directory")
self.logger = mock(Logger)
initialize_install_dependencies_plugin(self.project)
when(pybuilder.plugins.python.install_dependencies_plugin
).execute_command(any_value(),
any_value(),
env=any_value(),
shell=False).thenReturn(0)
def tearDown(self):
unstub()
def test_should_install_single_dependency_without_version(self):
self.project.depends_on("spam")
self.project.build_depends_on("eggs")
install_dependencies(self.logger, self.project)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command([PIP_EXECUTABLE, "install", 'spam'],
any_value(),
shell=False)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command([PIP_EXECUTABLE, "install", 'eggs'],
any_value(),
shell=False)
def create_project():
project = Project("/")
project.build_depends_on("testingframework")
project.depends_on("sometool")
project.depends_on(
"pyassert",
url=
"https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz")
project.name = "Spam and Eggs"
project.version = "1.2.3"
project.summary = "This is a simple integration-test for distutils plugin."
project.description = "As you might have guessed we have nothing to say here."
project.authors = [
Author("Udo Juettner", "*****@*****.**"),
Author("Michael Gruber", "*****@*****.**")
]
project.license = "WTFPL"
project.url = "http://github.com/pybuilder/pybuilder"
project.explicit_namespaces = ["foo.bar", "quick.brown.fox"]
def return_dummy_list():
return ["spam", "eggs"]
project.list_scripts = return_dummy_list
project.list_packages = return_dummy_list
project.list_modules = return_dummy_list
project.set_property(
"distutils_classifiers",
["Development Status :: 5 - Beta", "Environment :: Console"])
project.install_file("dir", "file1")
project.install_file("dir", "file2")
project.include_file("spam", "eggs")
return project
def create_project():
project = Project("/")
project.build_depends_on("testingframework")
project.depends_on("sometool")
project.depends_on(
"pyassert", url="https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz")
project.name = "Spam and Eggs"
project.version = "1.2.3"
project.summary = "This is a simple integration-test for distutils plugin."
project.description = "As you might have guessed we have nothing to say here."
project.authors = [
Author("Udo Juettner", "*****@*****.**"), Author("Michael Gruber", "*****@*****.**")]
project.license = "WTFPL"
project.url = "http://github.com/pybuilder/pybuilder"
def return_dummy_list():
return ["spam", "eggs"]
project.list_scripts = return_dummy_list
project.list_packages = return_dummy_list
project.list_modules = return_dummy_list
project.set_property("distutils_classifiers", [
"Development Status :: 5 - Beta", "Environment :: Console"])
project.install_file("dir", "file1")
project.install_file("dir", "file2")
project.include_file("spam", "eggs")
return project
def set_properties(project: Project):
# Dependencies
project.depends_on("gevent")
project.build_depends_on("wsaccel")
project.build_depends_on("ujson")
project.build_depends_on("websocket-client", "~=0.0")
project.build_depends_on("gunicorn")
# Cram Configuration
project.set_property("cram_fail_if_no_tests", False)
# Disable flake8
project.set_property("flake8_break_build", False)
# Integration Tests Coverage is disabled since there are no integration tests
project.set_property("unittest_coverage_threshold_warn", 0)
project.set_property("unittest_coverage_branch_threshold_warn", 0)
project.set_property("unittest_coverage_branch_partial_threshold_warn", 0)
project.set_property("unittest_coverage_allow_non_imported_modules", True)
project.set_property("integrationtest_coverage_threshold_warn", 0)
project.set_property("integrationtest_coverage_branch_threshold_warn", 0)
project.set_property(
"integrationtest_coverage_branch_partial_threshold_warn", 0)
project.set_property("integrationtest_coverage_allow_non_imported_modules",
True)
project.set_property("pybuilder_header_plugin_break_build", False)
project.set_property("copy_resources_target", "$dir_dist")
project.get_property("copy_resources_glob").append("LICENSE")
project.get_property("filter_resources_glob").append(
"**/geventwebsocket/__init__.py")
# Distutils
project.set_property(
"distutils_classifiers",
project.get_property("distutils_classifiers") + [
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Topic :: Software Development :: Libraries',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Internet',
])
project.set_property("pdoc_module_name", "geventwebsocket")
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project("unittest", ".")
self.project.set_property("dir_install_logs", "any_directory")
self.logger = Mock(Logger)
initialize_install_dependencies_plugin(self.project)
@patch("pybuilder.plugins.python.install_dependencies_plugin.execute_command", return_value=0)
def test_should_install_single_dependency_without_version(self, exec_command, get_package_version):
self.project.depends_on("spam")
self.project.build_depends_on("eggs")
install_dependencies(self.logger, self.project)
exec_command(PIP_EXEC_STANZA + ["install", 'spam'], ANY, shell=False)
exec_command(PIP_EXEC_STANZA + ["install", 'eggs'], ANY, shell=False)
def set_properties(project: Project):
# Dependencies
project.depends_on("kombu", "4.0.2")
project.build_depends_on("sqlalchemy")
project.build_depends_on("django")
project.build_depends_on("karellen-sqlite", "~=0.0.0")
project.build_depends_on("unittest2")
# Cram Configuration
project.set_property("cram_fail_if_no_tests", False)
# Disable flake8
project.set_property("flake8_break_build", False)
# Integration Tests Coverage is disabled since there are no integration tests
project.set_property("unittest_coverage_threshold_warn", 0)
project.set_property("unittest_coverage_branch_threshold_warn", 0)
project.set_property("unittest_coverage_branch_partial_threshold_warn", 0)
project.set_property("unittest_coverage_allow_non_imported_modules", True)
project.set_property("integrationtest_coverage_threshold_warn", 0)
project.set_property("integrationtest_coverage_branch_threshold_warn", 0)
project.set_property(
"integrationtest_coverage_branch_partial_threshold_warn", 0)
project.set_property("integrationtest_coverage_allow_non_imported_modules",
True)
project.set_property("pybuilder_header_plugin_break_build", False)
project.set_property("copy_resources_target", "$dir_dist/karellen")
project.get_property("copy_resources_glob").append("LICENSE.bsd3")
project.get_property("copy_resources_glob").append("LICENSE.apache")
project.include_file("karellen", "LICENSE.bsd3")
project.include_file("karellen", "LICENSE.apache")
# Distutils
project.set_property(
"distutils_classifiers",
project.get_property("distutils_classifiers") + [
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Topic :: Software Development :: Libraries',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Internet',
])
project.set_property("pdoc_module_name", "karellen.kombu")
class DependencyLinksTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_return_empty_string_when_no_link_dependency_is_given(self):
self.assertEqual("", build_dependency_links_string(self.project))
def test_should_return_dependency_link(self):
self.project.depends_on("pyassert", url="https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz")
self.assertEqual(
'dependency_links = [ "https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz" ],',
build_dependency_links_string(self.project),
)
def test_should_return_dependency_links(self):
self.project.depends_on(
"pyassert1", url="https://github.com/downloads/halimath/pyassert/pyassert1-0.2.2.tar.gz"
)
self.project.depends_on(
"pyassert2", url="https://github.com/downloads/halimath/pyassert/pyassert2-0.2.2.tar.gz"
)
self.assertEqual(
'dependency_links = [ "https://github.com/downloads/halimath/pyassert/pyassert1-0.2.2.tar.gz",'
' "https://github.com/downloads/halimath/pyassert/pyassert2-0.2.2.tar.gz" ],',
build_dependency_links_string(self.project),
)
class InstallRuntimeDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project("unittest", ".")
self.project.set_property("dir_install_logs", "any_directory")
self.logger = Mock(Logger)
initialize_install_dependencies_plugin(self.project)
@patch("pybuilder.plugins.python.install_dependencies_plugin.execute_command", return_value=0)
def test_should_install_multiple_dependencies(self, exec_command, get_package_version):
self.project.depends_on("spam")
self.project.depends_on("eggs")
self.project.depends_on_requirements("requirements.txt")
install_runtime_dependencies(self.logger, self.project)
exec_command(PIP_EXEC_STANZA + ["install", 'spam'], ANY, shell=False)
exec_command(PIP_EXEC_STANZA + ["install", 'eggs'], ANY, shell=False)
exec_command(PIP_EXEC_STANZA + ["install", '-r', 'requirements.txt'], ANY, shell=False)
@patch("pybuilder.plugins.python.install_dependencies_plugin.execute_command", return_value=0)
def test_should_install_multiple_dependencies_locally(self, exec_command, get_package_version):
self.project.depends_on("spam")
self.project.depends_on("eggs")
self.project.depends_on("foo")
self.project.set_property("install_dependencies_local_mapping", {
"spam": "any-dir",
"eggs": "any-other-dir"
})
install_runtime_dependencies(self.logger, self.project)
exec_command(PIP_EXEC_STANZA + ["install", "-t", "any-dir", 'spam'], ANY, shell=False)
exec_command(PIP_EXEC_STANZA + ["install", "-t", "any-other-dir", 'eggs'], ANY, shell=False)
exec_command(PIP_EXEC_STANZA + ["install", 'foo'], ANY, shell=False)
class InstallRuntimeDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project("unittest", ".")
self.project.set_property("dir_install_logs", "any_directory")
self.logger = mock(Logger)
initialize_install_dependencies_plugin(self.project)
when(pybuilder.plugins.python.install_dependencies_plugin
).execute_command(any_value(), any_value(),
shell=False).thenReturn(0)
def tearDown(self):
unstub()
def test_should_install_multiple_dependencies(self):
self.project.depends_on("spam")
self.project.depends_on("eggs")
self.project.depends_on_requirements("requirements.txt")
install_runtime_dependencies(self.logger, self.project)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command([PIP_EXECUTABLE, "install", 'spam'],
any_value(),
shell=False)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command([PIP_EXECUTABLE, "install", 'eggs'],
any_value(),
shell=False)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command(
[PIP_EXECUTABLE, "install", '-r', 'requirements.txt'],
any_value(),
shell=False)
def test_should_install_multiple_dependencies_locally(self):
self.project.depends_on("spam")
self.project.depends_on("eggs")
self.project.depends_on("foo")
self.project.set_property("install_dependencies_local_mapping", {
"spam": "any-dir",
"eggs": "any-other-dir"
})
install_runtime_dependencies(self.logger, self.project)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command(
[PIP_EXECUTABLE, "install", "-t", "any-dir", 'spam'],
any_value(),
shell=False)
verify(
pybuilder.plugins.python.install_dependencies_plugin
).execute_command(
[PIP_EXECUTABLE, "install", "-t", "any-other-dir", 'eggs'],
any_value(),
shell=False)
verify(pybuilder.plugins.python.install_dependencies_plugin
).execute_command([PIP_EXECUTABLE, "install", 'foo'],
any_value(),
shell=False)
class DependencyLinksTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_return_empty_string_when_no_link_dependency_is_given(self):
self.assertEqual("", build_dependency_links_string(self.project))
def test_should_return_dependency_link(self):
self.project.depends_on(
"pyassert",
url=
"https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz"
)
self.assertEqual(
'dependency_links = [ "https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz" ],',
build_dependency_links_string(self.project))
def test_should_return_dependency_links(self):
self.project.depends_on(
"pyassert1",
url=
"https://github.com/downloads/halimath/pyassert/pyassert1-0.2.2.tar.gz"
)
self.project.depends_on(
"pyassert2",
url=
"https://github.com/downloads/halimath/pyassert/pyassert2-0.2.2.tar.gz"
)
self.assertEqual(
'dependency_links = [ "https://github.com/downloads/halimath/pyassert/pyassert1-0.2.2.tar.gz",'
' "https://github.com/downloads/halimath/pyassert/pyassert2-0.2.2.tar.gz" ],',
build_dependency_links_string(self.project))
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project("unittest", ".")
self.project.set_property("install_env", "whatever")
self.project.set_property("dir_install_logs", "any_directory")
self.project.set_property("dir_target", "/any_target_directory")
self.logger = Mock(Logger)
self.reactor = Mock()
self.pyb_env = Mock()
self.pyb_env.executable = ["a/b"]
self.pyb_env.env_dir = "a"
self.pyb_env.execute_command.return_value = 0
self.reactor.python_env_registry = {"whatever": self.pyb_env}
initialize_install_dependencies_plugin(self.project)
@patch("pybuilder.install_utils.tail_log")
@patch("pybuilder.install_utils.open")
@patch("pybuilder.install_utils.create_constraint_file")
@patch("pybuilder.install_utils.get_packages_info", return_value={})
def test_should_install_single_dependency_without_version(self, *_):
self.project.depends_on("spam")
self.project.build_depends_on("eggs")
install_dependencies(self.logger, self.project, self.reactor)
exec_cmd = self.pyb_env.execute_command
call_stanza = self.pyb_env.executable + PIP_MODULE_STANZA + [
"install", "-c", ANY
]
exec_cmd.assert_called_with(call_stanza + ["eggs", "spam"],
outfile_name=ANY,
error_file_name=ANY,
env=ANY,
cwd=None,
shell=False,
no_path_search=True)
def set_properties(project: Project):
project.depends_on("pybuilder")
project.set_property('flake8_break_build', True)
project.set_property('flake8_include_test_sources', True)
project.set_property('flake8_include_scripts', True)
project.set_property('flake8_max_line_length', 130)
project.set_property("copy_resources_target", "$dir_dist/pybuilder-pipenv")
project.get_property("copy_resources_glob").append("LICENSE")
project.include_file("pybuilder-pipenv", "LICENSE")
project.set_property("distutils_classifiers", [
'Programming Language :: Python',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Development Status :: 4 - Beta', 'Intended Audience :: Developers',
'License :: OSI Approved :: GNU General Public License (GPL)',
'Topic :: Software Development :: Build Tools'
])
class InstallRuntimeDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project("unittest", ".")
self.project.set_property("dir_install_logs", "any_directory")
self.logger = mock(Logger)
when(pybuilder.plugins.python.install_dependencies_plugin).execute_command(
any_value(), any_value(), shell=True
).thenReturn(0)
def tearDown(self):
unstub()
def test_should_install_multiple_dependencies(self):
self.project.depends_on("spam")
self.project.depends_on("eggs")
self.project.depends_on_requirements("requirements.txt")
install_runtime_dependencies(self.logger, self.project)
verify(pybuilder.plugins.python.install_dependencies_plugin).execute_command(
"pip install 'spam'", any_value(), shell=True
)
verify(pybuilder.plugins.python.install_dependencies_plugin).execute_command(
"pip install 'eggs'", any_value(), shell=True
)
verify(pybuilder.plugins.python.install_dependencies_plugin).execute_command(
"pip install '-rrequirements.txt'", any_value(), shell=True
)
def test_should_install_multiple_dependencies_locally(self):
self.project.depends_on("spam")
self.project.depends_on("eggs")
self.project.depends_on("foo")
self.project.set_property("install_dependencies_local_mapping", {"spam": "any-dir", "eggs": "any-other-dir"})
install_runtime_dependencies(self.logger, self.project)
verify(pybuilder.plugins.python.install_dependencies_plugin).execute_command(
"pip install -t any-dir 'spam'", any_value(), shell=True
)
verify(pybuilder.plugins.python.install_dependencies_plugin).execute_command(
"pip install -t any-other-dir 'eggs'", any_value(), shell=True
)
verify(pybuilder.plugins.python.install_dependencies_plugin).execute_command(
"pip install 'foo'", any_value(), shell=True
)
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_leave_user_specified_properties_when_initializing_plugin(
self):
expected_properties = {
"distutils_commands": ["foo", "bar"],
"distutils_issue8876_workaround_enabled":
True,
"distutils_classifiers":
["Development Status :: 3 - Beta", "Programming Language :: Rust"],
"distutils_use_setuptools":
False
}
for property_name, property_value in expected_properties.items():
self.project.set_property(property_name, property_value)
initialize_distutils_plugin(self.project)
for property_name, property_value in expected_properties.items():
self.assertEqual(self.project.get_property("distutils_commands"),
["foo", "bar"])
self.assertEqual(
self.project.get_property(
"distutils_issue8876_workaround_enabled"), True)
self.assertEqual(
self.project.get_property("distutils_classifiers"), [
"Development Status :: 3 - Beta",
"Programming Language :: Rust"
])
self.assertEqual(
self.project.get_property("distutils_use_setuptools"), False)
def test_should_return_empty_string_when_no_dependency_is_given(self):
self.assertEqual("[]", build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string(self):
self.project.depends_on("spam")
self.assertEqual("['spam']",
build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string_with_version(self):
self.project.depends_on("spam", "0.7")
self.assertEqual("['spam>=0.7']",
build_install_dependencies_string(self.project))
def test_should_return_multiple_dependencies_string_with_versions(self):
self.project.depends_on("spam", "0.7")
self.project.depends_on("eggs")
self.assertEqual(
"[\n 'eggs',\n 'spam>=0.7'\n ]",
build_install_dependencies_string(self.project))
def test_should_not_insert_url_dependency_into_install_requires(self):
self.project.depends_on("spam")
self.project.depends_on(
"pyassert",
url=
"https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz"
)
self.assertEqual("['spam']",
build_install_dependencies_string(self.project))
def test_should_not_insert_default_version_operator_when_project_contains_operator_in_version(
self):
self.project.depends_on("spam", "==0.7")
self.assertEqual("['spam==0.7']",
build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_quote_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["foo", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual("[\n 'foo',\n 'bar'\n ]",
build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_empty_requirement_lines(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["", "foo", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual("[\n 'foo',\n 'bar'\n ]",
build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_comments_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["#comment", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual("['bar']",
build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_comments_with_leading_space_from_requirements(
self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [" # comment", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual("['bar']",
build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_editable_urls_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"foo",
"-e git+https://github.com/someuser/someproject.git#egg=some_package"
]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual("['foo']",
build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_expanded_editable_urls_from_requirements(
self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"foo",
"--editable git+https://github.com/someuser/someproject.git#egg=some_package"
]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual("['foo']",
build_install_dependencies_string(self.project))
class DependencyLinksTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_return_empty_string_when_no_link_dependency_is_given(self):
self.assertEqual("[]", build_dependency_links_string(self.project))
def test_should_return_dependency_link(self):
self.project.depends_on(
"pyassert",
url=
"https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz"
)
self.assertEqual(
"['https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz']",
build_dependency_links_string(self.project))
def test_should_return_dependency_links(self):
self.project.depends_on(
"pyassert1",
url=
"https://github.com/downloads/halimath/pyassert/pyassert1-0.2.2.tar.gz"
)
self.project.depends_on(
"pyassert2",
url=
"https://github.com/downloads/halimath/pyassert/pyassert2-0.2.2.tar.gz"
)
self.assertEqual(
"[\n 'https://github.com/downloads/halimath/pyassert/pyassert1-0.2.2.tar.gz',\n"
" 'https://github.com/downloads/halimath/pyassert/pyassert2-0.2.2.tar.gz'\n"
" ]", build_dependency_links_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_use_editable_urls_from_requirements_as_dependency_links(
self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"-e git+https://github.com/someuser/someproject.git#egg=some_package",
"-e svn+https://github.com/someuser/someproject#egg=some_package"
]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"[\n 'git+https://github.com/someuser/someproject.git#egg=some_package',\n"
" 'svn+https://github.com/someuser/someproject#egg=some_package'\n"
" ]", build_dependency_links_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_use_expanded_editable_urls_from_requirements_as_dependency_links(
self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"--editable git+https://github.com/someuser/someproject.git#egg=some_package",
"--editable svn+https://github.com/someuser/someproject#egg=some_package"
]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"[\n 'git+https://github.com/someuser/someproject.git#egg=some_package',\n"
" 'svn+https://github.com/someuser/someproject#egg=some_package'\n"
" ]", build_dependency_links_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_use_editable_urls_from_requirements_combined_with_url_dependencies(
self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"-e svn+https://github.com/someuser/someproject#egg=some_package"
]
self.project.depends_on("jedi",
url="git+https://github.com/davidhalter/jedi")
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"[\n 'git+https://github.com/davidhalter/jedi',\n"
" 'svn+https://github.com/someuser/someproject#egg=some_package'\n"
" ]", build_dependency_links_string(self.project))
class InstallRuntimeDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project("unittest", ".")
self.project.set_property("install_env", "whatever")
self.project.set_property("dir_install_logs", "any_directory")
self.project.set_property("dir_target", "/any_target_directory")
self.logger = Mock(Logger)
self.reactor = Mock()
self.pyb_env = Mock()
self.pyb_env.executable = ["a/b"]
self.pyb_env.env_dir = "a"
self.pyb_env.execute_command.return_value = 0
self.reactor.python_env_registry = {"whatever": self.pyb_env}
initialize_install_dependencies_plugin(self.project)
@patch("pybuilder.install_utils.tail_log")
@patch("pybuilder.install_utils.open")
@patch("pybuilder.install_utils.create_constraint_file")
@patch("pybuilder.install_utils.get_packages_info", return_value={})
def test_should_install_multiple_dependencies(self, *_):
self.project.depends_on("spam")
self.project.depends_on("eggs")
self.project.depends_on_requirements("requirements.txt")
install_runtime_dependencies(self.logger, self.project, self.reactor)
exec_cmd = self.pyb_env.execute_command
call_stanza = self.pyb_env.executable + PIP_MODULE_STANZA + [
"install", "-c", ANY
]
exec_cmd.assert_called_with(call_stanza +
["eggs", "spam", "-r", "requirements.txt"],
outfile_name=ANY,
error_file_name=ANY,
env=ANY,
cwd=None,
shell=False,
no_path_search=True)
@patch("pybuilder.install_utils.tail_log")
@patch("pybuilder.install_utils.open")
@patch("pybuilder.install_utils.create_constraint_file")
@patch("pybuilder.install_utils.get_packages_info", return_value={})
def test_should_install_multiple_dependencies_locally(self, *_):
self.project.depends_on("spam")
self.project.depends_on("eggs")
self.project.depends_on("foo")
self.project.set_property("install_dependencies_local_mapping", {
"spam": "any-dir",
"eggs": "any-other-dir"
})
install_runtime_dependencies(self.logger, self.project, self.reactor)
exec_cmd = self.pyb_env.execute_command
call_stanza = self.pyb_env.executable + PIP_MODULE_STANZA + [
"install", "-c", ANY
]
exec_cmd.assert_has_calls([
call(call_stanza + ["-t", "any-other-dir", "eggs"],
outfile_name=ANY,
error_file_name=ANY,
env=ANY,
cwd=None,
shell=False,
no_path_search=True),
call(call_stanza + ["-t", "any-dir", "spam"],
outfile_name=ANY,
error_file_name=ANY,
env=ANY,
cwd=None,
shell=False,
no_path_search=True),
call(call_stanza + ["foo"],
outfile_name=ANY,
error_file_name=ANY,
env=ANY,
cwd=None,
shell=False,
no_path_search=True)
],
any_order=True)
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_leave_user_specified_properties_when_initializing_plugin(self):
expected_properties = {
"distutils_commands": ["foo", "bar"],
"distutils_issue8876_workaround_enabled": True,
"distutils_classifiers": [
"Development Status :: 3 - Beta",
"Programming Language :: Rust"
],
"distutils_use_setuptools": False
}
for property_name, property_value in expected_properties.items():
self.project.set_property(property_name, property_value)
initialize_distutils_plugin(self.project)
for property_name, property_value in expected_properties.items():
self.assertEquals(
self.project.get_property("distutils_commands"), ["foo", "bar"])
self.assertEquals(
self.project.get_property("distutils_issue8876_workaround_enabled"), True)
self.assertEquals(
self.project.get_property("distutils_classifiers"), ["Development Status :: 3 - Beta",
"Programming Language :: Rust"])
self.assertEquals(
self.project.get_property("distutils_use_setuptools"), False)
def test_should_return_empty_string_when_no_dependency_is_given(self):
self.assertEqual("[]", build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string(self):
self.project.depends_on("spam")
self.assertEqual(
"['spam']", build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string_with_version(self):
self.project.depends_on("spam", "0.7")
self.assertEqual(
"['spam>=0.7']", build_install_dependencies_string(self.project))
def test_should_return_multiple_dependencies_string_with_versions(self):
self.project.depends_on("spam", "0.7")
self.project.depends_on("eggs")
self.assertEqual(
"[\n 'eggs',\n 'spam>=0.7'\n ]",
build_install_dependencies_string(self.project))
def test_should_not_insert_url_dependency_into_install_requires(self):
self.project.depends_on("spam")
self.project.depends_on(
"pyassert", url="https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz")
self.assertEqual(
"['spam']", build_install_dependencies_string(self.project))
def test_should_not_insert_default_version_operator_when_project_contains_operator_in_version(self):
self.project.depends_on("spam", "==0.7")
self.assertEqual(
"['spam==0.7']", build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_quote_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["foo", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"[\n 'foo',\n 'bar'\n ]", build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_empty_requirement_lines(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["", "foo", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"[\n 'foo',\n 'bar'\n ]", build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_comments_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["#comment", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"['bar']", build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_comments_with_leading_space_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [" # comment", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"['bar']", build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_editable_urls_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"foo", "-e git+https://github.com/someuser/someproject.git#egg=some_package"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"['foo']", build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_expanded_editable_urls_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"foo", "--editable git+https://github.com/someuser/someproject.git#egg=some_package"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"['foo']", build_install_dependencies_string(self.project))
class TestPrepareDependenciesDir(TestCase):
"""Testcases for prepare_dependencies_dir()"""
def setUp(self):
self.patch_popen = mock.patch("pybuilder_aws_plugin.lambda_tasks.subprocess.Popen")
self.mock_popen = self.patch_popen.start()
self.mock_process = mock.Mock()
self.mock_process.returncode = 0
self.mock_popen.return_value = self.mock_process
self.input_project = Project(".")
self.mock_logger = mock.Mock()
def tearDown(self):
self.patch_popen.stop()
def test_prepare_dependencies_no_excludes(self):
"""Test prepare_dependencies_dir() w/o excludes."""
for dependency in ["a", "b", "c"]:
self.input_project.depends_on(dependency)
prepare_dependencies_dir(self.mock_logger, self.input_project, "targetdir")
self.assertEqual(
list(self.mock_popen.call_args_list),
[
mock.call(["pip", "install", "--target", "targetdir", "a"], stdout=subprocess.PIPE),
mock.call(["pip", "install", "--target", "targetdir", "b"], stdout=subprocess.PIPE),
mock.call(["pip", "install", "--target", "targetdir", "c"], stdout=subprocess.PIPE),
],
)
self.assertEqual(self.mock_popen.return_value.communicate.call_count, 3)
self.assertNotEqual(self.mock_popen.return_value.communicate.call_count, 1)
def test_prepare_dependencies_with_excludes(self):
"""Test prepare_dependencies_dir() w/ excludes."""
for dependency in ["a", "b", "c", "d", "e"]:
self.input_project.depends_on(dependency)
prepare_dependencies_dir(self.mock_logger, self.input_project, "targetdir", excludes=["b", "e", "a"])
self.assertEqual(
list(self.mock_popen.call_args_list),
[
mock.call(["pip", "install", "--target", "targetdir", "c"], stdout=subprocess.PIPE),
mock.call(["pip", "install", "--target", "targetdir", "d"], stdout=subprocess.PIPE),
],
)
self.assertEqual(self.mock_popen.return_value.communicate.call_count, 2)
self.assertNotEqual(self.mock_popen.return_value.communicate.call_count, 1)
def test_prepare_dependencies_with_custom_index_url(self):
self.input_project.depends_on("a")
self.input_project.set_property("install_dependencies_index_url", "http://example.domain")
prepare_dependencies_dir(self.mock_logger, self.input_project, "targetdir")
self.assertEqual(
list(self.mock_popen.call_args_list),
[
mock.call(
["pip", "install", "--target", "targetdir", "--index-url", "http://example.domain", "a"],
stdout=subprocess.PIPE,
)
],
)
def test_prepare_dependencies_reports_errors(self):
self.input_project.depends_on("a")
self.mock_process.returncode = 1
self.assertRaises(Exception, prepare_dependencies_dir, self.mock_logger, self.input_project, "targetdir")
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_return_empty_string_when_no_dependency_is_given(self):
self.assertEqual("", build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string(self):
self.project.depends_on("spam")
self.assertEqual(
'install_requires = [ "spam" ],', build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string_with_version(self):
self.project.depends_on("spam", "0.7")
self.assertEqual(
'install_requires = [ "spam>=0.7" ],', build_install_dependencies_string(self.project))
def test_should_return_multiple_dependencies_string_with_versions(self):
self.project.depends_on("spam", "0.7")
self.project.depends_on("eggs")
self.assertEqual(
'install_requires = [ "eggs", "spam>=0.7" ],', build_install_dependencies_string(self.project))
def test_should_not_insert_url_dependency_into_install_requires(self):
self.project.depends_on("spam")
self.project.depends_on(
"pyassert", url="https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz")
self.assertEqual(
'install_requires = [ "spam" ],', build_install_dependencies_string(self.project))
def test_should_not_insert_default_version_operator_when_project_contains_operator_in_version(self):
self.project.depends_on("spam", "==0.7")
self.assertEqual(
'install_requires = [ "spam==0.7" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_quote_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["foo", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "foo", "bar" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_empty_requirement_lines(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["", "foo", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "foo", "bar" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_comments_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["#comment", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "bar" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_comments_with_leading_space_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [" # comment", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "bar" ],', build_install_dependencies_string(self.project))
class TestPrepareDependenciesDir(TestCase):
"""Testcases for prepare_dependencies_dir()"""
def setUp(self):
self.patch_popen = mock.patch(
"pybuilder_emr_plugin.emr_tasks.subprocess.Popen")
self.mock_popen = self.patch_popen.start()
self.mock_process = mock.Mock()
self.mock_process.returncode = 0
self.mock_popen.return_value = self.mock_process
self.input_project = Project(".")
self.mock_logger = mock.Mock()
def tearDown(self):
self.patch_popen.stop()
def test_prepare_dependencies_no_excludes(self):
"""Test prepare_dependencies_dir() w/o excludes."""
for dependency in ["a", "b", "c"]:
self.input_project.depends_on(dependency)
prepare_dependencies_dir(self.mock_logger, self.input_project,
"targetdir")
self.assertEqual(list(self.mock_popen.call_args_list), [
mock.call(["pip", "install", "--target", "targetdir", "a"],
stdout=subprocess.PIPE),
mock.call(["pip", "install", "--target", "targetdir", "b"],
stdout=subprocess.PIPE),
mock.call(["pip", "install", "--target", "targetdir", "c"],
stdout=subprocess.PIPE)
])
self.assertEqual(self.mock_popen.return_value.communicate.call_count,
3)
self.assertNotEqual(
self.mock_popen.return_value.communicate.call_count, 1)
def test_prepare_dependencies_with_excludes(self):
"""Test prepare_dependencies_dir() w/ excludes."""
for dependency in ["a", "b", "c", "d", "e"]:
self.input_project.depends_on(dependency)
prepare_dependencies_dir(self.mock_logger,
self.input_project,
"targetdir",
excludes=["b", "e", "a"])
self.assertEqual(list(self.mock_popen.call_args_list), [
mock.call(["pip", "install", "--target", "targetdir", "c"],
stdout=subprocess.PIPE),
mock.call(["pip", "install", "--target", "targetdir", "d"],
stdout=subprocess.PIPE)
])
self.assertEqual(self.mock_popen.return_value.communicate.call_count,
2)
self.assertNotEqual(
self.mock_popen.return_value.communicate.call_count, 1)
def test_prepare_dependencies_with_custom_index_url(self):
self.input_project.depends_on("a")
self.input_project.set_property("install_dependencies_index_url",
"http://example.domain")
prepare_dependencies_dir(self.mock_logger, self.input_project,
"targetdir")
self.assertEqual(list(self.mock_popen.call_args_list), [
mock.call([
"pip", "install", "--target", "targetdir", "--index-url",
"http://example.domain", "a"
],
stdout=subprocess.PIPE),
])
def test_prepare_dependencies_reports_errors(self):
self.input_project.depends_on("a")
self.mock_process.returncode = 1
self.assertRaises(Exception, prepare_dependencies_dir,
self.mock_logger, self.input_project, "targetdir")
class ProjectValidationTest(unittest.TestCase):
def setUp(self):
self.project = Project(basedir="/imaginary", name="Unittest")
def test_should_validate_empty_project(self):
validation_messages = self.project.validate()
assert_that(validation_messages).is_empty()
def test_should_not_validate_project_with_duplicate_dependency_but_different_versions(self):
self.project.depends_on('spam', version='1')
self.project.depends_on('spam', version='2')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Runtime dependency 'spam' has been defined multiple times.")
def test_should_not_validate_project_with_duplicate_dependency_when_version_is_given_for_one(self):
self.project.depends_on('spam')
self.project.depends_on('spam', version='2')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Runtime dependency 'spam' has been defined multiple times.")
def test_should_not_validate_project_with_duplicate_dependency_when_urls_are_different(self):
self.project.depends_on('spam', url='y')
self.project.depends_on('spam', url='x')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Runtime dependency 'spam' has been defined multiple times.")
def test_should_not_validate_project_with_duplicate_dependency_when_url_is_given_for_one(self):
self.project.depends_on('spam')
self.project.depends_on('spam', url='x')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Runtime dependency 'spam' has been defined multiple times.")
def test_should_not_validate_project_with_duplicate_dependency_for_more_than_two_times(self):
self.project.depends_on('spam', version='1')
self.project.depends_on('spam', version='2')
self.project.depends_on('spam', version='3')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Runtime dependency 'spam' has been defined multiple times.")
assert_that(len(validation_messages)).equals(1)
def test_should_not_validate_project_with_duplicate_build_dependency_but_different_versions(self):
self.project.build_depends_on('spam', version='1')
self.project.build_depends_on('spam', version='2')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Build dependency 'spam' has been defined multiple times.")
def test_should_not_validate_project_with_duplicate_build_dependency_when_version_is_given_for_one(self):
self.project.build_depends_on('spam')
self.project.build_depends_on('spam', version='2')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Build dependency 'spam' has been defined multiple times.")
def test_should_not_validate_project_with_duplicate_build_dependency_when_urls_are_different(self):
self.project.build_depends_on('spam', url='y')
self.project.build_depends_on('spam', url='x')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Build dependency 'spam' has been defined multiple times.")
def test_should_not_validate_project_with_duplicate_build_dependency_when_url_is_given_for_one(self):
self.project.build_depends_on('spam')
self.project.build_depends_on('spam', url='x')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Build dependency 'spam' has been defined multiple times.")
def test_should_not_validate_project_with_duplicate_build_dependency_for_more_than_two_times(self):
self.project.build_depends_on('spam', version='1')
self.project.build_depends_on('spam', version='2')
self.project.build_depends_on('spam', version='3')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Build dependency 'spam' has been defined multiple times.")
assert_that(len(validation_messages)).equals(1)
def test_should_not_validate_project_with_runtime_dependency_being_also_given_as_build_dependency(self):
self.project.depends_on('spam')
self.project.build_depends_on('spam')
validation_messages = self.project.validate()
assert_that(validation_messages).contains(
"Runtime dependency 'spam' has also been given as build dependency.")
assert_that(len(validation_messages)).equals(1)
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_return_empty_string_when_no_dependency_is_given(self):
self.assertEqual("", build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string(self):
self.project.depends_on("spam")
self.assertEqual(
'install_requires = [ "spam" ],', build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string_with_version(self):
self.project.depends_on("spam", "0.7")
self.assertEqual(
'install_requires = [ "spam>=0.7" ],', build_install_dependencies_string(self.project))
def test_should_return_multiple_dependencies_string_with_versions(self):
self.project.depends_on("spam", "0.7")
self.project.depends_on("eggs")
self.assertEqual(
'install_requires = [ "eggs", "spam>=0.7" ],', build_install_dependencies_string(self.project))
def test_should_not_insert_url_dependency_into_install_requires(self):
self.project.depends_on("spam")
self.project.depends_on(
"pyassert", url="https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz")
self.assertEqual(
'install_requires = [ "spam" ],', build_install_dependencies_string(self.project))
def test_should_not_insert_default_version_operator_when_project_contains_operator_in_version(self):
self.project.depends_on("spam", "==0.7")
self.assertEqual(
'install_requires = [ "spam==0.7" ],', build_install_dependencies_string(self.project))
class ProjectTest(unittest.TestCase):
def setUp(self):
self.project = Project(basedir="/imaginary", name="Unittest")
@patch("pybuilder.core.basename", return_value="imaginary")
def test_should_pick_directory_name_for_project_name_when_name_is_not_given(
self, os_path_basename):
project = Project(basedir="/imaginary")
self.assertEqual("imaginary", project.name)
os_path_basename.assert_called_with("/imaginary")
def test_get_property_should_return_default_value_when_property_is_not_set(
self):
self.assertEqual("spam", self.project.get_property("spam", "spam"))
def test_get_property_should_return_property_value_when_property_is_set(
self):
self.project.set_property("spam", "eggs")
self.assertEqual("eggs", self.project.get_property("spam", "spam"))
def test_has_property_should_return_false_when_property_is_not_set(self):
self.assertFalse(self.project.has_property("spam"))
def test_has_property_should_return_true_when_property_is_set(self):
self.project.set_property("spam", "eggs")
self.assertTrue(self.project.has_property("spam"))
def test_set_property_if_unset_should_set_property_when_property_is_not_set(
self):
self.project.set_property_if_unset("spam", "spam")
self.assertEqual("spam", self.project.get_property("spam"))
def test_set_property_if_unset_should_not_set_property_when_property_is_already_set(
self):
self.project.set_property("spam", "eggs")
self.project.set_property_if_unset("spam", "spam")
self.assertEqual("eggs", self.project.get_property("spam"))
def test_expand_should_raise_exception_when_property_is_not_set(self):
self.assertRaises(MissingPropertyException, self.project.expand,
"$spam")
def test_expand_should_return_expanded_string_when_property_is_set(self):
self.project.set_property("spam", "eggs")
self.assertEqual("eggs", self.project.expand("$spam"))
def test_expand_should_return_expanded_string_when_two_properties_are_found_and_set(
self):
self.project.set_property("spam", "spam")
self.project.set_property("eggs", "eggs")
self.assertEqual("spam and eggs",
self.project.expand("$spam and $eggs"))
def test_expand_should_expand_property_with_value_being_an_property_expression(
self):
self.project.set_property("spam", "spam")
self.project.set_property("eggs", "$spam")
self.assertEqual("spam", self.project.expand("$eggs"))
def test_expand_should_raise_exception_when_first_expansion_leads_to_property_reference_and_property_is_undefined(
self):
self.project.set_property("eggs", "$spam")
self.assertRaises(MissingPropertyException, self.project.expand,
"$eggs")
def test_expand_path_should_return_expanded_path(self):
self.project.set_property("spam", "spam")
self.project.set_property("eggs", "eggs")
self.assertEqual(np(jp(self.project.basedir, "spam", "eggs")),
self.project.expand_path("$spam/$eggs"))
def test_expand_path_should_return_expanded_path_and_additional_parts_when_additional_parts_are_given(
self):
self.project.set_property("spam", "spam")
self.project.set_property("eggs", "eggs")
self.assertEqual(
np(jp(self.project.basedir, "spam", "eggs", "foo", "bar")),
self.project.expand_path("$spam/$eggs", "foo", "bar"))
def test_should_raise_exception_when_getting_mandatory_propert_and_property_is_not_found(
self):
self.assertRaises(MissingPropertyException,
self.project.get_mandatory_property, "i_dont_exist")
def test_should_return_property_value_when_getting_mandatory_propert_and_property_exists(
self):
self.project.set_property("spam", "spam")
self.assertEqual("spam", self.project.get_mandatory_property("spam"))
def test_should_add_runtime_dependency_with_name_only(self):
self.project.depends_on("spam")
self.assertEqual(1, len(self.project.dependencies))
self.assertEqual("spam", self.project.dependencies[0].name)
self.assertEqual(None, self.project.dependencies[0].version)
def test_should_add_dependency_with_name_and_version(self):
self.project.depends_on("spam", "0.7")
self.assertEqual(1, len(self.project.dependencies))
self.assertEqual("spam", self.project.dependencies[0].name)
self.assertEqual(">=0.7", self.project.dependencies[0].version)
def test_should_add_dependency_with_name_and_version_only_once(self):
self.project.depends_on("spam", "0.7")
self.project.depends_on("spam", "0.7")
self.assertEqual(1, len(self.project.dependencies))
self.assertEqual("spam", self.project.dependencies[0].name)
self.assertEqual(">=0.7", self.project.dependencies[0].version)
class DependencyLinksTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_return_empty_string_when_no_link_dependency_is_given(self):
self.assertEqual("[]", build_dependency_links_string(self.project))
def test_should_return_dependency_link(self):
self.project.depends_on(
"pyassert", url="https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz")
self.assertEqual(
"['https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz']",
build_dependency_links_string(self.project))
def test_should_return_dependency_links(self):
self.project.depends_on("pyassert1",
url="https://github.com/downloads/halimath/pyassert/pyassert1-0.2.2.tar.gz")
self.project.depends_on("pyassert2",
url="https://github.com/downloads/halimath/pyassert/pyassert2-0.2.2.tar.gz")
self.assertEqual("[\n 'https://github.com/downloads/halimath/pyassert/pyassert1-0.2.2.tar.gz',\n"
" 'https://github.com/downloads/halimath/pyassert/pyassert2-0.2.2.tar.gz'\n"
" ]",
build_dependency_links_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_use_editable_urls_from_requirements_as_dependency_links(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"-e git+https://github.com/someuser/someproject.git#egg=some_package",
"-e svn+https://github.com/someuser/someproject#egg=some_package"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"[\n 'git+https://github.com/someuser/someproject.git#egg=some_package',\n"
" 'svn+https://github.com/someuser/someproject#egg=some_package'\n"
" ]",
build_dependency_links_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_use_expanded_editable_urls_from_requirements_as_dependency_links(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"--editable git+https://github.com/someuser/someproject.git#egg=some_package",
"--editable svn+https://github.com/someuser/someproject#egg=some_package"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"[\n 'git+https://github.com/someuser/someproject.git#egg=some_package',\n"
" 'svn+https://github.com/someuser/someproject#egg=some_package'\n"
" ]",
build_dependency_links_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_use_editable_urls_from_requirements_combined_with_url_dependencies(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [
"-e svn+https://github.com/someuser/someproject#egg=some_package"]
self.project.depends_on(
"jedi", url="git+https://github.com/davidhalter/jedi")
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
"[\n 'git+https://github.com/davidhalter/jedi',\n"
" 'svn+https://github.com/someuser/someproject#egg=some_package'\n"
" ]",
build_dependency_links_string(self.project))
class ProjectValidationTest(unittest.TestCase):
def setUp(self):
self.project = Project(basedir="/imaginary", name="Unittest")
def test_should_validate_empty_project(self):
validation_messages = self.project.validate()
self.assertFalse(validation_messages)
def test_should_not_validate_project_with_duplicate_dependency_but_different_versions(
self):
self.project.depends_on('spam', version='1')
self.project.depends_on('spam', version='2')
validation_messages = self.project.validate()
self.assertTrue(
"Runtime dependency 'spam' has been defined multiple times." in
validation_messages)
def test_should_not_validate_project_with_duplicate_dependency_when_version_is_given_for_one(
self):
self.project.depends_on('spam')
self.project.depends_on('spam', version='2')
validation_messages = self.project.validate()
self.assertTrue(
"Runtime dependency 'spam' has been defined multiple times." in
validation_messages)
def test_should_not_validate_project_with_duplicate_dependency_when_urls_are_different(
self):
self.project.depends_on('spam', url='y')
self.project.depends_on('spam', url='x')
validation_messages = self.project.validate()
self.assertTrue(
"Runtime dependency 'spam' has been defined multiple times." in
validation_messages)
def test_should_not_validate_project_with_duplicate_dependency_when_url_is_given_for_one(
self):
self.project.depends_on('spam')
self.project.depends_on('spam', url='x')
validation_messages = self.project.validate()
self.assertTrue(
"Runtime dependency 'spam' has been defined multiple times." in
validation_messages)
def test_should_not_validate_project_with_duplicate_dependency_for_more_than_two_times(
self):
self.project.depends_on('spam', version='1')
self.project.depends_on('spam', version='2')
self.project.depends_on('spam', version='3')
validation_messages = self.project.validate()
self.assertTrue(
"Runtime dependency 'spam' has been defined multiple times." in
validation_messages)
self.assertEquals(len(validation_messages), 1)
def test_should_not_validate_project_with_duplicate_build_dependency_but_different_versions(
self):
self.project.build_depends_on('spam', version='1')
self.project.build_depends_on('spam', version='2')
validation_messages = self.project.validate()
self.assertTrue(
"Build dependency 'spam' has been defined multiple times." in
validation_messages)
def test_should_not_validate_project_with_duplicate_build_dependency_when_version_is_given_for_one(
self):
self.project.build_depends_on('spam')
self.project.build_depends_on('spam', version='2')
validation_messages = self.project.validate()
self.assertTrue(
"Build dependency 'spam' has been defined multiple times." in
validation_messages)
def test_should_not_validate_project_with_duplicate_build_dependency_when_urls_are_different(
self):
self.project.build_depends_on('spam', url='y')
self.project.build_depends_on('spam', url='x')
validation_messages = self.project.validate()
self.assertTrue(
"Build dependency 'spam' has been defined multiple times." in
validation_messages)
def test_should_not_validate_project_with_duplicate_build_dependency_when_url_is_given_for_one(
self):
self.project.build_depends_on('spam')
self.project.build_depends_on('spam', url='x')
validation_messages = self.project.validate()
self.assertTrue(
"Build dependency 'spam' has been defined multiple times." in
validation_messages)
def test_should_not_validate_project_with_duplicate_build_dependency_for_more_than_two_times(
self):
self.project.build_depends_on('spam', version='1')
self.project.build_depends_on('spam', version='2')
self.project.build_depends_on('spam', version='3')
validation_messages = self.project.validate()
self.assertTrue(
"Build dependency 'spam' has been defined multiple times." in
validation_messages)
self.assertEquals(len(validation_messages), 1)
def test_should_not_validate_project_with_runtime_dependency_being_also_given_as_build_dependency(
self):
self.project.depends_on('spam')
self.project.build_depends_on('spam')
validation_messages = self.project.validate()
self.assertTrue(
"Runtime dependency 'spam' has also been given as build dependency."
in validation_messages)
self.assertEquals(len(validation_messages), 1)
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_return_empty_string_when_no_dependency_is_given(self):
self.assertEqual("", build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string(self):
self.project.depends_on("spam")
self.assertEqual(
'install_requires = [ "spam" ],', build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string_with_version(self):
self.project.depends_on("spam", "0.7")
self.assertEqual(
'install_requires = [ "spam>=0.7" ],', build_install_dependencies_string(self.project))
def test_should_return_multiple_dependencies_string_with_versions(self):
self.project.depends_on("spam", "0.7")
self.project.depends_on("eggs")
self.assertEqual(
'install_requires = [ "eggs", "spam>=0.7" ],', build_install_dependencies_string(self.project))
def test_should_not_insert_url_dependency_into_install_requires(self):
self.project.depends_on("spam")
self.project.depends_on(
"pyassert", url="https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz")
self.assertEqual(
'install_requires = [ "spam" ],', build_install_dependencies_string(self.project))
def test_should_not_insert_default_version_operator_when_project_contains_operator_in_version(self):
self.project.depends_on("spam", "==0.7")
self.assertEqual(
'install_requires = [ "spam==0.7" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_quote_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["foo", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "foo", "bar" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_empty_requirement_lines(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["", "foo", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "foo", "bar" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_comments_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["#comment", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "bar" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_comments_with_leading_space_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = [" # comment", "bar"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "bar" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_editable_urls_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["foo", "-e git+https://github.com/someuser/someproject.git#egg=some_package"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "foo" ],', build_install_dependencies_string(self.project))
@patch("pybuilder.plugins.python.distutils_plugin.open", create=True)
def test_should_ignore_expanded_editable_urls_from_requirements(self, mock_open):
mock_open.return_value = MagicMock(spec=TYPE_FILE)
handle = mock_open.return_value.__enter__.return_value
handle.readlines.return_value = ["foo", "--editable git+https://github.com/someuser/someproject.git#egg=some_package"]
self.project.depends_on_requirements("requirements.txt")
self.assertEqual(
'install_requires = [ "foo" ],', build_install_dependencies_string(self.project))
class InstallDependenciesTest(unittest.TestCase):
def setUp(self):
self.project = Project(".")
def test_should_return_empty_string_when_no_dependency_is_given(self):
self.assertEqual("", build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string(self):
self.project.depends_on("spam")
self.assertEqual('install_requires = [ "spam" ],',
build_install_dependencies_string(self.project))
def test_should_return_single_dependency_string_with_version(self):
self.project.depends_on("spam", "0.7")
self.assertEqual('install_requires = [ "spam>=0.7" ],',
build_install_dependencies_string(self.project))
def test_should_return_multiple_dependencies_string_with_versions(self):
self.project.depends_on("spam", "0.7")
self.project.depends_on("eggs")
self.assertEqual('install_requires = [ "eggs", "spam>=0.7" ],',
build_install_dependencies_string(self.project))
def test_should_not_insert_url_dependency_into_install_requires(self):
self.project.depends_on("spam")
self.project.depends_on(
"pyassert",
url=
"https://github.com/downloads/halimath/pyassert/pyassert-0.2.2.tar.gz"
)
self.assertEqual('install_requires = [ "spam" ],',
build_install_dependencies_string(self.project))
def test_should_not_insert_default_version_operator_when_project_contains_operator_in_version(
self):
self.project.depends_on("spam", "==0.7")
self.assertEqual('install_requires = [ "spam==0.7" ],',
build_install_dependencies_string(self.project))
class ProjectTest (unittest.TestCase):
def setUp(self):
self.project = Project(basedir="/imaginary", name="Unittest")
def test_should_pick_directory_name_for_project_name_when_name_is_not_given(self):
try:
when(os.path).basename("/imaginary").thenReturn("imaginary")
project = Project(basedir="/imaginary")
self.assertEquals("imaginary", project.name)
verify(os.path).basename("/imaginary")
finally:
unstub()
def test_get_property_should_return_default_value_when_property_is_not_set(self):
self.assertEquals("spam", self.project.get_property("spam", "spam"))
def test_get_property_should_return_property_value_when_property_is_set(self):
self.project.set_property("spam", "eggs")
self.assertEquals("eggs", self.project.get_property("spam", "spam"))
def test_has_property_should_return_false_when_property_is_not_set(self):
self.assertFalse(self.project.has_property("spam"))
def test_has_property_should_return_true_when_property_is_set(self):
self.project.set_property("spam", "eggs")
self.assertTrue(self.project.has_property("spam"))
def test_set_property_if_unset_should_set_property_when_property_is_not_set(self):
self.project.set_property_if_unset("spam", "spam")
self.assertEquals("spam", self.project.get_property("spam"))
def test_set_property_if_unset_should_not_set_property_when_property_is_already_set(self):
self.project.set_property("spam", "eggs")
self.project.set_property_if_unset("spam", "spam")
self.assertEquals("eggs", self.project.get_property("spam"))
def test_expand_should_raise_exception_when_property_is_not_set(self):
self.assertRaises(
MissingPropertyException, self.project.expand, "$spam")
def test_expand_should_return_expanded_string_when_property_is_set(self):
self.project.set_property("spam", "eggs")
self.assertEquals("eggs", self.project.expand("$spam"))
def test_expand_should_return_expanded_string_when_two_properties_are_found_and_set(self):
self.project.set_property("spam", "spam")
self.project.set_property("eggs", "eggs")
self.assertEquals(
"spam and eggs", self.project.expand("$spam and $eggs"))
def test_expand_should_expand_property_with_value_being_an_property_expression(self):
self.project.set_property("spam", "spam")
self.project.set_property("eggs", "$spam")
self.assertEquals("spam", self.project.expand("$eggs"))
def test_expand_should_raise_exception_when_first_expansion_leads_to_property_reference_and_property_is_undefined(self):
self.project.set_property("eggs", "$spam")
self.assertRaises(
MissingPropertyException, self.project.expand, "$eggs")
def test_expand_path_should_return_expanded_path(self):
self.project.set_property("spam", "spam")
self.project.set_property("eggs", "eggs")
self.assertEquals(os.path.join("/imaginary", "spam", "eggs"),
self.project.expand_path("$spam/$eggs"))
def test_expand_path_should_return_expanded_path_and_additional_parts_when_additional_parts_are_given(self):
self.project.set_property("spam", "spam")
self.project.set_property("eggs", "eggs")
self.assertEquals(
os.path.join("/imaginary", "spam", "eggs", "foo", "bar"),
self.project.expand_path("$spam/$eggs", "foo", "bar"))
def test_should_raise_exception_when_getting_mandatory_propert_and_property_is_not_found(self):
self.assertRaises(MissingPropertyException,
self.project.get_mandatory_property, "i_dont_exist")
def test_should_return_property_value_when_getting_mandatory_propert_and_property_exists(self):
self.project.set_property("spam", "spam")
self.assertEquals("spam", self.project.get_mandatory_property("spam"))
def test_should_add_runtime_dependency_with_name_only(self):
self.project.depends_on("spam")
self.assertEquals(1, len(self.project.dependencies))
self.assertEquals("spam", self.project.dependencies[0].name)
self.assertEquals(None, self.project.dependencies[0].version)
def test_should_add_dependency_with_name_and_version(self):
self.project.depends_on("spam", "0.7")
self.assertEquals(1, len(self.project.dependencies))
self.assertEquals("spam", self.project.dependencies[0].name)
self.assertEquals("0.7", self.project.dependencies[0].version)
def test_should_add_dependency_with_name_and_version_only_once(self):
self.project.depends_on("spam", "0.7")
self.project.depends_on("spam", "0.7")
self.assertEquals(1, len(self.project.dependencies))
self.assertEquals("spam", self.project.dependencies[0].name)
self.assertEquals("0.7", self.project.dependencies[0].version)
class TestPrepareDependenciesDir(TestCase):
"""Testcases for prepare_dependencies_dir()"""
def setUp(self):
self.patch_popen = mock.patch(
'pybuilder_aws_plugin.lambda_tasks.subprocess.Popen')
self.mock_popen = self.patch_popen.start()
self.mock_process = mock.Mock()
self.mock_process.returncode = 0
self.mock_popen.return_value = self.mock_process
self.patch_aspip = mock.patch(
'pybuilder_aws_plugin.lambda_tasks.as_pip_argument')
self.mock_aspip = self.patch_aspip.start()
self.mock_aspip.side_effect = lambda x: x.name
self.input_project = Project('.')
self.mock_logger = mock.Mock()
def tearDown(self):
self.patch_popen.stop()
self.patch_aspip.stop()
def test_prepare_dependencies_no_excludes(self):
"""Test prepare_dependencies_dir() w/o excludes."""
for dependency in ['a', 'b', 'c']:
self.input_project.depends_on(dependency)
prepare_dependencies_dir(
self.mock_logger, self.input_project, 'targetdir')
self.assertEqual(self.mock_aspip.call_count, 3)
self.assertNotEqual(self.mock_aspip.call_count, 4)
self.assertEqual(
list(self.mock_popen.call_args_list), [
mock.call(
['pip', 'install', '--target', 'targetdir', 'a'],
stdout=subprocess.PIPE),
mock.call(
['pip', 'install', '--target', 'targetdir', 'b'],
stdout=subprocess.PIPE),
mock.call(
['pip', 'install', '--target', 'targetdir', 'c'],
stdout=subprocess.PIPE)])
self.assertEqual(
self.mock_popen.return_value.communicate.call_count, 3)
self.assertNotEqual(
self.mock_popen.return_value.communicate.call_count, 1)
def test_prepare_dependencies_with_excludes(self):
"""Test prepare_dependencies_dir() w/ excludes."""
for dependency in ['a', 'b', 'c', 'd', 'e']:
self.input_project.depends_on(dependency)
prepare_dependencies_dir(
self.mock_logger, self.input_project, 'targetdir',
excludes=['b', 'e', 'a'])
self.assertEqual(self.mock_aspip.call_count, 5)
self.assertNotEqual(self.mock_aspip.call_count, 4)
self.assertEqual(
list(self.mock_popen.call_args_list), [
mock.call(
['pip', 'install', '--target', 'targetdir', 'c'],
stdout=subprocess.PIPE),
mock.call(
['pip', 'install', '--target', 'targetdir', 'd'],
stdout=subprocess.PIPE)])
self.assertEqual(
self.mock_popen.return_value.communicate.call_count, 2)
self.assertNotEqual(
self.mock_popen.return_value.communicate.call_count, 1)
def test_prepare_dependencies_with_custom_index_url(self):
self.input_project.depends_on('a')
self.input_project.set_property('install_dependencies_index_url',
'http://example.domain')
prepare_dependencies_dir(
self.mock_logger, self.input_project, 'targetdir')
self.assertEqual(
list(self.mock_popen.call_args_list),
[
mock.call(
['pip', 'install', '--target', 'targetdir', '--index-url',
'http://example.domain', 'a'],
stdout=subprocess.PIPE),
])
def test_prepare_dependencies_reports_errors(self):
self.input_project.depends_on('a')
self.mock_process.returncode = 1
self.assertRaises(Exception, prepare_dependencies_dir,
self.mock_logger, self.input_project, 'targetdir')
