15838394689

Committed 24 Jun 2025 12:46AM UTC coverage: 100.0%. Remained the same

Build # 15838394689

Build Type

Pull #155

github

Committed by

web-flow

Commit Message

Merge f91847441 into 899d4507b

Pull Request Pull Request #155: Bump flake8 from 7.2.0 to 7.3.0

Run Details

4 of 4 branches covered (100.0%)

Branch coverage included in aggregate %.

100 of 100 relevant lines covered (100.0%)

1.0 hits per line

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

100.0

/tests/test_plugin.py

# pylint: disable=missing-function-docstring

"""Tests for invoke_plugin_for_pylint._plugin."""

from __future__ import annotations

import astroid
import pytest
from pylint.checkers.variables import VariablesChecker
from pylint.lint import PyLinter
from pylint.testutils import UnittestLinter
from pylint.utils import ASTWalker
from pytest_mock import MockerFixture

from invoke_plugin_for_pylint._plugin import InvokeChecker, register

NON_TASK_UNUSED = "def foo(bar): pass"
NON_TASK_USED = "def foo(bar): bar += 2"
NON_TASK_DECORATED_UNUSED = """import contextlib
@contextlib.contextmanager
def foo(bar):
    pass
"""
NON_TASK_DECORATED_USED = """import contextlib
@contextlib.contextmanager
def foo(bar):
    bar += 2
"""
TASK_SIMPLE_UNUSED = """from invoke import task
@task
def foo(context):
    pass
"""
TASK_SIMPLE_USED = """from invoke import task
@task
def foo(context):
    context.run("foo")
"""
TASK_ARGS_UNUSED = """from invoke import task
@task("bar")
def foo(context):
    pass
"""
TASK_ARGS_USED = """from invoke import task
@task("bar")
def foo(context):
    context.run("foo")
"""
CUSTOM_TASK_UNUSED = """from invoke import task
def deco(func):
    return task(func)

@deco
def deco_task(context):
    pass
"""
CUSTOM_TASK_USED = """from invoke import task
def deco(func):
    return task(func)

@deco
def deco_task(context):
    context.run("foo")
"""


@pytest.fixture(autouse=True)
def autoreset_add_message(mocker: MockerFixture) -> None:
    mocker.patch.object(VariablesChecker, "add_message", VariablesChecker.add_message)


@pytest.mark.parametrize(
    "code,error",
    [
        (NON_TASK_UNUSED, True),
        (NON_TASK_USED, False),
        (NON_TASK_DECORATED_UNUSED, True),
        (NON_TASK_DECORATED_USED, False),
        (TASK_SIMPLE_UNUSED, True),
        (TASK_SIMPLE_USED, False),
        (TASK_ARGS_UNUSED, True),
        (TASK_ARGS_USED, False),
        (CUSTOM_TASK_UNUSED, True),
        (CUSTOM_TASK_USED, False),
    ],
)
def test(code: str, error: bool) -> None:
    linter = UnittestLinter()
    walker = ASTWalker(linter)

    checker = VariablesChecker(linter)
    checker.open()
    walker.add_checker(checker)

    node = astroid.parse(code)
    walker.walk(node)
    messages = linter.release_messages()

    if error:
        assert len(messages) == 1
        assert messages[0].msg_id == "unused-argument"
    else:
        assert not messages


@pytest.mark.parametrize(
    "code,error",
    [
        (NON_TASK_UNUSED, True),
        (NON_TASK_USED, False),
        (NON_TASK_DECORATED_UNUSED, True),
        (NON_TASK_DECORATED_USED, False),
        (TASK_SIMPLE_UNUSED, False),
        (TASK_SIMPLE_USED, False),
        (TASK_ARGS_UNUSED, False),
        (TASK_ARGS_USED, False),
        (CUSTOM_TASK_UNUSED, True),
        (CUSTOM_TASK_USED, False),
    ],
)
def test_plugin(code: str, error: bool) -> None:
    linter = UnittestLinter()
    walker = ASTWalker(linter)

    checker = VariablesChecker(linter)
    checker.open()
    walker.add_checker(checker)

    walker.add_checker(InvokeChecker(linter))

    node = astroid.parse(code)
    walker.walk(node)
    messages = linter.release_messages()

    if error:
        assert len(messages) == 1
        assert messages[0].msg_id == "unused-argument"
    else:
        assert not messages


