Document each configuration option in more detail (#2839)

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

diff --git a/tests/test_blackd.py b/tests/test_blackd.py
index 9127297c54fc08c86ef93dc4120401229767f312..5b6461f76859e69ddce3e5091a14ccc6cfc9c989 100644 (file)
--- a/tests/test_blackd.py
+++ b/tests/test_blackd.py
@@ -1,23 +1,37 @@
 import re
 import re

-import unittest
+from typing import TYPE_CHECKING, Any, Callable, TypeVar

 from unittest.mock import patch
 
 from unittest.mock import patch
 

+import pytest

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

-from tests.util import read_data, DETERMINISTIC_HEADER, skip_if_exception
+from tests.util import DETERMINISTIC_HEADER, read_data

 
 try:
 
 try:

-    import blackd
-    from aiohttp.test_utils import AioHTTPTestCase, unittest_run_loop

     from aiohttp import web
     from aiohttp import web

-except ImportError:
-    has_blackd_deps = False
-else:
-    has_blackd_deps = True
+    from aiohttp.test_utils import AioHTTPTestCase
+
+    import blackd
+except ImportError as e:
+    raise RuntimeError("Please install Black with the 'd' extra") from e

 
 

+if TYPE_CHECKING:
+    F = TypeVar("F", bound=Callable[..., Any])

 
 

-class BlackDTestCase(AioHTTPTestCase):
-    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    unittest_run_loop: Callable[[F], F] = lambda x: x
+else:
+    try:
+        from aiohttp.test_utils import unittest_run_loop
+    except ImportError:
+        # unittest_run_loop is unnecessary and a no-op since aiohttp 3.8, and
+        # aiohttp 4 removed it. To maintain compatibility we can make our own
+        # no-op decorator.
+        def unittest_run_loop(func, *args, **kwargs):
+            return func
+
+
+@pytest.mark.blackd
+class BlackDTestCase(AioHTTPTestCase):  # type: ignore[misc]

     def test_blackd_main(self) -> None:
         with patch("blackd.web.run_app"):
             result = CliRunner().invoke(blackd.main, [])
     def test_blackd_main(self) -> None:
         with patch("blackd.web.run_app"):
             result = CliRunner().invoke(blackd.main, [])


@@ -28,10 +42,6 @@ class BlackDTestCase(AioHTTPTestCase):
     async def get_application(self) -> web.Application:
         return blackd.make_app()
 
     async def get_application(self) -> web.Application:
         return blackd.make_app()
 

-    # TODO: remove these decorators once the below is released
-    # https://github.com/aio-libs/aiohttp/pull/3727
-    @skip_if_exception("ClientOSError")
-    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")

     @unittest_run_loop
     async def test_blackd_request_needs_formatting(self) -> None:
         response = await self.client.post("/", data=b"print('hello world')")
     @unittest_run_loop
     async def test_blackd_request_needs_formatting(self) -> None:
         response = await self.client.post("/", data=b"print('hello world')")


@@ -39,16 +49,12 @@ class BlackDTestCase(AioHTTPTestCase):
         self.assertEqual(response.charset, "utf8")
         self.assertEqual(await response.read(), b'print("hello world")\n')
 
         self.assertEqual(response.charset, "utf8")
         self.assertEqual(await response.read(), b'print("hello world")\n')
 

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

     @unittest_run_loop
     async def test_blackd_request_no_change(self) -> None:
         response = await self.client.post("/", data=b'print("hello world")\n')
         self.assertEqual(response.status, 204)
         self.assertEqual(await response.read(), b"")
 
     @unittest_run_loop
     async def test_blackd_request_no_change(self) -> None:
         response = await self.client.post("/", data=b'print("hello world")\n')
         self.assertEqual(response.status, 204)
         self.assertEqual(await response.read(), b"")
 

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

     @unittest_run_loop
     async def test_blackd_request_syntax_error(self) -> None:
         response = await self.client.post("/", data=b"what even ( is")
     @unittest_run_loop
     async def test_blackd_request_syntax_error(self) -> None:
         response = await self.client.post("/", data=b"what even ( is")


@@ -59,8 +65,6 @@ class BlackDTestCase(AioHTTPTestCase):
             msg=f"Expected error to start with 'Cannot parse', got {repr(content)}",
         )
 
             msg=f"Expected error to start with 'Cannot parse', got {repr(content)}",
         )
 

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

     @unittest_run_loop
     async def test_blackd_unsupported_version(self) -> None:
         response = await self.client.post(
     @unittest_run_loop
     async def test_blackd_unsupported_version(self) -> None:
         response = await self.client.post(


@@ -68,8 +72,6 @@ class BlackDTestCase(AioHTTPTestCase):
         )
         self.assertEqual(response.status, 501)
 
         )
         self.assertEqual(response.status, 501)
 

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

     @unittest_run_loop
     async def test_blackd_supported_version(self) -> None:
         response = await self.client.post(
     @unittest_run_loop
     async def test_blackd_supported_version(self) -> None:
         response = await self.client.post(


@@ -77,13 +79,13 @@ class BlackDTestCase(AioHTTPTestCase):
         )
         self.assertEqual(response.status, 200)
 
         )
         self.assertEqual(response.status, 200)
 

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

     @unittest_run_loop
     async def test_blackd_invalid_python_variant(self) -> None:
         async def check(header_value: str, expected_status: int = 400) -> None:
             response = await self.client.post(
     @unittest_run_loop
     async def test_blackd_invalid_python_variant(self) -> None:
         async def check(header_value: str, expected_status: int = 400) -> None:
             response = await self.client.post(

-                "/", data=b"what", headers={blackd.PYTHON_VARIANT_HEADER: header_value}
+                "/",
+                data=b"what",
+                headers={blackd.PYTHON_VARIANT_HEADER: header_value},

             )
             self.assertEqual(response.status, expected_status)
 
             )
             self.assertEqual(response.status, expected_status)
 


