Python Project.depends_on方法代码示例

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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", "[email protected]"), Author("Michael Gruber", "[email protected]")]
    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

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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)

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
    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)

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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),
        )

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
    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)

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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
        )

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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))
#.........这里部分代码省略.........

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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)

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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"]
#.........这里部分代码省略.........

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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))

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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))

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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))

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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")

# 需要导入模块: from pybuilder.core import Project [as 别名]
# 或者: from pybuilder.core.Project import depends_on [as 别名]
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')