]> 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
acks += miggaiowski
[etc/vim.git] / tests / test_black.py
diff --git a/tests/test_black.py b/tests/test_black.py
index fc310690ccec649a339bad18b53e6d44ccd335c7..bc133cab4aca84f69de1a6eab504134cd7ed1065 100644 (file)
--- a/tests/test_black.py
+++ b/tests/test_black.py
@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 import asyncio
 #!/usr/bin/env python3
 import asyncio
+from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
 from functools import partial
 from io import StringIO
 from contextlib import contextmanager
 from functools import partial
 from io import StringIO
@@ -56,8 +57,7 @@ def cache_dir(exists: bool = True) -> Iterator[Path]:
         cache_dir = Path(workspace)
         if not exists:
             cache_dir = cache_dir / "new"
         cache_dir = Path(workspace)
         if not exists:
             cache_dir = cache_dir / "new"
-        cache_file = cache_dir / "cache.pkl"
-        with patch("black.CACHE_DIR", cache_dir), patch("black.CACHE_FILE", cache_file):
+        with patch("black.CACHE_DIR", cache_dir):
             yield cache_dir
 
 
             yield cache_dir
 
 
@@ -167,6 +167,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_function2(self) -> None:
+        source, expected = read_data("function2")
+        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_expression(self) -> None:
         source, expected = read_data("expression")
     @patch("black.dump_to_file", dump_to_stderr)
     def test_expression(self) -> None:
         source, expected = read_data("expression")
@@ -199,7 +207,7 @@ class BlackTestCase(unittest.TestCase):
             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()
-            actual = actual.replace(tmp_file.name, "<stdin>")
+            actual = actual.replace(str(tmp_file), "<stdin>")
         finally:
             sys.stdout = hold_stdout
             os.unlink(tmp_file)
         finally:
             sys.stdout = hold_stdout
             os.unlink(tmp_file)
@@ -229,6 +237,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_slices(self) -> None:
+        source, expected = read_data("slices")
+        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_comments(self) -> None:
         source, expected = read_data("comments")
     @patch("black.dump_to_file", dump_to_stderr)
     def test_comments(self) -> None:
         source, expected = read_data("comments")
@@ -261,6 +277,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_comments5(self) -> None:
+        source, expected = read_data("comments5")
+        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_cantfit(self) -> None:
         source, expected = read_data("cantfit")
     @patch("black.dump_to_file", dump_to_stderr)
     def test_cantfit(self) -> None:
         source, expected = read_data("cantfit")
@@ -293,6 +317,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_string_prefixes(self) -> None:
+        source, expected = read_data("string_prefixes")
+        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_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")
@@ -301,6 +333,13 @@ 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_python2_unicode_literals(self) -> None:
+        source, expected = read_data("python2_unicode_literals")
+        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_fmtonoff(self) -> None:
         source, expected = read_data("fmtonoff")
     @patch("black.dump_to_file", dump_to_stderr)
     def test_fmtonoff(self) -> None:
         source, expected = read_data("fmtonoff")
@@ -309,6 +348,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_remove_empty_parentheses_after_class(self) -> None:
+        source, expected = read_data("class_blank_parentheses")
+        actual = fs(source)
+        self.assertFormatEqual(expected, actual)
+        black.assert_equivalent(source, actual)
+        black.assert_stable(source, actual, line_length=ll)
+
     def test_report(self) -> None:
         report = black.Report()
         out_lines = []
     def test_report(self) -> None:
         report = black.Report()
         out_lines = []
@@ -412,6 +459,28 @@ class BlackTestCase(unittest.TestCase):
         node = black.lib2to3_parse(expected)
         self.assertFalse(black.is_python36(node))
 
         node = black.lib2to3_parse(expected)
         self.assertFalse(black.is_python36(node))
 
