21552830208

Committed 31 Jan 2026 11:40PM UTC coverage: 80.277% (-0.05%) from 80.324%

Build # 21552830208

Build Type

Pull #23062

github

Committed by

web-flow

Commit Message

Merge 808a9786c into 2c4dcf9cf

Pull Request Pull Request #23062: Remove support for Get

Run Details

18 of 25 new or added lines in 4 files covered. (72.0%)

17119 existing lines in 541 files now uncovered.

78278 of 97510 relevant lines covered (80.28%)

3.36 hits per line

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

100.0

/src/python/pants/backend/shell/lint/shellcheck/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
from typing import Any

import pytest

from pants.backend.shell.lint.shellcheck.rules import ShellcheckFieldSet, ShellcheckRequest
from pants.backend.shell.lint.shellcheck.rules import rules as shellcheck_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.lint import LintResult, Partitions
from pants.core.util_rules import config_files, external_tool, source_files
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=[
            *shellcheck_rules(),
            *config_files.rules(),
            *external_tool.rules(),
            *source_files.rules(),
            *target_types_rules(),
            QueryRule(Partitions, [ShellcheckRequest.PartitionRequest]),
            QueryRule(LintResult, [ShellcheckRequest.Batch]),
        ],
        target_types=[ShellSourcesGeneratorTarget],
    )


GOOD_FILE = "# shellcheck shell=bash\necho 'shell known'\n"
BAD_FILE = "echo 'shell unknown'\n"


def run_shellcheck(
    rule_runner: RuleRunner, targets: list[Target], *, extra_args: list[str] | None = None
) -> tuple[LintResult, ...]:
    rule_runner.set_options(
        ["--backend-packages=pants.backend.shell.lint.shellcheck", *(extra_args or ())],
        env_inherit={"PATH"},
    )
    partitions = rule_runner.request(
        Partitions[ShellcheckFieldSet, Any],
        [
            ShellcheckRequest.PartitionRequest(
                tuple(ShellcheckFieldSet.create(tgt) for tgt in targets)
            )
        ],
    )
    results = []
    for partition in partitions:
        result = rule_runner.request(
            LintResult,
            [ShellcheckRequest.Batch("", partition.elements, partition.metadata)],
        )
        results.append(result)
    return tuple(results)


def assert_success(
    rule_runner: RuleRunner, target: Target, *, extra_args: list[str] | None = None
) -> None:
    result = run_shellcheck(rule_runner, [target], extra_args=extra_args)
    assert len(result) == 1
    assert result[0].exit_code == 0
    assert not result[0].stdout
    assert not result[0].stderr


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"))
    assert_success(rule_runner, tgt)


@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"))
    result = run_shellcheck(rule_runner, [tgt])
    assert len(result) == 1
    assert result[0].exit_code == 1
    assert "In f.sh line 1:" in result[0].stdout


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")),
    ]
    result = run_shellcheck(rule_runner, tgts)
    assert len(result) == 1
    assert result[0].exit_code == 1
    assert "good.sh" not in result[0].stdout
    assert "In bad.sh line 1:" in result[0].stdout


def test_config_files(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "a/f.sh": BAD_FILE,
            "a/BUILD": "shell_sources()",
            "a/.shellcheckrc": "disable=SC2148",
            "b/f.sh": BAD_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")),
    ]
    result = run_shellcheck(rule_runner, tgts)
    assert len(result) == 1
    assert result[0].exit_code == 1
    assert "a/f.sh" not in result[0].stdout
    assert "In b/f.sh line 1:" in result[0].stdout


