fix appveyor deploy section

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

diff --git a/tests/test_black.py b/tests/test_black.py
index 5532fc563d328d18cf012770e2d38f7567bf3b45..645eec7ae787afd7e66797bdcec65ae8cd4c91c7 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

+import logging

 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager, redirect_stderr
 from functools import partial, wraps
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager, redirect_stderr
 from functools import partial, wraps


@@ -37,12 +38,14 @@ except ImportError:
 else:
     has_blackd_deps = True
 
 else:
     has_blackd_deps = True
 

-

 ff = partial(black.format_file_in_place, mode=black.FileMode(), fast=True)
 fs = partial(black.format_str, mode=black.FileMode())
 THIS_FILE = Path(__file__)
 THIS_DIR = THIS_FILE.parent
 EMPTY_LINE = "# EMPTY LINE WITH WHITESPACE" + " (this comment will be removed)"
 ff = partial(black.format_file_in_place, mode=black.FileMode(), fast=True)
 fs = partial(black.format_str, mode=black.FileMode())
 THIS_FILE = Path(__file__)
 THIS_DIR = THIS_FILE.parent
 EMPTY_LINE = "# EMPTY LINE WITH WHITESPACE" + " (this comment will be removed)"

+PY36_ARGS = [
+    f"--target-version={version.name.lower()}" for version in black.PY36_VERSIONS
+]

 T = TypeVar("T")
 R = TypeVar("R")
 
 T = TypeVar("T")
 R = TypeVar("R")
 


@@ -437,9 +440,7 @@ class BlackTestCase(unittest.TestCase):
     @patch("black.dump_to_file", dump_to_stderr)
     def test_numeric_literals_ignoring_underscores(self) -> None:
         source, expected = read_data("numeric_literals_skip_underscores")
     @patch("black.dump_to_file", dump_to_stderr)
     def test_numeric_literals_ignoring_underscores(self) -> None:
         source, expected = read_data("numeric_literals_skip_underscores")

-        mode = black.FileMode(
-            numeric_underscore_normalization=False, target_versions=black.PY36_VERSIONS
-        )
+        mode = black.FileMode(target_versions=black.PY36_VERSIONS)

         actual = fs(source, mode=mode)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)
         actual = fs(source, mode=mode)
         self.assertFormatEqual(expected, actual)
         black.assert_equivalent(source, actual)


@@ -460,6 +461,14 @@ class BlackTestCase(unittest.TestCase):
         # black.assert_equivalent(source, actual)
         black.assert_stable(source, actual, black.FileMode())
 
         # black.assert_equivalent(source, actual)
         black.assert_stable(source, actual, black.FileMode())
 

+    @patch("black.dump_to_file", dump_to_stderr)
+    def test_python2_print_function(self) -> None:
+        source, expected = read_data("python2_print_function")
+        mode = black.FileMode(target_versions={black.TargetVersion.PY27})
+        actual = fs(source, mode=mode)
+        self.assertFormatEqual(expected, actual)
+        black.assert_stable(source, actual, mode)
+

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


@@ -525,18 +534,27 @@ class BlackTestCase(unittest.TestCase):
         black.assert_equivalent(source, actual)
         black.assert_stable(source, actual, black.FileMode())
 
         black.assert_equivalent(source, actual)
         black.assert_stable(source, actual, black.FileMode())
 

-    def test_comment_indentation(self) -> None:
+    def test_tab_comment_indentation(self) -> None:

         contents_tab = "if 1:\n\tif 2:\n\t\tpass\n\t# comment\n\tpass\n"
         contents_spc = "if 1:\n    if 2:\n        pass\n    # comment\n    pass\n"
         contents_tab = "if 1:\n\tif 2:\n\t\tpass\n\t# comment\n\tpass\n"
         contents_spc = "if 1:\n    if 2:\n        pass\n    # comment\n    pass\n"

-
-        self.assertFormatEqual(fs(contents_spc), contents_spc)
-        self.assertFormatEqual(fs(contents_tab), contents_spc)
+        self.assertFormatEqual(contents_spc, fs(contents_spc))
+        self.assertFormatEqual(contents_spc, fs(contents_tab))

 
         contents_tab = "if 1:\n\tif 2:\n\t\tpass\n\t\t# comment\n\tpass\n"
         contents_spc = "if 1:\n    if 2:\n        pass\n        # comment\n    pass\n"
 
         contents_tab = "if 1:\n\tif 2:\n\t\tpass\n\t\t# comment\n\tpass\n"
         contents_spc = "if 1:\n    if 2:\n        pass\n        # comment\n    pass\n"

+        self.assertFormatEqual(contents_spc, fs(contents_spc))
+        self.assertFormatEqual(contents_spc, fs(contents_tab))

 
 

-        self.assertFormatEqual(fs(contents_tab), contents_spc)
-        self.assertFormatEqual(fs(contents_spc), contents_spc)
+        # mixed tabs and spaces (valid Python 2 code)
+        contents_tab = "if 1:\n        if 2:\n\t\tpass\n\t# comment\n        pass\n"
+        contents_spc = "if 1:\n    if 2:\n        pass\n    # comment\n    pass\n"
+        self.assertFormatEqual(contents_spc, fs(contents_spc))
+        self.assertFormatEqual(contents_spc, fs(contents_tab))
+
+        contents_tab = "if 1:\n        if 2:\n\t\tpass\n\t\t# comment\n        pass\n"
+        contents_spc = "if 1:\n    if 2:\n        pass\n        # comment\n    pass\n"
+        self.assertFormatEqual(contents_spc, fs(contents_spc))
+        self.assertFormatEqual(contents_spc, fs(contents_tab))

 
     def test_report_verbose(self) -> None:
         report = black.Report(verbose=True)
 
     def test_report_verbose(self) -> None:
         report = black.Report(verbose=True)