+    def test_get_future_imports(self) -> None:
+        node = black.lib2to3_parse("\n")
+        self.assertEqual(set(), black.get_future_imports(node))
+        node = black.lib2to3_parse("from __future__ import black\n")
+        self.assertEqual({"black"}, black.get_future_imports(node))
+        node = black.lib2to3_parse("from __future__ import multiple, imports\n")
+        self.assertEqual({"multiple", "imports"}, black.get_future_imports(node))
+        node = black.lib2to3_parse("from __future__ import (parenthesized, imports)\n")
+        self.assertEqual({"parenthesized", "imports"}, black.get_future_imports(node))
+        node = black.lib2to3_parse(
+            "from __future__ import multiple\nfrom __future__ import imports\n"
+        )
+        self.assertEqual({"multiple", "imports"}, black.get_future_imports(node))
+        node = black.lib2to3_parse("# comment\nfrom __future__ import black\n")
+        self.assertEqual({"black"}, black.get_future_imports(node))
+        node = black.lib2to3_parse('"""docstring"""\nfrom __future__ import black\n')
+        self.assertEqual({"black"}, black.get_future_imports(node))
+        node = black.lib2to3_parse("some(other, code)\nfrom __future__ import black\n")
+        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))
+
     def test_debug_visitor(self) -> None:
         source, _ = read_data("debug_visitor.py")
         expected, _ = read_data("debug_visitor.out")
     def test_debug_visitor(self) -> None:
         source, _ = read_data("debug_visitor.py")
         expected, _ = read_data("debug_visitor.out")
@@ -483,15 +552,16 @@ class BlackTestCase(unittest.TestCase):
 
     def test_cache_broken_file(self) -> None:
         with cache_dir() as workspace:
 
     def test_cache_broken_file(self) -> None:
         with cache_dir() as workspace:
-            with black.CACHE_FILE.open("w") as fobj:
+            cache_file = black.get_cache_file(black.DEFAULT_LINE_LENGTH)
+            with cache_file.open("w") as fobj:
                 fobj.write("this is not a pickle")
                 fobj.write("this is not a pickle")
-            self.assertEqual(black.read_cache(), {})
+            self.assertEqual(black.read_cache(black.DEFAULT_LINE_LENGTH), {})
             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")
             result = CliRunner().invoke(black.main, [str(src)])
             self.assertEqual(result.exit_code, 0)
             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")
             result = CliRunner().invoke(black.main, [str(src)])
             self.assertEqual(result.exit_code, 0)
-            cache = black.read_cache()
+            cache = black.read_cache(black.DEFAULT_LINE_LENGTH)
             self.assertIn(src, cache)
 
     def test_cache_single_file_already_cached(self) -> None:
             self.assertIn(src, cache)
 
     def test_cache_single_file_already_cached(self) -> None:
@@ -499,7 +569,7 @@ class BlackTestCase(unittest.TestCase):
             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")
             src = (workspace / "test.py").resolve()
             with src.open("w") as fobj:
                 fobj.write("print('hello')")
-            black.write_cache({}, [src])
+            black.write_cache({}, [src], black.DEFAULT_LINE_LENGTH)
             result = CliRunner().invoke(black.main, [str(src)])
             self.assertEqual(result.exit_code, 0)
             with src.open("r") as fobj:
             result = CliRunner().invoke(black.main, [str(src)])
             self.assertEqual(result.exit_code, 0)
             with src.open("r") as fobj:
@@ -507,21 +577,23 @@ class BlackTestCase(unittest.TestCase):
 
     @event_loop(close=False)
     def test_cache_multiple_files(self) -> None:
 
     @event_loop(close=False)
     def test_cache_multiple_files(self) -> None:
