7692220850

Committed 29 Jan 2024 06:46AM UTC coverage: 96.45%. Remained the same

Build # 7692220850

Build Type

Pull #4192

github

Committed by

web-flow

Commit Message

Bump peter-evans/create-or-update-comment from 3.1.0 to 4.0.0

Bumps [peter-evans/create-or-update-comment](https://github.com/peter-evans/create-or-update-comment) from 3.1.0 to 4.0.0.
- [Release notes](https://github.com/peter-evans/create-or-update-comment/releases)
- [Commits](https://github.com/peter-evans/create-or-update-comment/compare/23ff15729...71345be02)

---
updated-dependencies:
- dependency-name: peter-evans/create-or-update-comment
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #4192: Bump peter-evans/create-or-update-comment from 3.1.0 to 4.0.0

Run Details

3021 of 3232 branches covered (0.0%)

7145 of 7408 relevant lines covered (96.45%)

4.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.0

/tests/test_blackd.py

import re
from typing import TYPE_CHECKING, Any, Callable, TypeVar
from unittest.mock import patch

import pytest
from click.testing import CliRunner

from tests.util import DETERMINISTIC_HEADER, read_data

try:
    from aiohttp import web
    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])

    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):
    def test_blackd_main(self) -> None:
        with patch("blackd.web.run_app"):
            result = CliRunner().invoke(blackd.main, [])
            if result.exception is not None:
                raise result.exception
            self.assertEqual(result.exit_code, 0)

    async def get_application(self) -> web.Application:
        return blackd.make_app()

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

    @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_syntax_error(self) -> None:
        response = await self.client.post("/", data=b"what even ( is")
        self.assertEqual(response.status, 400)
        content = await response.text()
        self.assertTrue(
            content.startswith("Cannot parse"),
            msg=f"Expected error to start with 'Cannot parse', got {repr(content)}",
        )

    @unittest_run_loop
    async def test_blackd_unsupported_version(self) -> None:
        response = await self.client.post(
            "/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "2"}
        )
        self.assertEqual(response.status, 501)

    @unittest_run_loop
    async def test_blackd_supported_version(self) -> None:
        response = await self.client.post(
            "/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "1"}
        )
        self.assertEqual(response.status, 200)

    @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},
            )
            self.assertEqual(response.status, expected_status)

        await check("lol")
        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")

    @unittest_run_loop
    async def test_blackd_pyi(self) -> None:
        source, expected = read_data("cases", "stub.py")
        response = await self.client.post(
            "/", data=source, headers={blackd.PYTHON_VARIANT_HEADER: "pyi"}
        )
        self.assertEqual(response.status, 200)
        self.assertEqual(await response.text(), expected)

    @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("miscellaneous", "blackd_diff")
        expected, _ = read_data("miscellaneous", "blackd_diff.diff")

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

        actual = await response.text()
        actual = diff_header.sub(DETERMINISTIC_HEADER, actual)
        self.assertEqual(actual, expected)

    @unittest_run_loop
    async def test_blackd_python_variant(self) -> None:
        code = (
            "def f(\n"
            "    and_has_a_bunch_of,\n"
            "    very_long_arguments_too,\n"
            "    and_lots_of_them_as_well_lol,\n"
            "    **and_very_long_keyword_arguments\n"
            "):\n"
            "    pass\n"
        )

        async def check(header_value: str, expected_status: int) -> None:
            response = await self.client.post(
                "/", data=code, headers={blackd.PYTHON_VARIANT_HEADER: header_value}
            )
            self.assertEqual(
                response.status, expected_status, msg=await response.text()
            )

        await check("3.6", 200)
        await check("py3.6", 200)
        await check("3.6,3.7", 200)
        await check("3.6,py3.7", 200)
        await check("py36,py37", 200)
        await check("36", 200)
        await check("3.6.4", 200)
        await check("3.4", 204)
        await check("py3.4", 204)
        await check("py34,py36", 204)
        await check("34", 204)

    @unittest_run_loop
    async def test_blackd_line_length(self) -> None:
        response = await self.client.post(
            "/", data=b'print("hello")\n', headers={blackd.LINE_LENGTH_HEADER: "7"}
        )
        self.assertEqual(response.status, 200)

    @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"},
        )
        self.assertEqual(response.status, 400)

    @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_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)

    @unittest_run_loop
    async def test_single_character(self) -> None:
        response = await self.client.post("/", data="1")
        self.assertEqual(await response.text(), "1\n")
        self.assertEqual(response.status, 200)

