]> git.madduck.net Git - etc/vim.git/blobdiff - tests/test_black.py

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

projects / etc / vim.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Make sure --verbose trumps --quiet
[etc/vim.git] / tests / test_black.py
diff --git a/tests/test_black.py b/tests/test_black.py
index c10dd1d90c3d3d217895ea52ba644010913a5ce6..1f93e6afdf7c2172621db8924b24e2d598b11b04 100644 (file)
--- a/tests/test_black.py
+++ b/tests/test_black.py
@@ -3,7 +3,7 @@ import asyncio
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
 from functools import partial
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
 from functools import partial
-from io import StringIO
+from io import BytesIO, TextIOWrapper
 import os
 from pathlib import Path
 import sys
 import os
 from pathlib import Path
 import sys
@@ -121,8 +121,9 @@ class BlackTestCase(unittest.TestCase):
         source, expected = read_data("../black")
         hold_stdin, hold_stdout = sys.stdin, sys.stdout
         try:
         source, expected = read_data("../black")
         hold_stdin, hold_stdout = sys.stdin, sys.stdout
         try:
-            sys.stdin, sys.stdout = StringIO(source), StringIO()
-            sys.stdin.name = "<stdin>"
+            sys.stdin = TextIOWrapper(BytesIO(source.encode("utf8")), encoding="utf8")
+            sys.stdout = TextIOWrapper(BytesIO(), encoding="utf8")
+            sys.stdin.buffer.name = "<stdin>"  # type: ignore
             black.format_stdin_to_stdout(
                 line_length=ll, fast=True, write_back=black.WriteBack.YES
             )
             black.format_stdin_to_stdout(
                 line_length=ll, fast=True, write_back=black.WriteBack.YES
             )
@@ -139,8 +140,9 @@ class BlackTestCase(unittest.TestCase):
         expected, _ = read_data("expression.diff")
         hold_stdin, hold_stdout = sys.stdin, sys.stdout
         try:
         expected, _ = read_data("expression.diff")
         hold_stdin, hold_stdout = sys.stdin, sys.stdout
         try:
-            sys.stdin, sys.stdout = StringIO(source), StringIO()
-            sys.stdin.name = "<stdin>"
+            sys.stdin = TextIOWrapper(BytesIO(source.encode("utf8")), encoding="utf8")
+            sys.stdout = TextIOWrapper(BytesIO(), encoding="utf8")
+            sys.stdin.buffer.name = "<stdin>"  # type: ignore
             black.format_stdin_to_stdout(
                 line_length=ll, fast=True, write_back=black.WriteBack.DIFF
             )
             black.format_stdin_to_stdout(
                 line_length=ll, fast=True, write_back=black.WriteBack.DIFF
             )
@@ -204,7 +206,7 @@ class BlackTestCase(unittest.TestCase):
         tmp_file = Path(black.dump_to_file(source))
         hold_stdout = sys.stdout
         try:
         tmp_file = Path(black.dump_to_file(source))
         hold_stdout = sys.stdout
         try:
-            sys.stdout = StringIO()
+            sys.stdout = TextIOWrapper(BytesIO(), encoding="utf8")
             self.assertTrue(ff(tmp_file, write_back=black.WriteBack.DIFF))
             sys.stdout.seek(0)
             actual = sys.stdout.read()
             self.assertTrue(ff(tmp_file, write_back=black.WriteBack.DIFF))
             sys.stdout.seek(0)
             actual = sys.stdout.read()
@@ -378,8 +380,8 @@ 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)
 
-    def test_report(self) -> None:
-        report = black.Report()
+    def test_report_verbose(self) -> None:
+        report = black.Report(verbose=True)
         out_lines = []
         err_lines = []
 
         out_lines = []
         err_lines = []
 
@@ -446,9 +448,19 @@ class BlackTestCase(unittest.TestCase):
                 "2 files failed to reformat.",
             )
             self.assertEqual(report.return_code, 123)
                 "2 files failed to reformat.",
             )
             self.assertEqual(report.return_code, 123)
-            report.done(Path("f4"), black.Changed.NO)
+            report.path_ignored(Path("wat"), "no match")
             self.assertEqual(len(out_lines), 5)
             self.assertEqual(len(err_lines), 2)
             self.assertEqual(len(out_lines), 5)
             self.assertEqual(len(err_lines), 2)