-        with cache_dir() as workspace:
+        with cache_dir() as workspace, patch(
+            "black.ProcessPoolExecutor", new=ThreadPoolExecutor
+        ):
             one = (workspace / "one.py").resolve()
             with one.open("w") as fobj:
                 fobj.write("print('hello')")
             two = (workspace / "two.py").resolve()
             with two.open("w") as fobj:
                 fobj.write("print('hello')")
             one = (workspace / "one.py").resolve()
             with one.open("w") as fobj:
                 fobj.write("print('hello')")
             two = (workspace / "two.py").resolve()
             with two.open("w") as fobj:
                 fobj.write("print('hello')")
-            black.write_cache({}, [one])
+            black.write_cache({}, [one], black.DEFAULT_LINE_LENGTH)
             result = CliRunner().invoke(black.main, [str(workspace)])
             self.assertEqual(result.exit_code, 0)
             with one.open("r") as fobj:
                 self.assertEqual(fobj.read(), "print('hello')")
             with two.open("r") as fobj:
                 self.assertEqual(fobj.read(), 'print("hello")\n')
             result = CliRunner().invoke(black.main, [str(workspace)])
             self.assertEqual(result.exit_code, 0)
             with one.open("r") as fobj:
                 self.assertEqual(fobj.read(), "print('hello')")
             with two.open("r") as fobj:
                 self.assertEqual(fobj.read(), 'print("hello")\n')
-            cache = black.read_cache()
+            cache = black.read_cache(black.DEFAULT_LINE_LENGTH)
             self.assertIn(one, cache)
             self.assertIn(two, cache)
 
             self.assertIn(one, cache)
             self.assertIn(two, cache)
 
@@ -532,24 +604,26 @@ class BlackTestCase(unittest.TestCase):
                 fobj.write("print('hello')")
             result = CliRunner().invoke(black.main, [str(src), "--diff"])
             self.assertEqual(result.exit_code, 0)
                 fobj.write("print('hello')")
             result = CliRunner().invoke(black.main, [str(src), "--diff"])
             self.assertEqual(result.exit_code, 0)
-            self.assertFalse(black.CACHE_FILE.exists())
+            cache_file = black.get_cache_file(black.DEFAULT_LINE_LENGTH)
+            self.assertFalse(cache_file.exists())
 
     def test_no_cache_when_stdin(self) -> None:
         with cache_dir():
             result = CliRunner().invoke(black.main, ["-"], input="print('hello')")
             self.assertEqual(result.exit_code, 0)
 
     def test_no_cache_when_stdin(self) -> None:
         with cache_dir():
             result = CliRunner().invoke(black.main, ["-"], input="print('hello')")
             self.assertEqual(result.exit_code, 0)
-            self.assertFalse(black.CACHE_FILE.exists())
+            cache_file = black.get_cache_file(black.DEFAULT_LINE_LENGTH)
+            self.assertFalse(cache_file.exists())
 
     def test_read_cache_no_cachefile(self) -> None:
         with cache_dir():
 
     def test_read_cache_no_cachefile(self) -> None:
         with cache_dir():
-            self.assertEqual(black.read_cache(), {})
+            self.assertEqual(black.read_cache(black.DEFAULT_LINE_LENGTH), {})
 
     def test_write_cache_read_cache(self) -> None:
         with cache_dir() as workspace:
             src = (workspace / "test.py").resolve()
             src.touch()
 
     def test_write_cache_read_cache(self) -> None:
         with cache_dir() as workspace:
             src = (workspace / "test.py").resolve()
             src.touch()
-            black.write_cache({}, [src])
-            cache = black.read_cache()
+            black.write_cache({}, [src], black.DEFAULT_LINE_LENGTH)
+            cache = black.read_cache(black.DEFAULT_LINE_LENGTH)
             self.assertIn(src, cache)
             self.assertEqual(cache[src], black.get_cache_info(src))
 
             self.assertIn(src, cache)
             self.assertEqual(cache[src], black.get_cache_info(src))
 
@@ -572,12 +646,14 @@ class BlackTestCase(unittest.TestCase):
     def test_write_cache_creates_directory_if_needed(self) -> None:
         with cache_dir(exists=False) as workspace:
             self.assertFalse(workspace.exists())
     def test_write_cache_creates_directory_if_needed(self) -> None:
         with cache_dir(exists=False) as workspace:
             self.assertFalse(workspace.exists())