def test_passthrough_args(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"))
    assert_success(rule_runner, tgt, extra_args=["--shellcheck-args=-e SC2148"])


def test_skip(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"))
    result = run_shellcheck(rule_runner, [tgt], extra_args=["--shellcheck-skip"])
    assert not result


def test_includes_direct_dependencies(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "transitive_dep.sh": BAD_FILE,
            "dep.sh": GOOD_FILE,
            "f.sh": "# shellcheck shell=bash\nsource dep.sh\n",
            "BUILD": dedent(
                """\
                shell_sources(name='transitive', sources=['transitive_dep.sh'])
                shell_sources(name='dep', sources=['dep.sh'], dependencies=[':transitive'])
                shell_sources(name='t', sources=['f.sh'], dependencies=[':dep'])
                """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))
    assert_success(rule_runner, tgt, extra_args=["--shellcheck-args=--external-sources"])

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	3✔
5
6	from textwrap import dedent	3✔
7	from typing import Any	3✔
8
9	import pytest	3✔
10
11	from pants.backend.shell.lint.shellcheck.rules import ShellcheckFieldSet, ShellcheckRequest	3✔
12	from pants.backend.shell.lint.shellcheck.rules import rules as shellcheck_rules	3✔
13	from pants.backend.shell.target_types import ShellSourcesGeneratorTarget	3✔
14	from pants.backend.shell.target_types import rules as target_types_rules	3✔
15	from pants.core.goals.lint import LintResult, Partitions	3✔
16	from pants.core.util_rules import config_files, external_tool, source_files	3✔
17	from pants.engine.addresses import Address	3✔
18	from pants.engine.target import Target	3✔
19	from pants.testutil.rule_runner import QueryRule, RuleRunner	3✔
20
21
22	@pytest.fixture	3✔
23	def rule_runner() -> RuleRunner:	3✔
24	return RuleRunner(	3✔
25	rules=[
26	*shellcheck_rules(),
27	*config_files.rules(),
28	*external_tool.rules(),
29	*source_files.rules(),
30	*target_types_rules(),
31	QueryRule(Partitions, [ShellcheckRequest.PartitionRequest]),
32	QueryRule(LintResult, [ShellcheckRequest.Batch]),
33	],
34	target_types=[ShellSourcesGeneratorTarget],
35	)
36
37
38	GOOD_FILE = "# shellcheck shell=bash\necho 'shell known'\n"	3✔
39	BAD_FILE = "echo 'shell unknown'\n"	3✔
40
41
42	def run_shellcheck(	3✔
43	rule_runner: RuleRunner, targets: list[Target], *, extra_args: list[str] \| None = None
44	) -> tuple[LintResult, ...]:
45	rule_runner.set_options(	3✔
46	["--backend-packages=pants.backend.shell.lint.shellcheck", *(extra_args or ())],
47	env_inherit={"PATH"},
48	)
49	partitions = rule_runner.request(	3✔
50	Partitions[ShellcheckFieldSet, Any],
51	[
52	ShellcheckRequest.PartitionRequest(
53	tuple(ShellcheckFieldSet.create(tgt) for tgt in targets)
54	)
55	],
56	)
57	results = []	3✔
58	for partition in partitions:	3✔
59	result = rule_runner.request(	3✔
60	LintResult,
61	[ShellcheckRequest.Batch("", partition.elements, partition.metadata)],
62	)
63	results.append(result)	3✔
64	return tuple(results)	3✔
65
66
67	def assert_success(	3✔
68	rule_runner: RuleRunner, target: Target, *, extra_args: list[str] \| None = None
69	) -> None:
UNCOV 70	result = run_shellcheck(rule_runner, [target], extra_args=extra_args)	1✔
UNCOV 71	assert len(result) == 1	1✔
UNCOV 72	assert result[0].exit_code == 0	1✔
UNCOV 73	assert not result[0].stdout	1✔
UNCOV 74	assert not result[0].stderr	1✔
75
76
77	def test_passing(rule_runner: RuleRunner) -> None:	3✔
UNCOV 78	rule_runner.write_files({"f.sh": GOOD_FILE, "BUILD": "shell_sources(name='t')"})	1✔
UNCOV 79	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))	1✔
UNCOV 80	assert_success(rule_runner, tgt)	1✔
81
82
83	@pytest.mark.platform_specific_behavior	3✔
84	def test_failing(rule_runner: RuleRunner) -> None:	3✔
85	rule_runner.write_files({"f.sh": BAD_FILE, "BUILD": "shell_sources(name='t')"})	3✔
86	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))	3✔
87	result = run_shellcheck(rule_runner, [tgt])	3✔
88	assert len(result) == 1	3✔
89	assert result[0].exit_code == 1	3✔
90	assert "In f.sh line 1:" in result[0].stdout	3✔
91
92
93	def test_multiple_targets(rule_runner: RuleRunner) -> None:	3✔
UNCOV 94	rule_runner.write_files(	1✔
95	{"good.sh": GOOD_FILE, "bad.sh": BAD_FILE, "BUILD": "shell_sources(name='t')"}
96	)
UNCOV 97	tgts = [	1✔
98	rule_runner.get_target(Address("", target_name="t", relative_file_path="good.sh")),
99	rule_runner.get_target(Address("", target_name="t", relative_file_path="bad.sh")),
100	]
UNCOV 101	result = run_shellcheck(rule_runner, tgts)	1✔
UNCOV 102	assert len(result) == 1	1✔
UNCOV 103	assert result[0].exit_code == 1	1✔
UNCOV 104	assert "good.sh" not in result[0].stdout	1✔
UNCOV 105	assert "In bad.sh line 1:" in result[0].stdout	1✔
106
107
108	def test_config_files(rule_runner: RuleRunner) -> None:	3✔
UNCOV 109	rule_runner.write_files(	1✔
110	{
111	"a/f.sh": BAD_FILE,
112	"a/BUILD": "shell_sources()",
113	"a/.shellcheckrc": "disable=SC2148",
114	"b/f.sh": BAD_FILE,
115	"b/BUILD": "shell_sources()",
116	}
117	)
UNCOV 118	tgts = [	1✔
119	rule_runner.get_target(Address("a", relative_file_path="f.sh")),
120	rule_runner.get_target(Address("b", relative_file_path="f.sh")),
121	]
UNCOV 122	result = run_shellcheck(rule_runner, tgts)	1✔
UNCOV 123	assert len(result) == 1	1✔
UNCOV 124	assert result[0].exit_code == 1	1✔
UNCOV 125	assert "a/f.sh" not in result[0].stdout	1✔
UNCOV 126	assert "In b/f.sh line 1:" in result[0].stdout	1✔
127
128
129	def test_passthrough_args(rule_runner: RuleRunner) -> None:	3✔
UNCOV 130	rule_runner.write_files({"f.sh": BAD_FILE, "BUILD": "shell_sources(name='t')"})	1✔
UNCOV 131	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))	1✔
UNCOV 132	assert_success(rule_runner, tgt, extra_args=["--shellcheck-args=-e SC2148"])	1✔
133
134
135	def test_skip(rule_runner: RuleRunner) -> None:	3✔
UNCOV 136	rule_runner.write_files({"f.sh": BAD_FILE, "BUILD": "shell_sources(name='t')"})	1✔
UNCOV 137	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))	1✔
UNCOV 138	result = run_shellcheck(rule_runner, [tgt], extra_args=["--shellcheck-skip"])	1✔
UNCOV 139	assert not result	1✔
140
141
142	def test_includes_direct_dependencies(rule_runner: RuleRunner) -> None:	3✔
UNCOV 143	rule_runner.write_files(	1✔
144	{
145	"transitive_dep.sh": BAD_FILE,
146	"dep.sh": GOOD_FILE,
147	"f.sh": "# shellcheck shell=bash\nsource dep.sh\n",
148	"BUILD": dedent(
149	"""\
150	shell_sources(name='transitive', sources=['transitive_dep.sh'])
151	shell_sources(name='dep', sources=['dep.sh'], dependencies=[':transitive'])
152	shell_sources(name='t', sources=['f.sh'], dependencies=[':dep'])
153	"""
154	),
155	}
156	)
UNCOV 157	tgt = rule_runner.get_target(Address("", target_name="t", relative_file_path="f.sh"))	1✔
UNCOV 158	assert_success(rule_runner, tgt, extra_args=["--shellcheck-args=--external-sources"])	1✔

pantsbuild / pants / 21552830208

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