19381742489

Committed 15 Nov 2025 12:52AM UTC coverage: 49.706% (-30.6%) from 80.29%

Build # 19381742489

Build Type

Pull #22890

github

Committed by

web-flow

Commit Message

Merge d961abf79 into 42e1ebd41

Pull Request Pull Request #22890: Updated all python subsystem constraints to 3.14

Run Details

4 of 5 new or added lines in 5 files covered. (80.0%)

14659 existing lines in 485 files now uncovered.

31583 of 63540 relevant lines covered (49.71%)

0.79 hits per line

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

54.08

/src/python/pants/backend/python/lint/flake8/rules_integration_test.py

# Copyright 2019 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).

from __future__ import annotations

from typing import Any

import pytest

from pants.backend.python import target_types_rules
from pants.backend.python.lint.flake8.rules import Flake8Request
from pants.backend.python.lint.flake8.rules import rules as flake8_rules
from pants.backend.python.lint.flake8.subsystem import Flake8FieldSet
from pants.backend.python.lint.flake8.subsystem import rules as flake8_subsystem_rules
from pants.backend.python.target_types import PythonSourcesGeneratorTarget
from pants.backend.python.util_rules import python_sources
from pants.core.goals.lint import LintResult, Partitions
from pants.core.util_rules import config_files
from pants.engine.addresses import Address
from pants.engine.fs import EMPTY_DIGEST, DigestContents
from pants.engine.target import Target
from pants.testutil.python_interpreter_selection import all_major_minor_python_versions
from pants.testutil.python_rule_runner import PythonRuleRunner
from pants.testutil.rule_runner import QueryRule
from pants.util.resources import read_sibling_resource


@pytest.fixture
def rule_runner() -> PythonRuleRunner:
    return PythonRuleRunner(
        rules=[
            *flake8_rules(),
            *flake8_subsystem_rules(),
            *python_sources.rules(),
            *config_files.rules(),
            *target_types_rules.rules(),
            QueryRule(Partitions, [Flake8Request.PartitionRequest]),
            QueryRule(LintResult, [Flake8Request.Batch]),
        ],
        target_types=[PythonSourcesGeneratorTarget],
    )


GOOD_FILE = "print('Nothing suspicious here..')\n"
BAD_FILE = "import typing\n"  # Unused import.


def run_flake8(
    rule_runner: PythonRuleRunner, targets: list[Target], *, extra_args: list[str] | None = None
) -> tuple[LintResult, ...]:
    rule_runner.set_options(
        ["--backend-packages=pants.backend.python.lint.flake8", *(extra_args or ())],
        env_inherit={"PATH", "PYENV_ROOT", "HOME"},
    )
    partitions = rule_runner.request(
        Partitions[Flake8FieldSet, Any],
        [Flake8Request.PartitionRequest(tuple(Flake8FieldSet.create(tgt) for tgt in targets))],
    )
    results = []
    for partition in partitions:
        result = rule_runner.request(
            LintResult,
            [Flake8Request.Batch("", partition.elements, partition.metadata)],
        )
        results.append(result)
    return tuple(results)


def assert_success(
    rule_runner: PythonRuleRunner, target: Target, *, extra_args: list[str] | None = None
) -> None:
    result = run_flake8(rule_runner, [target], extra_args=extra_args)
    assert len(result) == 1
    assert result[0].exit_code == 0
    assert result[0].stdout.strip() == ""
    assert result[0].report == EMPTY_DIGEST


@pytest.mark.platform_specific_behavior
@pytest.mark.parametrize(
    "major_minor_interpreter",
    all_major_minor_python_versions(["CPython>=3.9,<3.15"]),
)
def test_passing(rule_runner: PythonRuleRunner, major_minor_interpreter: str) -> None:
    rule_runner.write_files({"f.py": GOOD_FILE, "BUILD": "python_sources(name='t')"})
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))
    assert_success(
        rule_runner,
        tgt,
        extra_args=[f"--python-interpreter-constraints=['=={major_minor_interpreter}.*']"],
    )


def test_failing(rule_runner: PythonRuleRunner) -> None:
    rule_runner.write_files({"f.py": BAD_FILE, "BUILD": "python_sources(name='t')"})
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))
    result = run_flake8(rule_runner, [tgt])
    assert len(result) == 1
    assert result[0].exit_code == 1
    assert "f.py:1:1: F401" in result[0].stdout
    assert result[0].report == EMPTY_DIGEST