-            black.write_cache({}, [])
+            black.write_cache({}, [], black.DEFAULT_LINE_LENGTH)
             self.assertTrue(workspace.exists())
 
     @event_loop(close=False)
     def test_failed_formatting_does_not_get_cached(self) -> None:
             self.assertTrue(workspace.exists())
 
     @event_loop(close=False)
     def test_failed_formatting_does_not_get_cached(self) -> None:
-        with cache_dir() as workspace:
+        with cache_dir() as workspace, patch(
+            "black.ProcessPoolExecutor", new=ThreadPoolExecutor
+        ):
             failing = (workspace / "failing.py").resolve()
             with failing.open("w") as fobj:
                 fobj.write("not actually python")
             failing = (workspace / "failing.py").resolve()
             with failing.open("w") as fobj:
                 fobj.write("not actually python")
@@ -586,14 +662,55 @@ class BlackTestCase(unittest.TestCase):
                 fobj.write('print("hello")\n')
             result = CliRunner().invoke(black.main, [str(workspace)])
             self.assertEqual(result.exit_code, 123)
                 fobj.write('print("hello")\n')
             result = CliRunner().invoke(black.main, [str(workspace)])
             self.assertEqual(result.exit_code, 123)
-            cache = black.read_cache()
+            cache = black.read_cache(black.DEFAULT_LINE_LENGTH)
             self.assertNotIn(failing, cache)
             self.assertIn(clean, cache)
 
     def test_write_cache_write_fail(self) -> None:
         with cache_dir(), patch.object(Path, "open") as mock:
             mock.side_effect = OSError
             self.assertNotIn(failing, cache)
             self.assertIn(clean, cache)
 
     def test_write_cache_write_fail(self) -> None:
         with cache_dir(), patch.object(Path, "open") as mock:
             mock.side_effect = OSError
-            black.write_cache({}, [])
+            black.write_cache({}, [], black.DEFAULT_LINE_LENGTH)
+
+    def test_check_diff_use_together(self) -> None:
+        with cache_dir():
+            # Files which will be reformatted.
+            src1 = (THIS_DIR / "string_quotes.py").resolve()
+            result = CliRunner().invoke(black.main, [str(src1), "--diff", "--check"])
+            self.assertEqual(result.exit_code, 1)
+
+            # Files which will not be reformatted.
+            src2 = (THIS_DIR / "composition.py").resolve()
+            result = CliRunner().invoke(black.main, [str(src2), "--diff", "--check"])
+            self.assertEqual(result.exit_code, 0)
+
+            # Multi file command.
+            result = CliRunner().invoke(
+                black.main, [str(src1), str(src2), "--diff", "--check"]
+            )
+            self.assertEqual(result.exit_code, 1)
+
+    def test_no_files(self) -> None:
+        with cache_dir():
+            # Without an argument, black exits with error code 0.
+            result = CliRunner().invoke(black.main, [])
+            self.assertEqual(result.exit_code, 0)
+
+    def test_broken_symlink(self) -> None:
+        with cache_dir() as workspace:
+            symlink = workspace / "broken_link.py"
+            symlink.symlink_to("nonexistent.py")
+            result = CliRunner().invoke(black.main, [str(workspace.resolve())])
+            self.assertEqual(result.exit_code, 0)
+
+    def test_read_cache_line_lengths(self) -> None:
+        with cache_dir() as workspace:
+            path = (workspace / "file.py").resolve()
+            path.touch()
+            black.write_cache({}, [path], 1)
+            one = black.read_cache(1)
+            self.assertIn(path, one)
+            two = black.read_cache(2)
+            self.assertNotIn(path, two)
 
 
 if __name__ == "__main__":
 
 
 if __name__ == "__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.