20332790708

Committed 18 Dec 2025 09:48AM UTC coverage: 64.992% (-15.3%) from 80.295%

Build # 20332790708

Build Type

Pull #22949

github

Committed by

web-flow

Commit Message

Merge f730a56cd into 407284c67

Pull Request Pull Request #22949: Add experimental uv resolver for Python lockfiles

Run Details

54 of 97 new or added lines in 5 files covered. (55.67%)

8270 existing lines in 295 files now uncovered.

48990 of 75379 relevant lines covered (64.99%)

1.81 hits per line

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

61.29

/src/python/pants/backend/shell/lint/shfmt/rules_integration_test.py

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

from __future__ import annotations

from textwrap import dedent

import pytest

from pants.backend.shell.lint.shfmt.rules import ShfmtFieldSet, ShfmtRequest
from pants.backend.shell.lint.shfmt.rules import rules as shfmt_rules
from pants.backend.shell.target_types import ShellSourcesGeneratorTarget
from pants.backend.shell.target_types import rules as target_types_rules
from pants.core.goals.fmt import FmtResult
from pants.core.util_rules import config_files, external_tool, source_files
from pants.core.util_rules.source_files import SourceFiles, SourceFilesRequest
from pants.engine.addresses import Address
from pants.engine.target import Target
from pants.testutil.rule_runner import QueryRule, RuleRunner


@pytest.fixture
def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *shfmt_rules(),
            *config_files.rules(),
            *external_tool.rules(),
            *source_files.rules(),
            *target_types_rules(),
            QueryRule(FmtResult, [ShfmtRequest.Batch]),
            QueryRule(SourceFiles, [SourceFilesRequest]),
        ],
        target_types=[ShellSourcesGeneratorTarget],
    )


GOOD_FILE = "! foo bar >a &\n"
BAD_FILE = "!    foo bar >a  &\n"

# If config is loaded correctly, shfmt will indent the case statements.
NEEDS_CONFIG_FILE = dedent(
    """\
    case foo in
    PATTERN_1)
    \tbar
    \t;;
    *)
    \tbaz
    \t;;
    esac
    """
)
FIXED_NEEDS_CONFIG_FILE = dedent(
    """\
    case foo in
    \tPATTERN_1)
    \t\tbar
    \t\t;;
    \t*)
    \t\tbaz
    \t\t;;
    esac
    """
)


def run_shfmt(
    rule_runner: RuleRunner,
    targets: list[Target],
    *,
    extra_args: list[str] | None = None,
) -> FmtResult:
    rule_runner.set_options(
        ["--backend-packages=pants.backend.shell.lint.shfmt", *(extra_args or ())],
        env_inherit={"PATH"},
    )
    field_sets = [ShfmtFieldSet.create(tgt) for tgt in targets]
    input_sources = rule_runner.request(
        SourceFiles,
        [
            SourceFilesRequest(field_set.sources for field_set in field_sets),
        ],
    )
    fmt_result = rule_runner.request(
        FmtResult,
        [
            ShfmtRequest.Batch(
                "",
                input_sources.snapshot.files,
                partition_metadata=None,
                snapshot=input_sources.snapshot,
            ),
        ],
    )
    return fmt_result


def test_passing(rule_runner: RuleRunner) -> None:
    rule_runner.write_files({"f.sh": GOOD_FILE, "BUILD": "shell_sources(name='t')"})
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))
    fmt_result = run_shfmt(rule_runner, [tgt])
    assert fmt_result.stdout == ""
    assert fmt_result.output == rule_runner.make_snapshot({"f.sh": GOOD_FILE})
    assert fmt_result.did_change is False


@pytest.mark.platform_specific_behavior
def test_failing(rule_runner: RuleRunner) -> None:
    rule_runner.write_files({"f.sh": BAD_FILE, "BUILD": "shell_sources(name='t')"})
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))
    fmt_result = run_shfmt(rule_runner, [tgt])
    assert fmt_result.stdout == "f.sh\n"
    assert fmt_result.output == rule_runner.make_snapshot({"f.sh": GOOD_FILE})
    assert fmt_result.did_change is True


def test_multiple_targets(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {"good.sh": GOOD_FILE, "bad.sh": BAD_FILE, "BUILD": "shell_sources(name='t')"}
    )
    tgts = [
        rule_runner.get_target(Address("", target_name="t", relative_file_path="good.sh")),
        rule_runner.get_target(Address("", target_name="t", relative_file_path="bad.sh")),
    ]
    fmt_result = run_shfmt(rule_runner, tgts)
    assert "bad.sh\n" == fmt_result.stdout
    assert fmt_result.output == rule_runner.make_snapshot(
        {"good.sh": GOOD_FILE, "bad.sh": GOOD_FILE}
    )
    assert fmt_result.did_change is True


def test_config_files(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "a/f.sh": NEEDS_CONFIG_FILE,
            "a/BUILD": "shell_sources()",
            "a/.editorconfig": "[*.sh]\nswitch_case_indent = true\n",
            "b/f.sh": NEEDS_CONFIG_FILE,
            "b/BUILD": "shell_sources()",
        }
    )
    tgts = [
        rule_runner.get_target(Address("a", relative_file_path="f.sh")),
        rule_runner.get_target(Address("b", relative_file_path="f.sh")),
    ]
    fmt_result = run_shfmt(rule_runner, tgts)
    assert fmt_result.stdout == "a/f.sh\n"
    assert fmt_result.output == rule_runner.make_snapshot(
        {"a/f.sh": FIXED_NEEDS_CONFIG_FILE, "b/f.sh": NEEDS_CONFIG_FILE}
    )
    assert fmt_result.did_change is True


def test_passthrough_args(rule_runner: RuleRunner) -> None:
    rule_runner.write_files({"f.sh": NEEDS_CONFIG_FILE, "BUILD": "shell_sources(name='t')"})
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))
    fmt_result = run_shfmt(rule_runner, [tgt], extra_args=["--shfmt-args=-ci"])
    assert fmt_result.stdout == "f.sh\n"
    assert fmt_result.output == rule_runner.make_snapshot({"f.sh": FIXED_NEEDS_CONFIG_FILE})
    assert fmt_result.did_change is True

