supplier-meesho.webflow 1.0.0

package/GitRepos/isort/tests/unit/test_exceptions.py

@@ -0,0 +1,100 @@
+from isort import exceptions
+
+
+class TestISortError:
+    def setup_class(self):
+        self.instance = exceptions.ISortError()
+
+    def test_init(self):
+        assert isinstance(self.instance, exceptions.ISortError)
+
+
+class TestExistingSyntaxErrors(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.ExistingSyntaxErrors("file_path")
+
+    def test_variables(self):
+        assert self.instance.file_path == "file_path"
+
+
+class TestIntroducedSyntaxErrors(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.IntroducedSyntaxErrors("file_path")
+
+    def test_variables(self):
+        assert self.instance.file_path == "file_path"
+
+
+class TestFileSkipped(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.FileSkipped("message", "file_path")
+
+    def test_variables(self):
+        assert self.instance.file_path == "file_path"
+        assert str(self.instance) == "message"
+
+
+class TestFileSkipComment(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.FileSkipComment("file_path")
+
+    def test_variables(self):
+        assert self.instance.file_path == "file_path"
+
+
+class TestFileSkipSetting(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.FileSkipSetting("file_path")
+
+    def test_variables(self):
+        assert self.instance.file_path == "file_path"
+
+
+class TestProfileDoesNotExist(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.ProfileDoesNotExist("profile")
+
+    def test_variables(self):
+        assert self.instance.profile == "profile"
+
+
+class TestLiteralParsingFailure(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.LiteralParsingFailure("x = [", SyntaxError)
+
+    def test_variables(self):
+        assert self.instance.code == "x = ["
+        assert self.instance.original_error == SyntaxError
+
+
+class TestLiteralSortTypeMismatch(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.LiteralSortTypeMismatch(tuple, list)
+
+    def test_variables(self):
+        assert self.instance.kind == tuple
+        assert self.instance.expected_kind == list
+
+
+class TestAssignmentsFormatMismatch(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.AssignmentsFormatMismatch("print x")
+
+    def test_variables(self):
+        assert self.instance.code == "print x"
+
+
+class TestUnsupportedSettings(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.UnsupportedSettings({"apply": {"value": "true", "source": "/"}})
+
+    def test_variables(self):
+        assert self.instance.unsupported_settings == {"apply": {"value": "true", "source": "/"}}
+
+
+class TestUnsupportedEncoding(TestISortError):
+    def setup_class(self):
+        self.instance = exceptions.UnsupportedEncoding("file.py")
+
+    def test_variables(self):
+        assert self.instance.filename == "file.py"

package/GitRepos/isort/tests/unit/test_files.py

@@ -0,0 +1,8 @@
+from isort import files
+from isort.settings import DEFAULT_CONFIG
+
+
+def test_find(tmpdir):
+    tmp_file = tmpdir.join("file.py")
+    tmp_file.write("import os, sys\n")
+    assert tuple(files.find((tmp_file,), DEFAULT_CONFIG, [], [])) == (tmp_file,)

package/GitRepos/isort/tests/unit/test_format.py

@@ -0,0 +1,121 @@
+from io import StringIO
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import colorama
+import pytest
+from hypothesis import given, reject
+from hypothesis import strategies as st
+
+import isort.format
+
+
+def test_ask_whether_to_apply_changes_to_file():
+    with patch("isort.format.input", MagicMock(return_value="y")):
+        assert isort.format.ask_whether_to_apply_changes_to_file("")
+    with patch("isort.format.input", MagicMock(return_value="n")):
+        assert not isort.format.ask_whether_to_apply_changes_to_file("")
+    with patch("isort.format.input", MagicMock(return_value="q")):
+        with pytest.raises(SystemExit):
+            assert isort.format.ask_whether_to_apply_changes_to_file("")
+
+
+def test_basic_printer(capsys):
+    printer = isort.format.create_terminal_printer(color=False)
+    printer.success("All good!")
+    out, _ = capsys.readouterr()
+    assert out == "SUCCESS: All good!\n"
+    printer.error("Some error")
+    _, err = capsys.readouterr()
+    assert err == "ERROR: Some error\n"
+
+
+def test_basic_printer_diff(capsys):
+    printer = isort.format.create_terminal_printer(color=False)
+    printer.diff_line("+ added line\n")
+    printer.diff_line("- removed line\n")
+
+    out, _ = capsys.readouterr()
+    assert out == "+ added line\n- removed line\n"
+
+
+def test_colored_printer_success(capsys):
+    printer = isort.format.create_terminal_printer(color=True)
+    printer.success("All good!")
+    out, _ = capsys.readouterr()
+    assert "SUCCESS" in out
+    assert "All good!" in out
+    assert colorama.Fore.GREEN in out
+
+
+def test_colored_printer_error(capsys):
+    printer = isort.format.create_terminal_printer(color=True)
+    printer.error("Some error")
+    _, err = capsys.readouterr()
+    assert "ERROR" in err
+    assert "Some error" in err
+    assert colorama.Fore.RED in err
+
+
+def test_colored_printer_diff(capsys):
+    printer = isort.format.create_terminal_printer(color=True)
+    printer.diff_line("+++ file1\n")
+    printer.diff_line("--- file2\n")
+    printer.diff_line("+ added line\n")
+    printer.diff_line("normal line\n")
+    printer.diff_line("- removed line\n")
+    printer.diff_line("normal line\n")
+
+    out, _ = capsys.readouterr()
+    # No color added to lines with multiple + and -'s
+    assert out.startswith("+++ file1\n--- file2\n")
+    # Added lines are green
+    assert colorama.Fore.GREEN + "+ added line" in out
+    # Removed lines are red
+    assert colorama.Fore.RED + "- removed line" in out
+    # Normal lines are resetted back
+    assert colorama.Style.RESET_ALL + "normal line" in out
+
+
+def test_colored_printer_diff_output(capsys):
+    output = StringIO()
+    printer = isort.format.create_terminal_printer(color=True, output=output)
+    printer.diff_line("a line\n")
+
+    out, _ = capsys.readouterr()
+    assert out == ""
+
+    output.seek(0)
+    assert output.read().startswith("a line\n")
+
+
+@patch("isort.format.colorama_unavailable", True)
+def test_colorama_not_available_handled_gracefully(capsys):
+    with pytest.raises(SystemExit) as system_exit:
+        _ = isort.format.create_terminal_printer(color=True)
+    assert system_exit.value.code > 0
+    _, err = capsys.readouterr()
+    assert "colorama" in err
+    assert "colors extra" in err
+
+
+# This test code was written by the `hypothesis.extra.ghostwriter` module
+# and is provided under the Creative Commons Zero public domain dedication.
+
+
+@given(
+    file_input=st.text(),
+    file_output=st.text(),
+    file_path=st.one_of(st.none(), st.builds(Path)),
+    output=st.one_of(st.none(), st.builds(StringIO, st.text())),
+)
+def test_fuzz_show_unified_diff(file_input, file_output, file_path, output):
+    try:
+        isort.format.show_unified_diff(
+            file_input=file_input,
+            file_output=file_output,
+            file_path=file_path,
+            output=output,
+        )
+    except UnicodeEncodeError:
+        reject()

package/GitRepos/isort/tests/unit/test_hooks.py

@@ -0,0 +1,101 @@
+import os
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from isort import exceptions, hooks
+
+
+def test_git_hook(src_dir):
+    """Simple smoke level testing of git hooks"""
+
+    # Ensure correct subprocess command is called
+    with patch("subprocess.run", MagicMock()) as run_mock:
+        hooks.git_hook()
+        assert run_mock.called_once()
+        assert run_mock.call_args[0][0] == [
+            "git",
+            "diff-index",
+            "--cached",
+            "--name-only",
+            "--diff-filter=ACMRTUXB",
+            "HEAD",
+        ]
+
+        hooks.git_hook(lazy=True)
+        assert run_mock.called_once()
+        assert run_mock.call_args[0][0] == [
+            "git",
+            "diff-index",
+            "--name-only",
+            "--diff-filter=ACMRTUXB",
+            "HEAD",
+        ]
+
+    # Test that non python files aren't processed
+    with patch(
+        "isort.hooks.get_lines",
+        MagicMock(return_value=["README.md", "setup.cfg", "LICDENSE", "mkdocs.yml", "test"]),
+    ):
+        with patch("subprocess.run", MagicMock()) as run_mock:
+            hooks.git_hook(modify=True)
+            run_mock.assert_not_called()
+
+    mock_main_py = MagicMock(return_value=[os.path.join(src_dir, "main.py")])
+
+    mock_imperfect = MagicMock()
+    mock_imperfect.return_value.stdout = b"import b\nimport a"
+
+    # Test with incorrectly sorted file returned from git
+    with patch("isort.hooks.get_lines", mock_main_py):
+        with patch("subprocess.run", mock_imperfect):
+            with patch("isort.api.sort_file", MagicMock(return_value=False)) as api_mock:
+                hooks.git_hook(modify=True)
+                api_mock.assert_called_once()
+                assert api_mock.call_args[0][0] == mock_main_py.return_value[0]
+
+    # Test with sorted file returned from git and modify=False
+    with patch("isort.hooks.get_lines", mock_main_py):
+        with patch("subprocess.run", mock_imperfect):
+            with patch("isort.api.sort_file", MagicMock(return_value=False)) as api_mock:
+                hooks.git_hook(modify=False)
+                api_mock.assert_not_called()
+
+    # Test with skipped file returned from git
+    with patch(
+        "isort.hooks.get_lines", MagicMock(return_value=[os.path.join(src_dir, "main.py")])
+    ) as run_mock:
+
+        class FakeProcessResponse(object):
+            stdout = b"# isort: skip-file\nimport b\nimport a\n"
+
+        with patch("subprocess.run", MagicMock(return_value=FakeProcessResponse())) as run_mock:
+            with patch("isort.api", MagicMock(side_effect=exceptions.FileSkipped("", ""))):
+                hooks.git_hook(modify=True)
+
+
+def test_git_hook_uses_the_configuration_file_specified_in_settings_path(tmp_path: Path) -> None:
+    subdirectory_path = tmp_path / "subdirectory"
+    configuration_file_path = subdirectory_path / ".isort.cfg"
+
+    # Inserting the modified file in the parent directory of the configuration file ensures that it
+    # will not be found by the normal search routine
+    modified_file_path = configuration_file_path.parent.parent / "somefile.py"
+
+    # This section will be used to check that the configuration file was indeed loaded
+    section = "testsection"
+
+    os.mkdir(subdirectory_path)
+    with open(configuration_file_path, "w") as fd:
+        fd.write("[isort]\n")
+        fd.write(f"sections={section}")
+
+    with open(modified_file_path, "w") as fd:
+        pass
+
+    files_modified = [str(modified_file_path.absolute())]
+    with patch("isort.hooks.get_lines", MagicMock(return_value=files_modified)):
+        with patch("isort.hooks.get_output", MagicMock(return_value="")):
+            with patch("isort.api.check_code_string", MagicMock()) as run_mock:
+                hooks.git_hook(settings_file=str(configuration_file_path))
+
+                assert run_mock.call_args[1]["config"].sections == (section,)

package/GitRepos/isort/tests/unit/test_identify.py

@@ -0,0 +1,274 @@
+from io import StringIO
+from typing import List
+
+from isort import Config, identify
+from isort.identify import Import
+
+
+def imports_in_code(code: str, **kwargs) -> List[identify.Import]:
+    return list(identify.imports(StringIO(code), **kwargs))
+
+
+def test_top_only():
+    imports_in_function = """
+import abc
+
+def xyz():
+    import defg
+"""
+    assert len(imports_in_code(imports_in_function)) == 2
+    assert len(imports_in_code(imports_in_function, top_only=True)) == 1
+
+    imports_after_class = """
+import abc
+
+class MyObject:
+    pass
+
+import defg
+"""
+    assert len(imports_in_code(imports_after_class)) == 2
+    assert len(imports_in_code(imports_after_class, top_only=True)) == 1
+
+
+def test_top_doc_string():
+    assert (
+        len(
+            imports_in_code(
+                '''
+#! /bin/bash import x
+"""import abc
+from y import z
+"""
+import abc
+'''
+            )
+        )
+        == 1
+    )
+
+
+def test_yield_and_raise_edge_cases():
+    assert not imports_in_code(
+        """
+raise SomeException("Blah") \\
+    from exceptionsInfo.popitem()[1]
+"""
+    )
+    assert not imports_in_code(
+        """
+def generator_function():
+    yield \\
+        from other_function()[1]
+"""
+    )
+    assert (
+        len(
+            imports_in_code(
+                """
+# one
+
+# two
+
+
+def function():
+    # three \\
+    import b
+    import a
+"""
+            )
+        )
+        == 2
+    )
+    assert (
+        len(
+            imports_in_code(
+                """
+# one
+
+# two
+
+
+def function():
+    raise \\
+    import b
+    import a
+"""
+            )
+        )
+        == 1
+    )
+    assert not imports_in_code(
+        """
+def generator_function():
+    (
+     yield
+     from other_function()[1]
+    )
+"""
+    )
+    assert not imports_in_code(
+        """
+def generator_function():
+    (
+    (
+    ((((
+    (((((
+    ((
+    (((
+     yield
+
+
+
+     from other_function()[1]
+    )))))))))))))
+    )))
+"""
+    )
+    assert (
+        len(
+            imports_in_code(
+                """
+def generator_function():
+    import os
+
+    yield \\
+    from other_function()[1]
+"""
+            )
+        )
+        == 1
+    )
+
+    assert not imports_in_code(
+        """
+def generator_function():
+    (
+    (
+    ((((
+    (((((
+    ((
+    (((
+     yield
+"""
+    )
+    assert not imports_in_code(
+        """
+def generator_function():
+    (
+    (
+    ((((
+    (((((
+    ((
+    (((
+     raise (
+"""
+    )
+    assert not imports_in_code(
+        """
+def generator_function():
+    (
+    (
+    ((((
+    (((((
+    ((
+    (((
+     raise \\
+     from \\
+"""
+    )
+    assert (
+        len(
+            imports_in_code(
+                """
+def generator_function():
+    (
+    (
+    ((((
+    (((((
+    ((
+    (((
+     raise \\
+     from \\
+    import c
+
+    import abc
+    import xyz
+"""
+            )
+        )
+        == 2
+    )
+
+
+def test_complex_examples():
+    assert (
+        len(
+            imports_in_code(
+                """
+import a, b, c; import n
+
+x = (
+    1,
+    2,
+    3
+)
+
+import x
+from os \\
+    import path
+from os (
+    import path
+)
+from os import \\
+    path
+from os \\
+    import (
+        path
+    )
+from os import ( \\"""
+            )
+        )
+        == 9
+    )
+    assert not imports_in_code("from os import \\")
+    assert (
+        imports_in_code(
+            """
+from os \\
+    import (
+        system"""
+        )
+        == [
+            Import(
+                line_number=2,
+                indented=False,
+                module="os",
+                attribute="system",
+                alias=None,
+                cimport=False,
+                file_path=None,
+            )
+        ]
+    )
+
+
+def test_aliases():
+    assert imports_in_code("import os as os")[0].alias == "os"
+    assert not imports_in_code(
+        "import os as os",
+        config=Config(
+            remove_redundant_aliases=True,
+        ),
+    )[0].alias
+
+    assert imports_in_code("from os import path as path")[0].alias == "path"
+    assert not imports_in_code(
+        "from os import path as path", config=Config(remove_redundant_aliases=True)
+    )[0].alias
+
+
+def test_indented():
+    assert not imports_in_code("import os")[0].indented
+    assert imports_in_code("     import os")[0].indented
+    assert imports_in_code("\timport os")[0].indented

package/GitRepos/isort/tests/unit/test_importable.py

@@ -0,0 +1,42 @@
+"""Basic set of tests to ensure entire code base is importable"""
+import pytest
+
+
+def test_importable():
+    """Simple smoketest to ensure all isort modules are importable"""
+
+    import isort
+    import isort._future
+    import isort._future._dataclasses
+    import isort._version
+    import isort.api
+    import isort.comments
+    import isort.deprecated.finders
+    import isort.exceptions
+    import isort.format
+    import isort.hooks
+    import isort.logo
+    import isort.main
+    import isort.output
+    import isort.parse
+    import isort.place
+    import isort.profiles
+    import isort.pylama_isort
+    import isort.sections
+    import isort.settings
+    import isort.setuptools_commands
+    import isort.sorting
+    import isort.stdlibs
+    import isort.stdlibs.all
+    import isort.stdlibs.py2
+    import isort.stdlibs.py3
+    import isort.stdlibs.py27
+    import isort.stdlibs.py35
+    import isort.stdlibs.py36
+    import isort.stdlibs.py37
+    import isort.utils
+    import isort.wrap
+    import isort.wrap_modes
+
+    with pytest.raises(SystemExit):
+        import isort.__main__  # noqa: F401

package/GitRepos/isort/tests/unit/test_io.py

@@ -0,0 +1,43 @@
+import sys
+from unittest.mock import patch
+
+import pytest
+
+from isort import io
+
+
+class TestFile:
+    @pytest.mark.skipif(sys.platform == "win32", reason="Can't run file encoding test in AppVeyor")
+    def test_read(self, tmpdir):
+        test_file_content = """# -*- encoding: ascii -*-
+
+import Ὡ
+"""
+        test_file = tmpdir.join("file.py")
+        test_file.write(test_file_content)
+        with pytest.raises(Exception):
+            with io.File.read(str(test_file)) as file_handler:
+                file_handler.stream.read()
+
+    def test_from_content(self, tmpdir):
+        test_file = tmpdir.join("file.py")
+        test_file.write_text("import os", "utf8")
+        file_obj = io.File.from_contents("import os", filename=str(test_file))
+        assert file_obj
+        assert file_obj.extension == "py"
+
+    def test_open(self, tmpdir):
+        with pytest.raises(Exception):
+            io.File._open("THISCANTBEAREALFILEὩὩὩὩὩὩὩὩὩὩὩὩ.ὩὩὩὩὩ")
+
+        def raise_arbitrary_exception(*args, **kwargs):
+            raise RuntimeError("test")
+
+        test_file = tmpdir.join("file.py")
+        test_file.write("import os")
+        assert io.File._open(str(test_file))
+
+        # correctly responds to error determining encoding
+        with patch("tokenize.detect_encoding", raise_arbitrary_exception):
+            with pytest.raises(Exception):
+                io.File._open(str(test_file))