@pytest.mark.parametrize(
    "code,error",
    [
        (NON_TASK_UNUSED, True),
        (NON_TASK_USED, False),
        (NON_TASK_DECORATED_UNUSED, True),
        (NON_TASK_DECORATED_USED, False),
        (TASK_SIMPLE_UNUSED, False),
        (TASK_SIMPLE_USED, False),
        (TASK_ARGS_UNUSED, False),
        (TASK_ARGS_USED, False),
        (CUSTOM_TASK_UNUSED, False),
        (CUSTOM_TASK_USED, False),
    ],
)
def test_plugin_with_option(code: str, error: bool) -> None:
    linter = UnittestLinter()
    walker = ASTWalker(linter)

    checker = VariablesChecker(linter)
    checker.open()
    walker.add_checker(checker)

    invoke_checker = InvokeChecker(linter)
    walker.add_checker(invoke_checker)
    invoke_checker.linter.config.additional_invoke_task_decorators = [".deco"]

    node = astroid.parse(code)
    walker.walk(node)
    messages = linter.release_messages()

    if error:
        assert len(messages) == 1
        assert messages[0].msg_id == "unused-argument"
    else:
        assert not messages


def test_register(mocker: MockerFixture) -> None:
    linter = mocker.Mock(spec=PyLinter)
    register(linter)
    linter.register_checker.assert_called_once()