1	import re	5✔
2	from typing import TYPE_CHECKING, Any, Callable, TypeVar	5✔
3	from unittest.mock import patch	5✔
4
5	import pytest	5✔
6	from click.testing import CliRunner	5✔
7
8	from tests.util import DETERMINISTIC_HEADER, read_data	5✔
9
10	try:	5✔
11	from aiohttp import web	5✔
12	from aiohttp.test_utils import AioHTTPTestCase	5✔
13
14	import blackd	5✔
15	except ImportError as e:	×
16	raise RuntimeError("Please install Black with the 'd' extra") from e	×
17
18	if TYPE_CHECKING:	5!
19	F = TypeVar("F", bound=Callable[..., Any])	×
20
21	unittest_run_loop: Callable[[F], F] = lambda x: x	×
22	else:
23	try:	5✔
24	from aiohttp.test_utils import unittest_run_loop	5✔
25	except ImportError:	×
26	# unittest_run_loop is unnecessary and a no-op since aiohttp 3.8, and
27	# aiohttp 4 removed it. To maintain compatibility we can make our own
28	# no-op decorator.
29	def unittest_run_loop(func, args, *kwargs):	×
30	return func	×
31
32
33	@pytest.mark.blackd	5✔
34	class BlackDTestCase(AioHTTPTestCase):	5✔
35	def test_blackd_main(self) -> None:	5✔
36	with patch("blackd.web.run_app"):	5✔
37	result = CliRunner().invoke(blackd.main, [])	5✔
38	if result.exception is not None:	5!
39	raise result.exception	×
40	self.assertEqual(result.exit_code, 0)	5✔
41
42	async def get_application(self) -> web.Application:	5✔
43	return blackd.make_app()	5✔
44
45	@unittest_run_loop	5✔
46	async def test_blackd_request_needs_formatting(self) -> None:	5✔
47	response = await self.client.post("/", data=b"print('hello world')")	5✔
48	self.assertEqual(response.status, 200)	5✔
49	self.assertEqual(response.charset, "utf8")	5✔
50	self.assertEqual(await response.read(), b'print("hello world")\n')	5✔
51
52	@unittest_run_loop	5✔
53	async def test_blackd_request_no_change(self) -> None:	5✔
54	response = await self.client.post("/", data=b'print("hello world")\n')	5✔
55	self.assertEqual(response.status, 204)	5✔
56	self.assertEqual(await response.read(), b"")	5✔
57
58	@unittest_run_loop	5✔
59	async def test_blackd_request_syntax_error(self) -> None:	5✔
60	response = await self.client.post("/", data=b"what even ( is")	5✔
61	self.assertEqual(response.status, 400)	5✔
62	content = await response.text()	5✔
63	self.assertTrue(	5✔
64	content.startswith("Cannot parse"),
65	msg=f"Expected error to start with 'Cannot parse', got {repr(content)}",
66	)
67
68	@unittest_run_loop	5✔
69	async def test_blackd_unsupported_version(self) -> None:	5✔
70	response = await self.client.post(	5✔
71	"/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "2"}
72	)
73	self.assertEqual(response.status, 501)	5✔
74
75	@unittest_run_loop	5✔
76	async def test_blackd_supported_version(self) -> None:	5✔
77	response = await self.client.post(	5✔
78	"/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "1"}
79	)
80	self.assertEqual(response.status, 200)	5✔
81
82	@unittest_run_loop	5✔
83	async def test_blackd_invalid_python_variant(self) -> None:	5✔
84	async def check(header_value: str, expected_status: int = 400) -> None:	5✔
85	response = await self.client.post(	5✔
86	"/",
87	data=b"what",
88	headers={blackd.PYTHON_VARIANT_HEADER: header_value},
89	)
90	self.assertEqual(response.status, expected_status)	5✔
91
92	await check("lol")	5✔
93	await check("ruby3.5")	5✔
94	await check("pyi3.6")	5✔
95	await check("py1.5")	5✔
96	await check("2")	5✔
97	await check("2.7")	5✔
98	await check("py2.7")	5✔
99	await check("2.8")	5✔
100	await check("py2.8")	5✔
101	await check("3.0")	5✔
102	await check("pypy3.0")	5✔
103	await check("jython3.4")	5✔
104
105	@unittest_run_loop	5✔
106	async def test_blackd_pyi(self) -> None:	5✔
107	source, expected = read_data("cases", "stub.py")	5✔
108	response = await self.client.post(	5✔
109	"/", data=source, headers={blackd.PYTHON_VARIANT_HEADER: "pyi"}
110	)
111	self.assertEqual(response.status, 200)	5✔
112	self.assertEqual(await response.text(), expected)	5✔
113
114	@unittest_run_loop	5✔
115	async def test_blackd_diff(self) -> None:	5✔
116	diff_header = re.compile(	5✔
117	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"
118	)
119
120	source, _ = read_data("miscellaneous", "blackd_diff")	5✔
121	expected, _ = read_data("miscellaneous", "blackd_diff.diff")	5✔
122
123	response = await self.client.post(	5✔
124	"/", data=source, headers={blackd.DIFF_HEADER: "true"}
125	)
126	self.assertEqual(response.status, 200)	5✔
127
128	actual = await response.text()	5✔
129	actual = diff_header.sub(DETERMINISTIC_HEADER, actual)	5✔
130	self.assertEqual(actual, expected)	5✔
131
132	@unittest_run_loop	5✔
133	async def test_blackd_python_variant(self) -> None:	5✔
134	code = (	5✔
135	"def f(\n"
136	" and_has_a_bunch_of,\n"
137	" very_long_arguments_too,\n"
138	" and_lots_of_them_as_well_lol,\n"
139	" **and_very_long_keyword_arguments\n"
140	"):\n"
141	" pass\n"
142	)
143
144	async def check(header_value: str, expected_status: int) -> None:	5✔
145	response = await self.client.post(	5✔
146	"/", data=code, headers={blackd.PYTHON_VARIANT_HEADER: header_value}
147	)
148	self.assertEqual(	5✔
149	response.status, expected_status, msg=await response.text()
150	)
151
152	await check("3.6", 200)	5✔
153	await check("py3.6", 200)	5✔
154	await check("3.6,3.7", 200)	5✔
155	await check("3.6,py3.7", 200)	5✔
156	await check("py36,py37", 200)	5✔
157	await check("36", 200)	5✔
158	await check("3.6.4", 200)	5✔
159	await check("3.4", 204)	5✔
160	await check("py3.4", 204)	5✔
161	await check("py34,py36", 204)	5✔
162	await check("34", 204)	5✔
163
164	@unittest_run_loop	5✔
165	async def test_blackd_line_length(self) -> None:	5✔
166	response = await self.client.post(	5✔
167	"/", data=b'print("hello")\n', headers={blackd.LINE_LENGTH_HEADER: "7"}
168	)
169	self.assertEqual(response.status, 200)	5✔
170
171	@unittest_run_loop	5✔
172	async def test_blackd_invalid_line_length(self) -> None:	5✔
173	response = await self.client.post(	5✔
174	"/",
175	data=b'print("hello")\n',
176	headers={blackd.LINE_LENGTH_HEADER: "NaN"},
177	)
178	self.assertEqual(response.status, 400)	5✔
179
180	@unittest_run_loop	5✔
181	async def test_blackd_skip_first_source_line(self) -> None:	5✔
182	invalid_first_line = b"Header will be skipped\r\ni = [1,2,3]\nj = [1,2,3]\n"	5✔
183	expected_result = b"Header will be skipped\r\ni = [1, 2, 3]\nj = [1, 2, 3]\n"	5✔
184	response = await self.client.post("/", data=invalid_first_line)	5✔
185	self.assertEqual(response.status, 400)	5✔
186	response = await self.client.post(	5✔
187	"/",
188	data=invalid_first_line,
189	headers={blackd.SKIP_SOURCE_FIRST_LINE: "true"},
190	)
191	self.assertEqual(response.status, 200)	5✔
192	self.assertEqual(await response.read(), expected_result)	5✔
193
194	@unittest_run_loop	5✔
195	async def test_blackd_preview(self) -> None:	5✔
196	response = await self.client.post(	5✔
197	"/", data=b'print("hello")\n', headers={blackd.PREVIEW: "true"}
198	)
199	self.assertEqual(response.status, 204)	5✔
200
201	@unittest_run_loop	5✔
202	async def test_blackd_response_black_version_header(self) -> None:	5✔
203	response = await self.client.post("/")	5✔
204	self.assertIsNotNone(response.headers.get(blackd.BLACK_VERSION_HEADER))	5✔
205
206	@unittest_run_loop	5✔
207	async def test_cors_preflight(self) -> None:	5✔
208	response = await self.client.options(	5✔
209	"/",
210	headers={
211	"Access-Control-Request-Method": "POST",
212	"Origin": "*",
213	"Access-Control-Request-Headers": "Content-Type",
214	},
215	)
216	self.assertEqual(response.status, 200)	5✔
217	self.assertIsNotNone(response.headers.get("Access-Control-Allow-Origin"))	5✔
218	self.assertIsNotNone(response.headers.get("Access-Control-Allow-Headers"))	5✔
219	self.assertIsNotNone(response.headers.get("Access-Control-Allow-Methods"))	5✔
220
221	@unittest_run_loop	5✔
222	async def test_cors_headers_present(self) -> None:	5✔
223	response = await self.client.post("/", headers={"Origin": "*"})	5✔
224	self.assertIsNotNone(response.headers.get("Access-Control-Allow-Origin"))	5✔
225	self.assertIsNotNone(response.headers.get("Access-Control-Expose-Headers"))	5✔
226
227	@unittest_run_loop	5✔
228	async def test_preserves_line_endings(self) -> None:	5✔
229	for data in (b"c\r\nc\r\n", b"l\nl\n"):	5✔
230	# test preserved newlines when reformatted
231	response = await self.client.post("/", data=data + b" ")	5✔
232	self.assertEqual(await response.text(), data.decode())	5✔
233	# test 204 when no change
234	response = await self.client.post("/", data=data)	5✔
235	self.assertEqual(response.status, 204)	5✔
236
237	@unittest_run_loop	5✔
238	async def test_normalizes_line_endings(self) -> None:	5✔
239	for data, expected in ((b"c\r\nc\n", "c\r\nc\r\n"), (b"l\nl\r\n", "l\nl\n")):	5✔
240	response = await self.client.post("/", data=data)	5✔
241	self.assertEqual(await response.text(), expected)	5✔
242	self.assertEqual(response.status, 200)	5✔
243
244	@unittest_run_loop	5✔
245	async def test_single_character(self) -> None:	5✔
246	response = await self.client.post("/", data="1")	5✔
247	self.assertEqual(await response.text(), "1\n")	5✔
248	self.assertEqual(response.status, 200)	5✔

psf / black / 7692220850

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous