write cache in --check mode (#453)

[etc/vim.git] / tests / test_black.py

diff --git a/tests/test_black.py b/tests/test_black.py
index 84b7a616c2dc2df785fb1429ad59cd6c6776c785..884d0463a3fa294fcec898aaff2d51ea454adc02 100644 (file)
--- a/tests/test_black.py
+++ b/tests/test_black.py
@@ -11,7 +11,7 @@ import sys
 from tempfile import TemporaryDirectory
 from typing import Any, BinaryIO, Generator, List, Tuple, Iterator
 import unittest
 from tempfile import TemporaryDirectory
 from typing import Any, BinaryIO, Generator, List, Tuple, Iterator
 import unittest

-from unittest.mock import patch
+from unittest.mock import patch, MagicMock

 
 from click import unstyle
 from click.testing import CliRunner
 
 from click import unstyle
 from click.testing import CliRunner


@@ -162,7 +162,9 @@ class BlackTestCase(unittest.TestCase):
         source, expected = read_data("../black", data=False)
         stderrbuf = BytesIO()
         result = BlackRunner(stderrbuf).invoke(
         source, expected = read_data("../black", data=False)
         stderrbuf = BytesIO()
         result = BlackRunner(stderrbuf).invoke(

-            black.main, ["-", "--fast", f"--line-length={ll}"], input=source
+            black.main,
+            ["-", "--fast", f"--line-length={ll}"],
+            input=BytesIO(source.encode("utf8")),

         )
         self.assertEqual(result.exit_code, 0)
         self.assertFormatEqual(expected, result.output)
         )
         self.assertEqual(result.exit_code, 0)
         self.assertFormatEqual(expected, result.output)


@@ -179,7 +181,9 @@ class BlackTestCase(unittest.TestCase):
         config = THIS_DIR / "data" / "empty_pyproject.toml"
         stderrbuf = BytesIO()
         args = ["-", "--fast", f"--line-length={ll}", "--diff", f"--config={config}"]
         config = THIS_DIR / "data" / "empty_pyproject.toml"
         stderrbuf = BytesIO()
         args = ["-", "--fast", f"--line-length={ll}", "--diff", f"--config={config}"]

-        result = BlackRunner(stderrbuf).invoke(black.main, args, input=source)
+        result = BlackRunner(stderrbuf).invoke(
+            black.main, args, input=BytesIO(source.encode("utf8"))
+        )

         self.assertEqual(result.exit_code, 0)
         actual = diff_header.sub("[Deterministic header]", result.output)
         actual = actual.rstrip() + "\n"  # the diff output has a trailing space
         self.assertEqual(result.exit_code, 0)
         actual = diff_header.sub("[Deterministic header]", result.output)
         actual = actual.rstrip() + "\n"  # the diff output has a trailing space


@@ -369,6 +373,21 @@ class BlackTestCase(unittest.TestCase):
         black.assert_equivalent(source, actual)
         black.assert_stable(source, actual, line_length=ll)
 
         black.assert_equivalent(source, actual)
         black.assert_stable(source, actual, line_length=ll)
 

+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_numeric_literals(self) -> None:
+        source, expected = read_data("numeric_literals")
+        actual = fs(source, mode=black.FileMode.PYTHON36)
+        self.assertFormatEqual(expected, actual)
+        black.assert_equivalent(source, actual)
+        black.assert_stable(source, actual, line_length=ll)
+
+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_numeric_literals_py2(self) -> None:
+        source, expected = read_data("numeric_literals_py2")
+        actual = fs(source)
+        self.assertFormatEqual(expected, actual)
+        black.assert_stable(source, actual, line_length=ll)
+

     @patch("black.dump_to_file", dump_to_stderr)
     def test_python2(self) -> None:
         source, expected = read_data("python2")
     @patch("black.dump_to_file", dump_to_stderr)
     def test_python2(self) -> None:
         source, expected = read_data("python2")


@@ -400,6 +419,14 @@ class BlackTestCase(unittest.TestCase):
         black.assert_equivalent(source, actual)
         black.assert_stable(source, actual, line_length=ll)
 
         black.assert_equivalent(source, actual)
         black.assert_stable(source, actual, line_length=ll)
 

+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_fmtonoff2(self) -> None:
+        source, expected = read_data("fmtonoff2")
+        actual = fs(source)
+        self.assertFormatEqual(expected, actual)
+        black.assert_equivalent(source, actual)
+        black.assert_stable(source, actual, line_length=ll)
+

     @patch("black.dump_to_file", dump_to_stderr)
     def test_remove_empty_parentheses_after_class(self) -> None:
         source, expected = read_data("class_blank_parentheses")
     @patch("black.dump_to_file", dump_to_stderr)
     def test_remove_empty_parentheses_after_class(self) -> None:
         source, expected = read_data("class_blank_parentheses")


@@ -727,6 +754,14 @@ class BlackTestCase(unittest.TestCase):
         self.assertEqual(set(), black.get_future_imports(node))
         node = black.lib2to3_parse("from some.module import black\n")
         self.assertEqual(set(), black.get_future_imports(node))
         self.assertEqual(set(), black.get_future_imports(node))
         node = black.lib2to3_parse("from some.module import black\n")
         self.assertEqual(set(), black.get_future_imports(node))

+        node = black.lib2to3_parse(
+            "from __future__ import unicode_literals as _unicode_literals"
+        )
+        self.assertEqual({"unicode_literals"}, black.get_future_imports(node))
+        node = black.lib2to3_parse(
+            "from __future__ import unicode_literals as _lol, print"
+        )
+        self.assertEqual({"unicode_literals", "print"}, black.get_future_imports(node))

 
     def test_debug_visitor(self) -> None:
         source, _ = read_data("debug_visitor.py")
 
     def test_debug_visitor(self) -> None:
         source, _ = read_data("debug_visitor.py")


@@ -861,7 +896,9 @@ class BlackTestCase(unittest.TestCase):
     def test_no_cache_when_stdin(self) -> None:
         mode = black.FileMode.AUTO_DETECT
         with cache_dir():
     def test_no_cache_when_stdin(self) -> None:
         mode = black.FileMode.AUTO_DETECT
         with cache_dir():

-            result = CliRunner().invoke(black.main, ["-"], input="print('hello')")
+            result = CliRunner().invoke(
+                black.main, ["-"], input=BytesIO(b"print('hello')")
+            )

             self.assertEqual(result.exit_code, 0)
             cache_file = black.get_cache_file(black.DEFAULT_LINE_LENGTH, mode)
             self.assertFalse(cache_file.exists())
             self.assertEqual(result.exit_code, 0)
             cache_file = black.get_cache_file(black.DEFAULT_LINE_LENGTH, mode)
             self.assertFalse(cache_file.exists())


@@ -935,12 +972,10 @@ class BlackTestCase(unittest.TestCase):
             src1 = (THIS_DIR / "data" / "string_quotes.py").resolve()
             result = CliRunner().invoke(black.main, [str(src1), "--diff", "--check"])
             self.assertEqual(result.exit_code, 1, result.output)
             src1 = (THIS_DIR / "data" / "string_quotes.py").resolve()
             result = CliRunner().invoke(black.main, [str(src1), "--diff", "--check"])
             self.assertEqual(result.exit_code, 1, result.output)

-

             # Files which will not be reformatted.
             src2 = (THIS_DIR / "data" / "composition.py").resolve()
             result = CliRunner().invoke(black.main, [str(src2), "--diff", "--check"])
             self.assertEqual(result.exit_code, 0, result.output)
             # Files which will not be reformatted.
             src2 = (THIS_DIR / "data" / "composition.py").resolve()
             result = CliRunner().invoke(black.main, [str(src2), "--diff", "--check"])
             self.assertEqual(result.exit_code, 0, result.output)

-

             # Multi file command.
             result = CliRunner().invoke(
                 black.main, [str(src1), str(src2), "--diff", "--check"]
             # Multi file command.
             result = CliRunner().invoke(
                 black.main, [str(src1), str(src2), "--diff", "--check"]


@@ -1021,7 +1056,9 @@ class BlackTestCase(unittest.TestCase):
 
     def test_pipe_force_pyi(self) -> None:
         source, expected = read_data("force_pyi")
 
     def test_pipe_force_pyi(self) -> None:
         source, expected = read_data("force_pyi")

-        result = CliRunner().invoke(black.main, ["-", "-q", "--pyi"], input=source)
+        result = CliRunner().invoke(
+            black.main, ["-", "-q", "--pyi"], input=BytesIO(source.encode("utf8"))
+        )

         self.assertEqual(result.exit_code, 0)
         actual = result.output
         self.assertFormatEqual(actual, expected)
         self.assertEqual(result.exit_code, 0)
         actual = result.output
         self.assertFormatEqual(actual, expected)


@@ -1075,7 +1112,9 @@ class BlackTestCase(unittest.TestCase):
 
     def test_pipe_force_py36(self) -> None:
         source, expected = read_data("force_py36")
 
     def test_pipe_force_py36(self) -> None:
         source, expected = read_data("force_py36")

-        result = CliRunner().invoke(black.main, ["-", "-q", "--py36"], input=source)
+        result = CliRunner().invoke(
+            black.main, ["-", "-q", "--py36"], input=BytesIO(source.encode("utf8"))
+        )

         self.assertEqual(result.exit_code, 0)
         actual = result.output
         self.assertFormatEqual(actual, expected)
         self.assertEqual(result.exit_code, 0)
         actual = result.output
         self.assertFormatEqual(actual, expected)


@@ -1154,14 +1193,67 @@ class BlackTestCase(unittest.TestCase):
                 test_file.write_bytes(contents.encode())
                 ff(test_file, write_back=black.WriteBack.YES)
                 updated_contents: bytes = test_file.read_bytes()
                 test_file.write_bytes(contents.encode())
                 ff(test_file, write_back=black.WriteBack.YES)
                 updated_contents: bytes = test_file.read_bytes()

-                self.assertIn(nl.encode(), updated_contents)  # type: ignore
+                self.assertIn(nl.encode(), updated_contents)

                 if nl == "\n":
                 if nl == "\n":

-                    self.assertNotIn(b"\r\n", updated_contents)  # type: ignore
+                    self.assertNotIn(b"\r\n", updated_contents)

 
     def test_assert_equivalent_different_asts(self) -> None:
         with self.assertRaises(AssertionError):
             black.assert_equivalent("{}", "None")
 
 
     def test_assert_equivalent_different_asts(self) -> None:
         with self.assertRaises(AssertionError):
             black.assert_equivalent("{}", "None")
 

+    def test_symlink_out_of_root_directory(self) -> None:
+        path = MagicMock()
+        root = THIS_DIR
+        child = MagicMock()
+        include = re.compile(black.DEFAULT_INCLUDES)
+        exclude = re.compile(black.DEFAULT_EXCLUDES)
+        report = black.Report()
+        # `child` should behave like a symlink which resolved path is clearly
+        # outside of the `root` directory.
+        path.iterdir.return_value = [child]
+        child.resolve.return_value = Path("/a/b/c")
+        child.is_symlink.return_value = True
+        try:
+            list(black.gen_python_files_in_dir(path, root, include, exclude, report))
+        except ValueError as ve:
+            self.fail("`get_python_files_in_dir()` failed: {ve}")
+        path.iterdir.assert_called_once()
+        child.resolve.assert_called_once()
+        child.is_symlink.assert_called_once()
+        # `child` should behave like a strange file which resolved path is clearly
+        # outside of the `root` directory.
+        child.is_symlink.return_value = False
+        with self.assertRaises(ValueError):
+            list(black.gen_python_files_in_dir(path, root, include, exclude, report))
+        path.iterdir.assert_called()
+        self.assertEqual(path.iterdir.call_count, 2)
+        child.resolve.assert_called()
+        self.assertEqual(child.resolve.call_count, 2)
+        child.is_symlink.assert_called()
+        self.assertEqual(child.is_symlink.call_count, 2)
+
+    def test_shhh_click(self) -> None:
+        try:
+            from click import _unicodefun  # type: ignore
+        except ModuleNotFoundError:
+            self.skipTest("Incompatible Click version")
+        if not hasattr(_unicodefun, "_verify_python3_env"):
+            self.skipTest("Incompatible Click version")
+        # First, let's see if Click is crashing with a preferred ASCII charset.
+        with patch("locale.getpreferredencoding") as gpe:
+            gpe.return_value = "ASCII"
+            with self.assertRaises(RuntimeError):
+                _unicodefun._verify_python3_env()
+        # Now, let's silence Click...
+        black.patch_click()
+        # ...and confirm it's silent.
+        with patch("locale.getpreferredencoding") as gpe:
+            gpe.return_value = "ASCII"
+            try:
+                _unicodefun._verify_python3_env()
+            except RuntimeError as re:
+                self.fail(f"`patch_click()` failed, exception still raised: {re}")
+

 
 if __name__ == "__main__":
     unittest.main(module="test_black")
 
 if __name__ == "__main__":
     unittest.main(module="test_black")