def test_multiple_targets(rule_runner: PythonRuleRunner) -> None:
    rule_runner.write_files(
        {"good.py": GOOD_FILE, "bad.py": BAD_FILE, "BUILD": "python_sources(name='t')"}
    )
    tgts = [
        rule_runner.get_target(Address("", target_name="t", relative_file_path="good.py")),
        rule_runner.get_target(Address("", target_name="t", relative_file_path="bad.py")),
    ]
    result = run_flake8(rule_runner, tgts)
    assert len(result) == 1
    assert result[0].exit_code == 1
    assert "good.py" not in result[0].stdout
    assert "bad.py:1:1: F401" in result[0].stdout


@pytest.mark.parametrize(
    "config_path,extra_args",
    ([".flake8", []], ["custom_config.ini", ["--flake8-config=custom_config.ini"]]),
)
def test_config_file(
    rule_runner: PythonRuleRunner, config_path: str, extra_args: list[str]
) -> None:
    rule_runner.write_files(
        {
            "f.py": BAD_FILE,
            "BUILD": "python_sources(name='t')",
            config_path: "[flake8]\nignore = F401\n",
        }
    )
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))
    assert_success(rule_runner, tgt, extra_args=extra_args)


def test_passthrough_args(rule_runner: PythonRuleRunner) -> None:
    rule_runner.write_files({"f.py": BAD_FILE, "BUILD": "python_sources(name='t')"})
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))
    assert_success(rule_runner, tgt, extra_args=["--flake8-args='--ignore=F401'"])


def test_skip(rule_runner: PythonRuleRunner) -> None:
    rule_runner.write_files({"f.py": BAD_FILE, "BUILD": "python_sources(name='t')"})
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))
    result = run_flake8(rule_runner, [tgt], extra_args=["--flake8-skip"])
    assert not result


def test_3rdparty_plugin(rule_runner: PythonRuleRunner) -> None:
    # Test extra_files option.
    rule_runner.write_files(
        {
            "f.py": "assert 1 == 1\n",
            ".bandit": "[bandit]\nskips: B101\n",
            "BUILD": "python_sources(name='t')",
            "flake8.lock": read_sibling_resource(__name__, "flake8_plugin_test.lock"),
        }
    )
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))
    result = run_flake8(
        rule_runner,
        [tgt],
        extra_args=[
            "--python-resolves={'flake8':'flake8.lock'}",
            "--flake8-install-from-resolve=flake8",
            "--flake8-extra-files=['.bandit']",
        ],
    )
    assert len(result) == 1
    assert result[0].exit_code == 0, result[0].stderr


def test_report_file(rule_runner: PythonRuleRunner) -> None:
    rule_runner.write_files({"f.py": BAD_FILE, "BUILD": "python_sources(name='t')"})
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))
    result = run_flake8(
        rule_runner, [tgt], extra_args=["--flake8-args='--output-file=reports/foo.txt'"]
    )
    assert len(result) == 1
    assert result[0].exit_code == 1
    assert result[0].stdout.strip() == ""
    report_files = rule_runner.request(DigestContents, [result[0].report])
    assert len(report_files) == 1
    assert "f.py:1:1: F401" in report_files[0].content.decode()


def test_type_stubs(rule_runner: PythonRuleRunner) -> None:
    rule_runner.write_files(
        {"f.pyi": BAD_FILE, "f.py": GOOD_FILE, "BUILD": "python_sources(name='t')"}
    )
    tgts = [
        rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py")),
        rule_runner.get_target(Address("", target_name="t", relative_file_path="f.pyi")),
    ]
    result = run_flake8(rule_runner, tgts)
    assert len(result) == 1
    assert result[0].exit_code == 1
    assert "f.py:" not in result[0].stdout
    assert "f.pyi:1:1: F401" in result[0].stdout