@@ -828,8 +846,7 @@ class BlackTestCase(unittest.TestCase):
         )
         node = black.lib2to3_parse(expected)
         self.assertEqual(
         )
         node = black.lib2to3_parse(expected)
         self.assertEqual(

-            black.get_features_used(node),
-            {Feature.TRAILING_COMMA, Feature.F_STRINGS, Feature.NUMERIC_UNDERSCORES},
+            black.get_features_used(node), {Feature.TRAILING_COMMA, Feature.F_STRINGS}

         )
         source, expected = read_data("expression")
         node = black.lib2to3_parse(source)
         )
         source, expected = read_data("expression")
         node = black.lib2to3_parse(source)


@@ -1163,10 +1180,10 @@ class BlackTestCase(unittest.TestCase):
             path = (workspace / "file.py").resolve()
             with open(path, "w") as fh:
                 fh.write(source)
             path = (workspace / "file.py").resolve()
             with open(path, "w") as fh:
                 fh.write(source)

-            self.invokeBlack([str(path), "--py36"])
+            self.invokeBlack([str(path), *PY36_ARGS])

             with open(path, "r") as fh:
                 actual = fh.read()
             with open(path, "r") as fh:
                 actual = fh.read()

-            # verify cache with --py36 is separate
+            # verify cache with --target-version is separate

             py36_cache = black.read_cache(py36_mode)
             self.assertIn(path, py36_cache)
             normal_cache = black.read_cache(reg_mode)
             py36_cache = black.read_cache(py36_mode)
             self.assertIn(path, py36_cache)
             normal_cache = black.read_cache(reg_mode)


@@ -1186,12 +1203,12 @@ class BlackTestCase(unittest.TestCase):
             for path in paths:
                 with open(path, "w") as fh:
                     fh.write(source)
             for path in paths:
                 with open(path, "w") as fh:
                     fh.write(source)

-            self.invokeBlack([str(p) for p in paths] + ["--py36"])
+            self.invokeBlack([str(p) for p in paths] + PY36_ARGS)

             for path in paths:
                 with open(path, "r") as fh:
                     actual = fh.read()
                 self.assertEqual(actual, expected)
             for path in paths:
                 with open(path, "r") as fh:
                     actual = fh.read()
                 self.assertEqual(actual, expected)

-            # verify cache with --py36 is separate
+            # verify cache with --target-version is separate

             pyi_cache = black.read_cache(py36_mode)
             normal_cache = black.read_cache(reg_mode)
             for path in paths:
             pyi_cache = black.read_cache(py36_mode)
             normal_cache = black.read_cache(reg_mode)
             for path in paths:


@@ -1201,7 +1218,9 @@ class BlackTestCase(unittest.TestCase):
     def test_pipe_force_py36(self) -> None:
         source, expected = read_data("force_py36")
         result = CliRunner().invoke(
     def test_pipe_force_py36(self) -> None:
         source, expected = read_data("force_py36")
         result = CliRunner().invoke(

-            black.main, ["-", "-q", "--py36"], input=BytesIO(source.encode("utf8"))
+            black.main,
+            ["-", "-q", "--target-version=py36"],
+            input=BytesIO(source.encode("utf8")),

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


@@ -1354,6 +1373,21 @@ class BlackTestCase(unittest.TestCase):
             except RuntimeError as re:
                 self.fail(f"`patch_click()` failed, exception still raised: {re}")
 
             except RuntimeError as re:
                 self.fail(f"`patch_click()` failed, exception still raised: {re}")
 

+    def test_root_logger_not_used_directly(self) -> None:
+        def fail(*args: Any, **kwargs: Any) -> None:
+            self.fail("Record created with root logger")
+
+        with patch.multiple(
+            logging.root,
+            debug=fail,
+            info=fail,
+            warning=fail,
+            error=fail,
+            critical=fail,
+            log=fail,
+        ):
+            ff(THIS_FILE)
+

     @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
     @async_test
     async def test_blackd_request_needs_formatting(self) -> None:
     @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
     @async_test
     async def test_blackd_request_needs_formatting(self) -> None:


@@ -1423,9 +1457,9 @@ class BlackTestCase(unittest.TestCase):
             await check("lol")
             await check("ruby3.5")
             await check("pyi3.6")
             await check("lol")
             await check("ruby3.5")
             await check("pyi3.6")

-            await check("cpy1.5")
+            await check("py1.5")

             await check("2.8")
             await check("2.8")

-            await check("cpy2.8")
+            await check("py2.8")

             await check("3.0")
             await check("pypy3.0")
             await check("jython3.4")
             await check("3.0")
             await check("pypy3.0")
             await check("jython3.4")


@@ -1464,17 +1498,15 @@ class BlackTestCase(unittest.TestCase):
                 self.assertEqual(response.status, expected_status)
 
             await check("3.6", 200)
                 self.assertEqual(response.status, expected_status)
 
             await check("3.6", 200)

-            await check("cpy3.6", 200)
+            await check("py3.6", 200)

             await check("3.5,3.7", 200)
             await check("3.5,3.7", 200)

-            await check("3.5,cpy3.7", 200)
+            await check("3.5,py3.7", 200)

 
             await check("2", 204)
             await check("2.7", 204)
 
             await check("2", 204)
             await check("2.7", 204)

-            await check("cpy2.7", 204)
-            await check("pypy2.7", 204)
+            await check("py2.7", 204)

             await check("3.4", 204)
             await check("3.4", 204)

-            await check("cpy3.4", 204)
-            await check("pypy3.4", 204)
+            await check("py3.4", 204)

 
     @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
     @async_test
 
     @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
     @async_test