1	# Copyright 2021 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 textwrap import dedent	1✔
7
8	import pytest	1✔
9
10	from pants.backend.shell.lint.shfmt.rules import ShfmtFieldSet, ShfmtRequest	1✔
11	from pants.backend.shell.lint.shfmt.rules import rules as shfmt_rules	1✔
12	from pants.backend.shell.target_types import ShellSourcesGeneratorTarget	1✔
13	from pants.backend.shell.target_types import rules as target_types_rules	1✔
14	from pants.core.goals.fmt import FmtResult	1✔
15	from pants.core.util_rules import config_files, external_tool, source_files	1✔
16	from pants.core.util_rules.source_files import SourceFiles, SourceFilesRequest	1✔
17	from pants.engine.addresses import Address	1✔
18	from pants.engine.target import Target	1✔
19	from pants.testutil.rule_runner import QueryRule, RuleRunner	1✔
20
21
22	@pytest.fixture	1✔
23	def rule_runner() -> RuleRunner:	1✔
24	return RuleRunner(	1✔
25	rules=[
26	*shfmt_rules(),
27	*config_files.rules(),
28	*external_tool.rules(),
29	*source_files.rules(),
30	*target_types_rules(),
31	QueryRule(FmtResult, [ShfmtRequest.Batch]),
32	QueryRule(SourceFiles, [SourceFilesRequest]),
33	],
34	target_types=[ShellSourcesGeneratorTarget],
35	)
36
37
38	GOOD_FILE = "! foo bar >a &\n"	1✔
39	BAD_FILE = "! foo bar >a &\n"	1✔
40
41	# If config is loaded correctly, shfmt will indent the case statements.
42	NEEDS_CONFIG_FILE = dedent(	1✔
43	"""\
44	case foo in
45	PATTERN_1)
46	\tbar
47	\t;;
48	*)
49	\tbaz
50	\t;;
51	esac
52	"""
53	)
54	FIXED_NEEDS_CONFIG_FILE = dedent(	1✔
55	"""\
56	case foo in
57	\tPATTERN_1)
58	\t\tbar
59	\t\t;;
60	\t*)
61	\t\tbaz
62	\t\t;;
63	esac
64	"""
65	)
66
67
68	def run_shfmt(	1✔
69	rule_runner: RuleRunner,
70	targets: list[Target],
71	*,
72	extra_args: list[str] \| None = None,
73	) -> FmtResult:
74	rule_runner.set_options(	1✔
75	["--backend-packages=pants.backend.shell.lint.shfmt", *(extra_args or ())],
76	env_inherit={"PATH"},
77	)
78	field_sets = [ShfmtFieldSet.create(tgt) for tgt in targets]	1✔
79	input_sources = rule_runner.request(	1✔
80	SourceFiles,
81	[
82	SourceFilesRequest(field_set.sources for field_set in field_sets),
83	],
84	)
85	fmt_result = rule_runner.request(	1✔
86	FmtResult,
87	[
88	ShfmtRequest.Batch(
89	"",
90	input_sources.snapshot.files,
91	partition_metadata=None,
92	snapshot=input_sources.snapshot,
93	),
94	],
95	)
96	return fmt_result	1✔
97
98
99	def test_passing(rule_runner: RuleRunner) -> None:	1✔
UNCOV 100	rule_runner.write_files({"f.sh": GOOD_FILE, "BUILD": "shell_sources(name='t')"})	×
UNCOV 101	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))	×
UNCOV 102	fmt_result = run_shfmt(rule_runner, [tgt])	×
UNCOV 103	assert fmt_result.stdout == ""	×
UNCOV 104	assert fmt_result.output == rule_runner.make_snapshot({"f.sh": GOOD_FILE})	×
UNCOV 105	assert fmt_result.did_change is False	×
106
107
108	@pytest.mark.platform_specific_behavior	1✔
109	def test_failing(rule_runner: RuleRunner) -> None:	1✔
110	rule_runner.write_files({"f.sh": BAD_FILE, "BUILD": "shell_sources(name='t')"})	1✔
111	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))	1✔
112	fmt_result = run_shfmt(rule_runner, [tgt])	1✔
113	assert fmt_result.stdout == "f.sh\n"	1✔
114	assert fmt_result.output == rule_runner.make_snapshot({"f.sh": GOOD_FILE})	1✔
115	assert fmt_result.did_change is True	1✔
116
117
118	def test_multiple_targets(rule_runner: RuleRunner) -> None:	1✔
UNCOV 119	rule_runner.write_files(	×
120	{"good.sh": GOOD_FILE, "bad.sh": BAD_FILE, "BUILD": "shell_sources(name='t')"}
121	)
UNCOV 122	tgts = [	×
123	rule_runner.get_target(Address("", target_name="t", relative_file_path="good.sh")),
124	rule_runner.get_target(Address("", target_name="t", relative_file_path="bad.sh")),
125	]
UNCOV 126	fmt_result = run_shfmt(rule_runner, tgts)	×
UNCOV 127	assert "bad.sh\n" == fmt_result.stdout	×
UNCOV 128	assert fmt_result.output == rule_runner.make_snapshot(	×
129	{"good.sh": GOOD_FILE, "bad.sh": GOOD_FILE}
130	)
UNCOV 131	assert fmt_result.did_change is True	×
132
133
134	def test_config_files(rule_runner: RuleRunner) -> None:	1✔
UNCOV 135	rule_runner.write_files(	×
136	{
137	"a/f.sh": NEEDS_CONFIG_FILE,
138	"a/BUILD": "shell_sources()",
139	"a/.editorconfig": "[*.sh]\nswitch_case_indent = true\n",
140	"b/f.sh": NEEDS_CONFIG_FILE,
141	"b/BUILD": "shell_sources()",
142	}
143	)
UNCOV 144	tgts = [	×
145	rule_runner.get_target(Address("a", relative_file_path="f.sh")),
146	rule_runner.get_target(Address("b", relative_file_path="f.sh")),
147	]
UNCOV 148	fmt_result = run_shfmt(rule_runner, tgts)	×
UNCOV 149	assert fmt_result.stdout == "a/f.sh\n"	×
UNCOV 150	assert fmt_result.output == rule_runner.make_snapshot(	×
151	{"a/f.sh": FIXED_NEEDS_CONFIG_FILE, "b/f.sh": NEEDS_CONFIG_FILE}
152	)
UNCOV 153	assert fmt_result.did_change is True	×
154
155
156	def test_passthrough_args(rule_runner: RuleRunner) -> None:	1✔
UNCOV 157	rule_runner.write_files({"f.sh": NEEDS_CONFIG_FILE, "BUILD": "shell_sources(name='t')"})	×
UNCOV 158	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))	×
UNCOV 159	fmt_result = run_shfmt(rule_runner, [tgt], extra_args=["--shfmt-args=-ci"])	×
UNCOV 160	assert fmt_result.stdout == "f.sh\n"	×
UNCOV 161	assert fmt_result.output == rule_runner.make_snapshot({"f.sh": FIXED_NEEDS_CONFIG_FILE})	×
UNCOV 162	assert fmt_result.did_change is True	×

pantsbuild / pants / 20332790708

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