+            self.assertEqual(out_lines[-1], "wat ignored: no match")
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files reformatted, 2 files left unchanged, "
+                "2 files failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.done(Path("f4"), black.Changed.NO)
+            self.assertEqual(len(out_lines), 6)
+            self.assertEqual(len(err_lines), 2)
             self.assertEqual(out_lines[-1], "f4 already well formatted, good job.")
             self.assertEqual(
                 unstyle(str(report)),
             self.assertEqual(out_lines[-1], "f4 already well formatted, good job.")
             self.assertEqual(
                 unstyle(str(report)),
@@ -463,6 +475,183 @@ class BlackTestCase(unittest.TestCase):
                 "2 files would fail to reformat.",
             )
 
                 "2 files would fail to reformat.",
             )
 
+    def test_report_quiet(self) -> None:
+        report = black.Report(quiet=True)
+        out_lines = []
+        err_lines = []
+
+        def out(msg: str, **kwargs: Any) -> None:
+            out_lines.append(msg)
+
+        def err(msg: str, **kwargs: Any) -> None:
+            err_lines.append(msg)
+
+        with patch("black.out", out), patch("black.err", err):
+            report.done(Path("f1"), black.Changed.NO)
+            self.assertEqual(len(out_lines), 0)
+            self.assertEqual(len(err_lines), 0)
+            self.assertEqual(unstyle(str(report)), "1 file left unchanged.")
+            self.assertEqual(report.return_code, 0)
+            report.done(Path("f2"), black.Changed.YES)
+            self.assertEqual(len(out_lines), 0)
+            self.assertEqual(len(err_lines), 0)
+            self.assertEqual(
+                unstyle(str(report)), "1 file reformatted, 1 file left unchanged."
+            )
+            report.done(Path("f3"), black.Changed.CACHED)
+            self.assertEqual(len(out_lines), 0)
+            self.assertEqual(len(err_lines), 0)
+            self.assertEqual(
+                unstyle(str(report)), "1 file reformatted, 2 files left unchanged."
+            )
+            self.assertEqual(report.return_code, 0)
+            report.check = True
+            self.assertEqual(report.return_code, 1)
+            report.check = False
+            report.failed(Path("e1"), "boom")
+            self.assertEqual(len(out_lines), 0)
+            self.assertEqual(len(err_lines), 1)
+            self.assertEqual(err_lines[-1], "error: cannot format e1: boom")
+            self.assertEqual(
+                unstyle(str(report)),
+                "1 file reformatted, 2 files left unchanged, "
+                "1 file failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.done(Path("f3"), black.Changed.YES)
+            self.assertEqual(len(out_lines), 0)
+            self.assertEqual(len(err_lines), 1)
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files reformatted, 2 files left unchanged, "
+                "1 file failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.failed(Path("e2"), "boom")
+            self.assertEqual(len(out_lines), 0)
+            self.assertEqual(len(err_lines), 2)
+            self.assertEqual(err_lines[-1], "error: cannot format e2: boom")
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files reformatted, 2 files left unchanged, "
+                "2 files failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.path_ignored(Path("wat"), "no match")
+            self.assertEqual(len(out_lines), 0)
+            self.assertEqual(len(err_lines), 2)
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files reformatted, 2 files left unchanged, "
+                "2 files failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.done(Path("f4"), black.Changed.NO)
+            self.assertEqual(len(out_lines), 0)
+            self.assertEqual(len(err_lines), 2)
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files reformatted, 3 files left unchanged, "
+                "2 files failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.check = True
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files would be reformatted, 3 files would be left unchanged, "
+                "2 files would fail to reformat.",
+            )
+
+    def test_report_normal(self) -> None:
+        report = black.Report()
+        out_lines = []
+        err_lines = []
+
+        def out(msg: str, **kwargs: Any) -> None:
+            out_lines.append(msg)
+
+        def err(msg: str, **kwargs: Any) -> None:
+            err_lines.append(msg)
+
+        with patch("black.out", out), patch("black.err", err):
+            report.done(Path("f1"), black.Changed.NO)
+            self.assertEqual(len(out_lines), 0)
+            self.assertEqual(len(err_lines), 0)
+            self.assertEqual(unstyle(str(report)), "1 file left unchanged.")
+            self.assertEqual(report.return_code, 0)
+            report.done(Path("f2"), black.Changed.YES)
+            self.assertEqual(len(out_lines), 1)
+            self.assertEqual(len(err_lines), 0)
+            self.assertEqual(out_lines[-1], "reformatted f2")
+            self.assertEqual(
+                unstyle(str(report)), "1 file reformatted, 1 file left unchanged."
+            )
+            report.done(Path("f3"), black.Changed.CACHED)
+            self.assertEqual(len(out_lines), 1)
+            self.assertEqual(len(err_lines), 0)
+            self.assertEqual(out_lines[-1], "reformatted f2")
+            self.assertEqual(
+                unstyle(str(report)), "1 file reformatted, 2 files left unchanged."
+            )
+            self.assertEqual(report.return_code, 0)
+            report.check = True
+            self.assertEqual(report.return_code, 1)
+            report.check = False
+            report.failed(Path("e1"), "boom")
+            self.assertEqual(len(out_lines), 1)
+            self.assertEqual(len(err_lines), 1)
+            self.assertEqual(err_lines[-1], "error: cannot format e1: boom")
+            self.assertEqual(
+                unstyle(str(report)),
+                "1 file reformatted, 2 files left unchanged, "
+                "1 file failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.done(Path("f3"), black.Changed.YES)
+            self.assertEqual(len(out_lines), 2)
+            self.assertEqual(len(err_lines), 1)
+            self.assertEqual(out_lines[-1], "reformatted f3")
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files reformatted, 2 files left unchanged, "
+                "1 file failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.failed(Path("e2"), "boom")
+            self.assertEqual(len(out_lines), 2)
+            self.assertEqual(len(err_lines), 2)
+            self.assertEqual(err_lines[-1], "error: cannot format e2: boom")
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files reformatted, 2 files left unchanged, "
+                "2 files failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.path_ignored(Path("wat"), "no match")
+            self.assertEqual(len(out_lines), 2)
+            self.assertEqual(len(err_lines), 2)
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files reformatted, 2 files left unchanged, "
+                "2 files failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.done(Path("f4"), black.Changed.NO)
+            self.assertEqual(len(out_lines), 2)
+            self.assertEqual(len(err_lines), 2)
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files reformatted, 3 files left unchanged, "
+                "2 files failed to reformat.",
+            )
+            self.assertEqual(report.return_code, 123)
+            report.check = True
+            self.assertEqual(
+                unstyle(str(report)),
+                "2 files would be reformatted, 3 files would be left unchanged, "
+                "2 files would fail to reformat.",
+            )
+
     def test_is_python36(self) -> None:
         node = black.lib2to3_parse("def f(*, arg): ...\n")
         self.assertFalse(black.is_python36(node))
     def test_is_python36(self) -> None:
         node = black.lib2to3_parse("def f(*, arg): ...\n")
         self.assertFalse(black.is_python36(node))