@@ -91,33 +93,32 @@ class BlackDTestCase(AioHTTPTestCase):
         await check("ruby3.5")
         await check("pyi3.6")
         await check("py1.5")
         await check("ruby3.5")
         await check("pyi3.6")
         await check("py1.5")

+        await check("2")
+        await check("2.7")
+        await check("py2.7")

         await check("2.8")
         await check("py2.8")
         await check("3.0")
         await check("pypy3.0")
         await check("jython3.4")
 
         await check("2.8")
         await check("py2.8")
         await check("3.0")
         await check("pypy3.0")
         await check("jython3.4")
 

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

     @unittest_run_loop
     async def test_blackd_pyi(self) -> None:
     @unittest_run_loop
     async def test_blackd_pyi(self) -> None:

-        source, expected = read_data("stub.pyi")
+        source, expected = read_data("miscellaneous", "stub.pyi")

         response = await self.client.post(
             "/", data=source, headers={blackd.PYTHON_VARIANT_HEADER: "pyi"}
         )
         self.assertEqual(response.status, 200)
         self.assertEqual(await response.text(), expected)
 
         response = await self.client.post(
             "/", data=source, headers={blackd.PYTHON_VARIANT_HEADER: "pyi"}
         )
         self.assertEqual(response.status, 200)
         self.assertEqual(await response.text(), expected)
 

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

     @unittest_run_loop
     async def test_blackd_diff(self) -> None:
         diff_header = re.compile(
             r"(In|Out)\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d\d\d\d \+\d\d\d\d"
         )
 
     @unittest_run_loop
     async def test_blackd_diff(self) -> None:
         diff_header = re.compile(
             r"(In|Out)\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d\d\d\d \+\d\d\d\d"
         )
 