1	# pylint: disable=missing-function-docstring
2
3	"""Tests for invoke_plugin_for_pylint._plugin."""
4
5	from __future__ import annotations	1✔
6
7	import astroid	1✔
8	import pytest	1✔
9	from pylint.checkers.variables import VariablesChecker	1✔
10	from pylint.lint import PyLinter	1✔
11	from pylint.testutils import UnittestLinter	1✔
12	from pylint.utils import ASTWalker	1✔
13	from pytest_mock import MockerFixture	1✔
14
15	from invoke_plugin_for_pylint._plugin import InvokeChecker, register	1✔
16
17	NON_TASK_UNUSED = "def foo(bar): pass"	1✔
18	NON_TASK_USED = "def foo(bar): bar += 2"	1✔
19	NON_TASK_DECORATED_UNUSED = """import contextlib	1✔
20	@contextlib.contextmanager
21	def foo(bar):
22	pass
23	"""
24	NON_TASK_DECORATED_USED = """import contextlib	1✔
25	@contextlib.contextmanager
26	def foo(bar):
27	bar += 2
28	"""
29	TASK_SIMPLE_UNUSED = """from invoke import task	1✔
30	@task
31	def foo(context):
32	pass
33	"""
34	TASK_SIMPLE_USED = """from invoke import task	1✔
35	@task
36	def foo(context):
37	context.run("foo")
38	"""
39	TASK_ARGS_UNUSED = """from invoke import task	1✔
40	@task("bar")
41	def foo(context):
42	pass
43	"""
44	TASK_ARGS_USED = """from invoke import task	1✔
45	@task("bar")
46	def foo(context):
47	context.run("foo")
48	"""
49	CUSTOM_TASK_UNUSED = """from invoke import task	1✔
50	def deco(func):
51	return task(func)
52
53	@deco
54	def deco_task(context):
55	pass
56	"""
57	CUSTOM_TASK_USED = """from invoke import task	1✔
58	def deco(func):
59	return task(func)
60
61	@deco
62	def deco_task(context):
63	context.run("foo")
64	"""
65
66
67	@pytest.fixture(autouse=True)	1✔
68	def autoreset_add_message(mocker: MockerFixture) -> None:	1✔
69	mocker.patch.object(VariablesChecker, "add_message", VariablesChecker.add_message)	1✔
70
71
72	@pytest.mark.parametrize(	1✔
73	"code,error",
74	[
75	(NON_TASK_UNUSED, True),
76	(NON_TASK_USED, False),
77	(NON_TASK_DECORATED_UNUSED, True),
78	(NON_TASK_DECORATED_USED, False),
79	(TASK_SIMPLE_UNUSED, True),
80	(TASK_SIMPLE_USED, False),
81	(TASK_ARGS_UNUSED, True),
82	(TASK_ARGS_USED, False),
83	(CUSTOM_TASK_UNUSED, True),
84	(CUSTOM_TASK_USED, False),
85	],
86	)
87	def test(code: str, error: bool) -> None:	1✔
88	linter = UnittestLinter()	1✔
89	walker = ASTWalker(linter)	1✔
90
91	checker = VariablesChecker(linter)	1✔
92	checker.open()	1✔
93	walker.add_checker(checker)	1✔
94
95	node = astroid.parse(code)	1✔
96	walker.walk(node)	1✔
97	messages = linter.release_messages()	1✔
98
99	if error:	1✔
100	assert len(messages) == 1	1✔
101	assert messages[0].msg_id == "unused-argument"	1✔
102	else:
103	assert not messages	1✔
104
105
106	@pytest.mark.parametrize(	1✔
107	"code,error",
108	[
109	(NON_TASK_UNUSED, True),
110	(NON_TASK_USED, False),
111	(NON_TASK_DECORATED_UNUSED, True),
112	(NON_TASK_DECORATED_USED, False),
113	(TASK_SIMPLE_UNUSED, False),
114	(TASK_SIMPLE_USED, False),
115	(TASK_ARGS_UNUSED, False),
116	(TASK_ARGS_USED, False),
117	(CUSTOM_TASK_UNUSED, True),
118	(CUSTOM_TASK_USED, False),
119	],
120	)
121	def test_plugin(code: str, error: bool) -> None:	1✔
122	linter = UnittestLinter()	1✔
123	walker = ASTWalker(linter)	1✔
124
125	checker = VariablesChecker(linter)	1✔
126	checker.open()	1✔
127	walker.add_checker(checker)	1✔
128
129	walker.add_checker(InvokeChecker(linter))	1✔
130
131	node = astroid.parse(code)	1✔
132	walker.walk(node)	1✔
133	messages = linter.release_messages()	1✔
134
135	if error:	1✔
136	assert len(messages) == 1	1✔
137	assert messages[0].msg_id == "unused-argument"	1✔
138	else:
139	assert not messages	1✔
140
141
142	@pytest.mark.parametrize(	1✔
143	"code,error",
144	[
145	(NON_TASK_UNUSED, True),
146	(NON_TASK_USED, False),
147	(NON_TASK_DECORATED_UNUSED, True),
148	(NON_TASK_DECORATED_USED, False),
149	(TASK_SIMPLE_UNUSED, False),
150	(TASK_SIMPLE_USED, False),
151	(TASK_ARGS_UNUSED, False),
152	(TASK_ARGS_USED, False),
153	(CUSTOM_TASK_UNUSED, False),
154	(CUSTOM_TASK_USED, False),
155	],
156	)
157	def test_plugin_with_option(code: str, error: bool) -> None:	1✔
158	linter = UnittestLinter()	1✔
159	walker = ASTWalker(linter)	1✔
160
161	checker = VariablesChecker(linter)	1✔
162	checker.open()	1✔
163	walker.add_checker(checker)	1✔
164
165	invoke_checker = InvokeChecker(linter)	1✔
166	walker.add_checker(invoke_checker)	1✔
167	invoke_checker.linter.config.additional_invoke_task_decorators = [".deco"]	1✔
168
169	node = astroid.parse(code)	1✔
170	walker.walk(node)	1✔
171	messages = linter.release_messages()	1✔
172
173	if error:	1✔
174	assert len(messages) == 1	1✔
175	assert messages[0].msg_id == "unused-argument"	1✔
176	else:
177	assert not messages	1✔
178
179
180	def test_register(mocker: MockerFixture) -> None:	1✔
181	linter = mocker.Mock(spec=PyLinter)	1✔
182	register(linter)	1✔
183	linter.register_checker.assert_called_once()	1✔

SAP / invoke-plugin-for-pylint / 15838394689

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