@@ -731,7 +920,10 @@ class BlackTestCase(unittest.TestCase):
     def test_broken_symlink(self) -> None:
         with cache_dir() as workspace:
             symlink = workspace / "broken_link.py"
     def test_broken_symlink(self) -> None:
         with cache_dir() as workspace:
             symlink = workspace / "broken_link.py"
-            symlink.symlink_to("nonexistent.py")
+            try:
+                symlink.symlink_to("nonexistent.py")
+            except OSError as e:
+                self.skipTest(f"Can't create symlinks: {e}")
             result = CliRunner().invoke(black.main, [str(workspace.resolve())])
             self.assertEqual(result.exit_code, 0)
 
             result = CliRunner().invoke(black.main, [str(workspace.resolve())])
             self.assertEqual(result.exit_code, 0)
 
@@ -856,40 +1048,59 @@ class BlackTestCase(unittest.TestCase):
         path = THIS_DIR / "include_exclude_tests"
         include = re.compile(r"\.pyi?$")
         exclude = re.compile(r"/exclude/|/\.definitely_exclude/")
         path = THIS_DIR / "include_exclude_tests"
         include = re.compile(r"\.pyi?$")
         exclude = re.compile(r"/exclude/|/\.definitely_exclude/")
+        report = black.Report()
         sources: List[Path] = []
         expected = [
             Path(THIS_DIR / "include_exclude_tests/b/dont_exclude/a.py"),
             Path(THIS_DIR / "include_exclude_tests/b/dont_exclude/a.pyi"),
         ]
         sources: List[Path] = []
         expected = [
             Path(THIS_DIR / "include_exclude_tests/b/dont_exclude/a.py"),
             Path(THIS_DIR / "include_exclude_tests/b/dont_exclude/a.pyi"),
         ]