-        source, _ = read_data("blackd_diff.py")
-        expected, _ = read_data("blackd_diff.diff")
+        source, _ = read_data("miscellaneous", "blackd_diff")
+        expected, _ = read_data("miscellaneous", "blackd_diff.diff")

 
         response = await self.client.post(
             "/", data=source, headers={blackd.DIFF_HEADER: "true"}
 
         response = await self.client.post(
             "/", data=source, headers={blackd.DIFF_HEADER: "true"}


@@ -128,8 +129,6 @@ class BlackDTestCase(AioHTTPTestCase):
         actual = diff_header.sub(DETERMINISTIC_HEADER, actual)
         self.assertEqual(actual, expected)
 
         actual = diff_header.sub(DETERMINISTIC_HEADER, actual)
         self.assertEqual(actual, expected)
 

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

     @unittest_run_loop
     async def test_blackd_python_variant(self) -> None:
         code = (
     @unittest_run_loop
     async def test_blackd_python_variant(self) -> None:
         code = (


@@ -157,17 +156,11 @@ class BlackDTestCase(AioHTTPTestCase):
         await check("py36,py37", 200)
         await check("36", 200)
         await check("3.6.4", 200)
         await check("py36,py37", 200)
         await check("36", 200)
         await check("3.6.4", 200)

-
-        await check("2", 204)
-        await check("2.7", 204)
-        await check("py2.7", 204)

         await check("3.4", 204)
         await check("py3.4", 204)
         await check("py34,py36", 204)
         await check("34", 204)
 
         await check("3.4", 204)
         await check("py3.4", 204)
         await check("py34,py36", 204)
         await check("34", 204)
 

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

     @unittest_run_loop
     async def test_blackd_line_length(self) -> None:
         response = await self.client.post(
     @unittest_run_loop
     async def test_blackd_line_length(self) -> None:
         response = await self.client.post(


@@ -175,18 +168,75 @@ class BlackDTestCase(AioHTTPTestCase):
         )
         self.assertEqual(response.status, 200)
 
         )
         self.assertEqual(response.status, 200)
 

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

     @unittest_run_loop
     async def test_blackd_invalid_line_length(self) -> None:
         response = await self.client.post(
     @unittest_run_loop
     async def test_blackd_invalid_line_length(self) -> None:
         response = await self.client.post(

-            "/", data=b'print("hello")\n', headers={blackd.LINE_LENGTH_HEADER: "NaN"}
+            "/",
+            data=b'print("hello")\n',
+            headers={blackd.LINE_LENGTH_HEADER: "NaN"},

         )
         self.assertEqual(response.status, 400)
 
         )
         self.assertEqual(response.status, 400)
 

-    @skip_if_exception("ClientOSError")
-    @unittest.skipUnless(has_blackd_deps, "blackd's dependencies are not installed")
+    @unittest_run_loop
+    async def test_blackd_skip_first_source_line(self) -> None:
+        invalid_first_line = b"Header will be skipped\r\ni = [1,2,3]\nj = [1,2,3]\n"
+        expected_result = b"Header will be skipped\r\ni = [1, 2, 3]\nj = [1, 2, 3]\n"
+        response = await self.client.post("/", data=invalid_first_line)
+        self.assertEqual(response.status, 400)
+        response = await self.client.post(
+            "/",
+            data=invalid_first_line,
+            headers={blackd.SKIP_SOURCE_FIRST_LINE: "true"},
+        )
+        self.assertEqual(response.status, 200)
+        self.assertEqual(await response.read(), expected_result)
+
+    @unittest_run_loop
+    async def test_blackd_preview(self) -> None:
+        response = await self.client.post(
+            "/", data=b'print("hello")\n', headers={blackd.PREVIEW: "true"}
+        )
+        self.assertEqual(response.status, 204)
+

     @unittest_run_loop
     async def test_blackd_response_black_version_header(self) -> None:
         response = await self.client.post("/")
         self.assertIsNotNone(response.headers.get(blackd.BLACK_VERSION_HEADER))
     @unittest_run_loop
     async def test_blackd_response_black_version_header(self) -> None:
         response = await self.client.post("/")
         self.assertIsNotNone(response.headers.get(blackd.BLACK_VERSION_HEADER))

+
+    @unittest_run_loop
+    async def test_cors_preflight(self) -> None:
+        response = await self.client.options(
+            "/",
+            headers={
+                "Access-Control-Request-Method": "POST",
+                "Origin": "*",
+                "Access-Control-Request-Headers": "Content-Type",
+            },
+        )
+        self.assertEqual(response.status, 200)
+        self.assertIsNotNone(response.headers.get("Access-Control-Allow-Origin"))
+        self.assertIsNotNone(response.headers.get("Access-Control-Allow-Headers"))
+        self.assertIsNotNone(response.headers.get("Access-Control-Allow-Methods"))
+
+    @unittest_run_loop
+    async def test_cors_headers_present(self) -> None:
+        response = await self.client.post("/", headers={"Origin": "*"})
+        self.assertIsNotNone(response.headers.get("Access-Control-Allow-Origin"))
+        self.assertIsNotNone(response.headers.get("Access-Control-Expose-Headers"))
+
+    @unittest_run_loop
+    async def test_preserves_line_endings(self) -> None:
+        for data in (b"c\r\nc\r\n", b"l\nl\n"):
+            # test preserved newlines when reformatted
+            response = await self.client.post("/", data=data + b" ")
+            self.assertEqual(await response.text(), data.decode())
+            # test 204 when no change
+            response = await self.client.post("/", data=data)
+            self.assertEqual(response.status, 204)
+
+    @unittest_run_loop
+    async def test_normalizes_line_endings(self) -> None:
+        for data, expected in ((b"c\r\nc\n", "c\r\nc\r\n"), (b"l\nl\r\n", "l\nl\n")):
+            response = await self.client.post("/", data=data)
+            self.assertEqual(await response.text(), expected)
+            self.assertEqual(response.status, 200)