tests/test_blackd.py

   1 import re
   2 from unittest.mock import patch
   3
   4 from click.testing import CliRunner
   5 import pytest
   6
   7 from tests.util import read_data, DETERMINISTIC_HEADER
   8
   9 try:
  10     import blackd
  11     from aiohttp.test_utils import AioHTTPTestCase, unittest_run_loop
  12     from aiohttp import web
  13 except ImportError:
  14     has_blackd_deps = False
  15 else:
  16     has_blackd_deps = True
  17
  18
  19 @pytest.mark.blackd
  20 class BlackDTestCase(AioHTTPTestCase):
  21     def test_blackd_main(self) -> None:
  22         with patch("blackd.web.run_app"):
  23             result = CliRunner().invoke(blackd.main, [])
  24             if result.exception is not None:
  25                 raise result.exception
  26             self.assertEqual(result.exit_code, 0)
  27
  28     async def get_application(self) -> web.Application:
  29         return blackd.make_app()
  30
  31     @unittest_run_loop
  32     async def test_blackd_request_needs_formatting(self) -> None:
  33         response = await self.client.post("/", data=b"print('hello world')")
  34         self.assertEqual(response.status, 200)
  35         self.assertEqual(response.charset, "utf8")
  36         self.assertEqual(await response.read(), b'print("hello world")\n')
  37
  38     @unittest_run_loop
  39     async def test_blackd_request_no_change(self) -> None:
  40         response = await self.client.post("/", data=b'print("hello world")\n')
  41         self.assertEqual(response.status, 204)
  42         self.assertEqual(await response.read(), b"")
  43
  44     @unittest_run_loop
  45     async def test_blackd_request_syntax_error(self) -> None:
  46         response = await self.client.post("/", data=b"what even ( is")
  47         self.assertEqual(response.status, 400)
  48         content = await response.text()
  49         self.assertTrue(
  50             content.startswith("Cannot parse"),
  51             msg=f"Expected error to start with 'Cannot parse', got {repr(content)}",
  52         )
  53
  54     @unittest_run_loop
  55     async def test_blackd_unsupported_version(self) -> None:
  56         response = await self.client.post(
  57             "/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "2"}
  58         )
  59         self.assertEqual(response.status, 501)
  60
  61     @unittest_run_loop
  62     async def test_blackd_supported_version(self) -> None:
  63         response = await self.client.post(
  64             "/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "1"}
  65         )
  66         self.assertEqual(response.status, 200)
  67
  68     @unittest_run_loop
  69     async def test_blackd_invalid_python_variant(self) -> None:
  70         async def check(header_value: str, expected_status: int = 400) -> None:
  71             response = await self.client.post(
  72                 "/", data=b"what", headers={blackd.PYTHON_VARIANT_HEADER: header_value}
  73             )
  74             self.assertEqual(response.status, expected_status)
  75
  76         await check("lol")
  77         await check("ruby3.5")
  78         await check("pyi3.6")
  79         await check("py1.5")
  80         await check("2")
  81         await check("2.7")
  82         await check("py2.7")
  83         await check("2.8")
  84         await check("py2.8")
  85         await check("3.0")
  86         await check("pypy3.0")
  87         await check("jython3.4")
  88
  89     @unittest_run_loop
  90     async def test_blackd_pyi(self) -> None:
  91         source, expected = read_data("stub.pyi")
  92         response = await self.client.post(
  93             "/", data=source, headers={blackd.PYTHON_VARIANT_HEADER: "pyi"}
  94         )
  95         self.assertEqual(response.status, 200)
  96         self.assertEqual(await response.text(), expected)
  97
  98     @unittest_run_loop
  99     async def test_blackd_diff(self) -> None:
 100         diff_header = re.compile(
 101             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"
 102         )
 103
 104         source, _ = read_data("blackd_diff.py")
 105         expected, _ = read_data("blackd_diff.diff")
 106
 107         response = await self.client.post(
 108             "/", data=source, headers={blackd.DIFF_HEADER: "true"}
 109         )
 110         self.assertEqual(response.status, 200)
 111
 112         actual = await response.text()
 113         actual = diff_header.sub(DETERMINISTIC_HEADER, actual)
 114         self.assertEqual(actual, expected)
 115
 116     @unittest_run_loop
 117     async def test_blackd_python_variant(self) -> None:
 118         code = (
 119             "def f(\n"
 120             "    and_has_a_bunch_of,\n"
 121             "    very_long_arguments_too,\n"
 122             "    and_lots_of_them_as_well_lol,\n"
 123             "    **and_very_long_keyword_arguments\n"
 124             "):\n"
 125             "    pass\n"
 126         )
 127
 128         async def check(header_value: str, expected_status: int) -> None:
 129             response = await self.client.post(
 130                 "/", data=code, headers={blackd.PYTHON_VARIANT_HEADER: header_value}
 131             )
 132             self.assertEqual(
 133                 response.status, expected_status, msg=await response.text()
 134             )
 135
 136         await check("3.6", 200)
 137         await check("py3.6", 200)
 138         await check("3.6,3.7", 200)
 139         await check("3.6,py3.7", 200)
 140         await check("py36,py37", 200)
 141         await check("36", 200)
 142         await check("3.6.4", 200)
 143         await check("3.4", 204)
 144         await check("py3.4", 204)
 145         await check("py34,py36", 204)
 146         await check("34", 204)
 147
 148     @unittest_run_loop
 149     async def test_blackd_line_length(self) -> None:
 150         response = await self.client.post(
 151             "/", data=b'print("hello")\n', headers={blackd.LINE_LENGTH_HEADER: "7"}
 152         )
 153         self.assertEqual(response.status, 200)
 154
 155     @unittest_run_loop
 156     async def test_blackd_invalid_line_length(self) -> None:
 157         response = await self.client.post(
 158             "/", data=b'print("hello")\n', headers={blackd.LINE_LENGTH_HEADER: "NaN"}
 159         )
 160         self.assertEqual(response.status, 400)
 161
 162     @unittest_run_loop
 163     async def test_blackd_response_black_version_header(self) -> None:
 164         response = await self.client.post("/")
 165         self.assertIsNotNone(response.headers.get(blackd.BLACK_VERSION_HEADER))
 166
 167     @unittest_run_loop
 168     async def test_cors_preflight(self) -> None:
 169         response = await self.client.options(
 170             "/",
 171             headers={
 172                 "Access-Control-Request-Method": "POST",
 173                 "Origin": "*",
 174                 "Access-Control-Request-Headers": "Content-Type",
 175             },
 176         )
 177         self.assertEqual(response.status, 200)
 178         self.assertIsNotNone(response.headers.get("Access-Control-Allow-Origin"))
 179         self.assertIsNotNone(response.headers.get("Access-Control-Allow-Headers"))
 180         self.assertIsNotNone(response.headers.get("Access-Control-Allow-Methods"))
 181
 182     @unittest_run_loop
 183     async def test_cors_headers_present(self) -> None:
 184         response = await self.client.post("/", headers={"Origin": "*"})
 185         self.assertIsNotNone(response.headers.get("Access-Control-Allow-Origin"))
 186         self.assertIsNotNone(response.headers.get("Access-Control-Expose-Headers"))