]> 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
Automatic management of parentheses in `elif`, too
[etc/vim.git] / tests / test_black.py
diff --git a/tests/test_black.py b/tests/test_black.py
index b4820531fab62d860808b37448881ccf3b494a78..5b84c3ce0a143a1afe7d3ea077d063402d7462d6 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")
@@ -309,6 +333,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 = []
@@ -483,15 +515,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 +532,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 +540,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 +567,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 +609,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 +625,14 @@ 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():
 
     def test_check_diff_use_together(self) -> None:
         with cache_dir():
@@ -613,6 +652,22 @@ class BlackTestCase(unittest.TestCase):
             )
             self.assertEqual(result.exit_code, 1)
 
             )
             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_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__":
     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.