1	# Copyright 2019 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3
4	from __future__ import annotations	1✔
5
6	from typing import Any	1✔
7
8	import pytest	1✔
9
10	from pants.backend.python import target_types_rules	1✔
11	from pants.backend.python.lint.flake8.rules import Flake8Request	1✔
12	from pants.backend.python.lint.flake8.rules import rules as flake8_rules	1✔
13	from pants.backend.python.lint.flake8.subsystem import Flake8FieldSet	1✔
14	from pants.backend.python.lint.flake8.subsystem import rules as flake8_subsystem_rules	1✔
15	from pants.backend.python.target_types import PythonSourcesGeneratorTarget	1✔
16	from pants.backend.python.util_rules import python_sources	1✔
17	from pants.core.goals.lint import LintResult, Partitions	1✔
18	from pants.core.util_rules import config_files	1✔
19	from pants.engine.addresses import Address	1✔
20	from pants.engine.fs import EMPTY_DIGEST, DigestContents	1✔
21	from pants.engine.target import Target	1✔
22	from pants.testutil.python_interpreter_selection import all_major_minor_python_versions	1✔
23	from pants.testutil.python_rule_runner import PythonRuleRunner	1✔
24	from pants.testutil.rule_runner import QueryRule	1✔
25	from pants.util.resources import read_sibling_resource	1✔
26
27
28	@pytest.fixture	1✔
29	def rule_runner() -> PythonRuleRunner:	1✔
30	return PythonRuleRunner(	1✔
31	rules=[
32	*flake8_rules(),
33	*flake8_subsystem_rules(),
34	*python_sources.rules(),
35	*config_files.rules(),
36	*target_types_rules.rules(),
37	QueryRule(Partitions, [Flake8Request.PartitionRequest]),
38	QueryRule(LintResult, [Flake8Request.Batch]),
39	],
40	target_types=[PythonSourcesGeneratorTarget],
41	)
42
43
44	GOOD_FILE = "print('Nothing suspicious here..')\n"	1✔
45	BAD_FILE = "import typing\n" # Unused import.	1✔
46
47
48	def run_flake8(	1✔
49	rule_runner: PythonRuleRunner, targets: list[Target], *, extra_args: list[str] \| None = None
50	) -> tuple[LintResult, ...]:
51	rule_runner.set_options(	1✔
52	["--backend-packages=pants.backend.python.lint.flake8", *(extra_args or ())],
53	env_inherit={"PATH", "PYENV_ROOT", "HOME"},
54	)
55	partitions = rule_runner.request(	1✔
56	Partitions[Flake8FieldSet, Any],
57	[Flake8Request.PartitionRequest(tuple(Flake8FieldSet.create(tgt) for tgt in targets))],
58	)
59	results = []	1✔
60	for partition in partitions:	1✔
61	result = rule_runner.request(	1✔
62	LintResult,
63	[Flake8Request.Batch("", partition.elements, partition.metadata)],
64	)
65	results.append(result)	1✔
66	return tuple(results)	1✔
67
68
69	def assert_success(	1✔
70	rule_runner: PythonRuleRunner, target: Target, *, extra_args: list[str] \| None = None
71	) -> None:
72	result = run_flake8(rule_runner, [target], extra_args=extra_args)	1✔
73	assert len(result) == 1	1✔
74	assert result[0].exit_code == 0	1✔
75	assert result[0].stdout.strip() == ""	1✔
76	assert result[0].report == EMPTY_DIGEST	1✔
77
78
79	@pytest.mark.platform_specific_behavior	1✔
80	@pytest.mark.parametrize(	1✔
81	"major_minor_interpreter",
82	all_major_minor_python_versions(["CPython>=3.9,<3.15"]),
83	)
84	def test_passing(rule_runner: PythonRuleRunner, major_minor_interpreter: str) -> None:	1✔
85	rule_runner.write_files({"f.py": GOOD_FILE, "BUILD": "python_sources(name='t')"})	1✔
86	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))	1✔
87	assert_success(	1✔
88	rule_runner,
89	tgt,
90	extra_args=[f"--python-interpreter-constraints=['=={major_minor_interpreter}.*']"],
91	)
92
93
94	def test_failing(rule_runner: PythonRuleRunner) -> None:	1✔
UNCOV 95	rule_runner.write_files({"f.py": BAD_FILE, "BUILD": "python_sources(name='t')"})	×
UNCOV 96	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))	×
UNCOV 97	result = run_flake8(rule_runner, [tgt])	×
UNCOV 98	assert len(result) == 1	×
UNCOV 99	assert result[0].exit_code == 1	×
UNCOV 100	assert "f.py:1:1: F401" in result[0].stdout	×
UNCOV 101	assert result[0].report == EMPTY_DIGEST	×
102
103
104	def test_multiple_targets(rule_runner: PythonRuleRunner) -> None:	1✔
UNCOV 105	rule_runner.write_files(	×
106	{"good.py": GOOD_FILE, "bad.py": BAD_FILE, "BUILD": "python_sources(name='t')"}
107	)
UNCOV 108	tgts = [	×
109	rule_runner.get_target(Address("", target_name="t", relative_file_path="good.py")),
110	rule_runner.get_target(Address("", target_name="t", relative_file_path="bad.py")),
111	]
UNCOV 112	result = run_flake8(rule_runner, tgts)	×
UNCOV 113	assert len(result) == 1	×
UNCOV 114	assert result[0].exit_code == 1	×
UNCOV 115	assert "good.py" not in result[0].stdout	×
UNCOV 116	assert "bad.py:1:1: F401" in result[0].stdout	×
117
118
119	@pytest.mark.parametrize(	1✔
120	"config_path,extra_args",
121	([".flake8", []], ["custom_config.ini", ["--flake8-config=custom_config.ini"]]),
122	)
123	def test_config_file(	1✔
124	rule_runner: PythonRuleRunner, config_path: str, extra_args: list[str]
125	) -> None:
UNCOV 126	rule_runner.write_files(	×
127	{
128	"f.py": BAD_FILE,
129	"BUILD": "python_sources(name='t')",
130	config_path: "[flake8]\nignore = F401\n",
131	}
132	)
UNCOV 133	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))	×
UNCOV 134	assert_success(rule_runner, tgt, extra_args=extra_args)	×
135
136
137	def test_passthrough_args(rule_runner: PythonRuleRunner) -> None:	1✔
UNCOV 138	rule_runner.write_files({"f.py": BAD_FILE, "BUILD": "python_sources(name='t')"})	×
UNCOV 139	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))	×
UNCOV 140	assert_success(rule_runner, tgt, extra_args=["--flake8-args='--ignore=F401'"])	×
141
142
143	def test_skip(rule_runner: PythonRuleRunner) -> None:	1✔
UNCOV 144	rule_runner.write_files({"f.py": BAD_FILE, "BUILD": "python_sources(name='t')"})	×
UNCOV 145	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))	×
UNCOV 146	result = run_flake8(rule_runner, [tgt], extra_args=["--flake8-skip"])	×
UNCOV 147	assert not result	×
148
149
150	def test_3rdparty_plugin(rule_runner: PythonRuleRunner) -> None:	1✔
151	# Test extra_files option.
UNCOV 152	rule_runner.write_files(	×
153	{
154	"f.py": "assert 1 == 1\n",
155	".bandit": "[bandit]\nskips: B101\n",
156	"BUILD": "python_sources(name='t')",
157	"flake8.lock": read_sibling_resource(__name__, "flake8_plugin_test.lock"),
158	}
159	)
UNCOV 160	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))	×
UNCOV 161	result = run_flake8(	×
162	rule_runner,
163	[tgt],
164	extra_args=[
165	"--python-resolves={'flake8':'flake8.lock'}",
166	"--flake8-install-from-resolve=flake8",
167	"--flake8-extra-files=['.bandit']",
168	],
169	)
UNCOV 170	assert len(result) == 1	×
UNCOV 171	assert result[0].exit_code == 0, result[0].stderr	×
172
173
174	def test_report_file(rule_runner: PythonRuleRunner) -> None:	1✔
UNCOV 175	rule_runner.write_files({"f.py": BAD_FILE, "BUILD": "python_sources(name='t')"})	×
UNCOV 176	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py"))	×
UNCOV 177	result = run_flake8(	×
178	rule_runner, [tgt], extra_args=["--flake8-args='--output-file=reports/foo.txt'"]
179	)
UNCOV 180	assert len(result) == 1	×
UNCOV 181	assert result[0].exit_code == 1	×
UNCOV 182	assert result[0].stdout.strip() == ""	×
UNCOV 183	report_files = rule_runner.request(DigestContents, [result[0].report])	×
UNCOV 184	assert len(report_files) == 1	×
UNCOV 185	assert "f.py:1:1: F401" in report_files[0].content.decode()	×
186
187
188	def test_type_stubs(rule_runner: PythonRuleRunner) -> None:	1✔
UNCOV 189	rule_runner.write_files(	×
190	{"f.pyi": BAD_FILE, "f.py": GOOD_FILE, "BUILD": "python_sources(name='t')"}
191	)
UNCOV 192	tgts = [	×
193	rule_runner.get_target(Address("", target_name="t", relative_file_path="f.py")),
194	rule_runner.get_target(Address("", target_name="t", relative_file_path="f.pyi")),
195	]
UNCOV 196	result = run_flake8(rule_runner, tgts)	×
UNCOV 197	assert len(result) == 1	×
UNCOV 198	assert result[0].exit_code == 1	×
UNCOV 199	assert "f.py:" not in result[0].stdout	×
UNCOV 200	assert "f.pyi:1:1: F401" in result[0].stdout	×

pantsbuild / pants / 19381742489

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