-        sources.extend(black.gen_python_files_in_dir(path, include, exclude))
+        this_abs = THIS_DIR.resolve()
+        sources.extend(
+            black.gen_python_files_in_dir(path, this_abs, include, exclude, report)
+        )
         self.assertEqual(sorted(expected), sorted(sources))
 
     def test_empty_include(self) -> None:
         path = THIS_DIR / "include_exclude_tests"
         self.assertEqual(sorted(expected), sorted(sources))
 
     def test_empty_include(self) -> None:
         path = THIS_DIR / "include_exclude_tests"
+        report = black.Report()
         empty = re.compile(r"")
         sources: List[Path] = []
         empty = re.compile(r"")
         sources: List[Path] = []
+        expected = [
+            Path(path / "b/exclude/a.pie"),
+            Path(path / "b/exclude/a.py"),
+            Path(path / "b/exclude/a.pyi"),
+            Path(path / "b/dont_exclude/a.pie"),
+            Path(path / "b/dont_exclude/a.py"),
+            Path(path / "b/dont_exclude/a.pyi"),
+            Path(path / "b/.definitely_exclude/a.pie"),
+            Path(path / "b/.definitely_exclude/a.py"),
+            Path(path / "b/.definitely_exclude/a.pyi"),
+        ]
+        this_abs = THIS_DIR.resolve()
         sources.extend(
             black.gen_python_files_in_dir(
         sources.extend(
             black.gen_python_files_in_dir(
-                path, empty, re.compile(black.DEFAULT_EXCLUDES)
+                path, this_abs, empty, re.compile(black.DEFAULT_EXCLUDES), report
             )
         )
             )
         )
-        self.assertEqual([], (sources))
+        self.assertEqual(sorted(expected), sorted(sources))
 
     def test_empty_exclude(self) -> None:
         path = THIS_DIR / "include_exclude_tests"
 
     def test_empty_exclude(self) -> None:
         path = THIS_DIR / "include_exclude_tests"
+        report = black.Report()
         empty = re.compile(r"")
         sources: List[Path] = []
         expected = [
         empty = re.compile(r"")
         sources: List[Path] = []
         expected = [
-            Path(THIS_DIR / "include_exclude_tests/b/dont_exclude/a.py"),
-            Path(THIS_DIR / "include_exclude_tests/b/dont_exclude/a.pyi"),
-            Path(THIS_DIR / "include_exclude_tests/b/exclude/a.py"),
-            Path(THIS_DIR / "include_exclude_tests/b/exclude/a.pyi"),
-            Path(THIS_DIR / "include_exclude_tests/b/.definitely_exclude/a.py"),
-            Path(THIS_DIR / "include_exclude_tests/b/.definitely_exclude/a.pyi"),
+            Path(path / "b/dont_exclude/a.py"),
+            Path(path / "b/dont_exclude/a.pyi"),
+            Path(path / "b/exclude/a.py"),
+            Path(path / "b/exclude/a.pyi"),
+            Path(path / "b/.definitely_exclude/a.py"),
+            Path(path / "b/.definitely_exclude/a.pyi"),
         ]
         ]
+        this_abs = THIS_DIR.resolve()
         sources.extend(
             black.gen_python_files_in_dir(
         sources.extend(
             black.gen_python_files_in_dir(
-                path, re.compile(black.DEFAULT_INCLUDES), empty
+                path, this_abs, re.compile(black.DEFAULT_INCLUDES), empty, report
             )
         )
         self.assertEqual(sorted(expected), sorted(sources))
             )
         )
         self.assertEqual(sorted(expected), sorted(sources))
@@ -899,6 +1110,18 @@ class BlackTestCase(unittest.TestCase):
             result = CliRunner().invoke(black.main, ["-", option, "**()(!!*)"])
             self.assertEqual(result.exit_code, 2)
 
             result = CliRunner().invoke(black.main, ["-", option, "**()(!!*)"])
             self.assertEqual(result.exit_code, 2)
 
+    def test_preserves_line_endings(self) -> None:
+        with TemporaryDirectory() as workspace:
+            test_file = Path(workspace) / "test.py"
+            for nl in ["\n", "\r\n"]:
+                contents = nl.join(["def f(  ):", "    pass"])
+                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
+                if nl == "\n":
+                    self.assertNotIn(b"\r\n", updated_contents)  # type: ignore
+
 
 if __name__ == "__main__":
     unittest.main()
 
 if __name__ == "__main__":
     unittest.main()
vim configuration

Legalese

All content available in this repository is copyright © martin f. krafft, unless otherwise noted.

All files and their content are released under the terms of the Artistic Licence 2.0, unless otherwise noted.

The operator of this repository shall not be held liable for offending content in pages linking to or linked from these page, nor does he endorse their content unless stated otherwise.