11108792338

Committed 30 Sep 2024 03:00PM UTC coverage: 96.03% (-0.003%) from 96.033%

Build # 11108792338

Build Type

push

github

Committed by

web-flow

Commit Message

Bump AndreMiras/coveralls-python-action from <a class=hub.com/psf/black/commit/<a class="double-link" href="https://git"><a class=hub.com/psf/black/commit/65c1672f0b8a201702d86c81b79187df74072505">65c1672f0<a href="https://github.com/psf/black/commit/b7d0e7212bb8bf9ee9ff6ad4137b33bd9711946e"><a href="https://github.com/psf/black/commit/b7d0e7212bb8bf9ee9ff6ad4137b33bd9711946e"> to <a class=hub.com/psf/black/commit/<a class="double-link" href="https://git"><a class=hub.com/psf/black/commit/ac868b9540fad490f7ca82b8ca00480fd751ed19">ac868b954 (#4468)


Bumps [AndreMiras/coveralls-python-action](https://github.com/andremiras/coveralls-python-action) from 65c1672f0b8a201702d86c81b79187df74072505 to ac868b9540fad490f7ca82b8ca00480fd751ed19.
- [Release notes](https://github.com/andremiras/coveralls-python-action/releases)
- [Changelog](https://github.com/AndreMiras/coveralls-python-action/blob/develop/CHANGELOG.md)
- [Commits](https://github.com/andremiras/coveralls-python-action/compare/65c1672f0b8a201702d86c81b79187df74072505...ac868b9540fad490f7ca82b8ca00480fd751ed19)

---
updated-dependencies:
- dependency-name: AndreMiras/coveralls-python-action
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Run Details

3432 of 3673 branches covered (93.44%)

7475 of 7784 relevant lines covered (96.03%)

4.8 hits per line

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

97.79

/tests/test_blackd.py

import gc
import re
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


@pytest.mark.blackd
class BlackDTestCase(AioHTTPTestCase):
    def tearDown(self) -> None:
        # Work around https://github.com/python/cpython/issues/124706
        gc.collect()
        super().tearDown()

    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()

    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')

    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"")

    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)}",
        )

    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)

    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)

    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")

    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)

    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)

    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)

    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)

    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)

    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)

    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)

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

    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"))

    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"))

    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)

    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)

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

psf / black / 11108792338

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