18822648545

Committed 26 Oct 2025 07:24PM UTC coverage: 79.831% (-0.4%) from 80.28%

Build # 18822648545

Build Type

Pull #22809

github

Committed by

web-flow

Commit Message

Merge 9401c4830 into 170094e99

Pull Request Pull Request #22809: golang: fix Go SDK version check for coverage experiment

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

439 existing lines in 25 files now uncovered.

77436 of 97000 relevant lines covered (79.83%)

3.35 hits per line

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

42.5

/src/python/pants/backend/go/util_rules/coverage_test.py

# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import annotations

import textwrap

import pytest

from pants.backend.go import target_type_rules
from pants.backend.go.goals.test import GoTestFieldSet, GoTestRequest
from pants.backend.go.goals.test import rules as test_rules
from pants.backend.go.target_types import GoModTarget, GoPackageTarget
from pants.backend.go.util_rules import (
    assembly,
    build_pkg,
    build_pkg_target,
    coverage,
    coverage_output,
    first_party_pkg,
    go_mod,
    link,
    sdk,
    tests_analysis,
    third_party_pkg,
)
from pants.backend.go.util_rules.coverage import GoCoverageData
from pants.backend.go.util_rules.coverage_output import GoCoverageDataCollection
from pants.build_graph.address import Address
from pants.core.goals.test import (
    CoverageReport,
    CoverageReports,
    FilesystemCoverageReport,
    TestResult,
    get_filtered_environment,
)
from pants.core.target_types import FileTarget
from pants.core.util_rules import source_files
from pants.engine.fs import DigestContents
from pants.engine.internals.native_engine import Digest
from pants.engine.rules import QueryRule
from pants.engine.target import Target
from pants.testutil.rule_runner import RuleRunner


@pytest.fixture
def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *test_rules(),
            *assembly.rules(),
            *build_pkg.rules(),
            *build_pkg_target.rules(),
            *coverage.rules(),
            *coverage_output.rules(),
            *first_party_pkg.rules(),
            *go_mod.rules(),
            *link.rules(),
            *sdk.rules(),
            *target_type_rules.rules(),
            *tests_analysis.rules(),
            *third_party_pkg.rules(),
            *source_files.rules(),
            get_filtered_environment,
            QueryRule(TestResult, (GoTestRequest.Batch,)),
            QueryRule(CoverageReports, (GoCoverageDataCollection,)),
            QueryRule(DigestContents, (Digest,)),
        ],
        target_types=[GoModTarget, GoPackageTarget, FileTarget],
    )
    rule_runner.set_options(
        ["--go-test-args=-v -bench=.", "--test-use-coverage"], env_inherit={"PATH"}
    )
    return rule_runner


def test_basic_coverage(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "foo/BUILD": "go_mod(name='mod')\ngo_package()",
            "foo/go.mod": "module foo",
            "foo/add.go": textwrap.dedent(
                """
            package foo
            func add(x, y int) int {
              return x + y
            }
            """
            ),
            "foo/add_test.go": textwrap.dedent(
                """
            package foo
            import "testing"
            func TestAdd(t *testing.T) {
              if add(2, 3) != 5 {
                t.Fail()
              }
            }
            """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("foo"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 0
    assert b"PASS: TestAdd" in result.stdout_bytes
    coverage_data = result.coverage_data
    assert coverage_data is not None
    assert isinstance(coverage_data, GoCoverageData)
    assert coverage_data.import_path == "foo"
    coverage_reports = rule_runner.request(
        CoverageReports, [GoCoverageDataCollection([coverage_data])]
    )
    assert len(coverage_reports.reports) == 2
    reports: list[CoverageReport] = list(coverage_reports.reports)

    go_report = reports[0]
    assert isinstance(go_report, FilesystemCoverageReport)
    digest_contents = rule_runner.request(DigestContents, (go_report.result_snapshot.digest,))
    assert len(digest_contents) == 1
    assert digest_contents[0].path == "cover.out"

    html_report = reports[1]
    assert isinstance(html_report, FilesystemCoverageReport)
    digest_contents = rule_runner.request(DigestContents, (html_report.result_snapshot.digest,))
    assert len(digest_contents) == 1
    assert digest_contents[0].path == "coverage.html"


def test_coverage_of_multiple_packages(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "foo/BUILD": "go_mod(name='mod')\ngo_package()",
            "foo/go.mod": "module foo",
            # `foo/adder` is a separate package so the test can attempt to include it into coverage of the
            # `foo` package.
            "foo/adder/BUILD": "go_package()",
            "foo/adder/add.go": textwrap.dedent(
                """\
            package adder
            func Add(x, y int) int {
              return x + y
            }
            """
            ),
            "foo/add.go": textwrap.dedent(
                """\
                package foo
                import "foo/adder"
                func add(x, y int) int {
                  return adder.Add(x, y)
                }
                """
            ),
            "foo/add_test.go": textwrap.dedent(
                """\
            package foo
            import "testing"
            func TestAdd(t *testing.T) {
              if add(2, 3) != 5 {
                t.Fail()
              }
            }
            """
            ),
        }
    )

    def run_test(tgt: Target) -> str:
        result = rule_runner.request(
            TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
        )
        assert result.exit_code == 0
        assert b"PASS: TestAdd" in result.stdout_bytes
        coverage_data = result.coverage_data
        assert coverage_data is not None
        assert isinstance(coverage_data, GoCoverageData)
        assert coverage_data.import_path == "foo"
        coverage_reports = rule_runner.request(
            CoverageReports, [GoCoverageDataCollection([coverage_data])]
        )
        assert len(coverage_reports.reports) == 2
        reports: list[CoverageReport] = list(coverage_reports.reports)

        go_report = reports[0]
        assert isinstance(go_report, FilesystemCoverageReport)
        digest_contents = rule_runner.request(DigestContents, (go_report.result_snapshot.digest,))
        assert len(digest_contents) == 1
        assert digest_contents[0].path == "cover.out"

        raw_go_report = digest_contents[0].content.decode()

        html_report = reports[1]
        assert isinstance(html_report, FilesystemCoverageReport)
        digest_contents = rule_runner.request(DigestContents, (html_report.result_snapshot.digest,))
        assert len(digest_contents) == 1
        assert digest_contents[0].path == "coverage.html"

        return raw_go_report

    # Test that the `foo/adder` package is missing when it is **not** configured to be covered
    # via the `--go-test-coverage-include-patterns` option.
    tgt = rule_runner.get_target(Address("foo"))
    cover_report = run_test(tgt)
    assert "foo/add.go" in cover_report
    assert "foo/adder/add.go" not in cover_report

    # Then set `--go-test-coverage-include-patterns` to include the `foo/adder` package in coverage.
    # It should now show up in the raw coverage report.
    rule_runner.set_options(
        [
            "--go-test-args=-v -bench=.",
            "--test-use-coverage",
            "--go-test-coverage-packages=foo/adder",
        ],
        env_inherit={"PATH"},
    )
    multi_cover_report = run_test(tgt)
    assert "foo/add.go" in multi_cover_report
    assert "foo/adder/add.go" in multi_cover_report

1	# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3	from __future__ import annotations	1✔
4
5	import textwrap	1✔
6
7	import pytest	1✔
8
9	from pants.backend.go import target_type_rules	1✔
10	from pants.backend.go.goals.test import GoTestFieldSet, GoTestRequest	1✔
11	from pants.backend.go.goals.test import rules as test_rules	1✔
12	from pants.backend.go.target_types import GoModTarget, GoPackageTarget	1✔
13	from pants.backend.go.util_rules import (	1✔
14	assembly,
15	build_pkg,
16	build_pkg_target,
17	coverage,
18	coverage_output,
19	first_party_pkg,
20	go_mod,
21	link,
22	sdk,
23	tests_analysis,
24	third_party_pkg,
25	)
26	from pants.backend.go.util_rules.coverage import GoCoverageData	1✔
27	from pants.backend.go.util_rules.coverage_output import GoCoverageDataCollection	1✔
28	from pants.build_graph.address import Address	1✔
29	from pants.core.goals.test import (	1✔
30	CoverageReport,
31	CoverageReports,
32	FilesystemCoverageReport,
33	TestResult,
34	get_filtered_environment,
35	)
36	from pants.core.target_types import FileTarget	1✔
37	from pants.core.util_rules import source_files	1✔
38	from pants.engine.fs import DigestContents	1✔
39	from pants.engine.internals.native_engine import Digest	1✔
40	from pants.engine.rules import QueryRule	1✔
41	from pants.engine.target import Target	1✔
42	from pants.testutil.rule_runner import RuleRunner	1✔
43
44
45	@pytest.fixture	1✔
46	def rule_runner() -> RuleRunner:	1✔
47	rule_runner = RuleRunner(	1✔
48	rules=[
49	*test_rules(),
50	*assembly.rules(),
51	*build_pkg.rules(),
52	*build_pkg_target.rules(),
53	*coverage.rules(),
54	*coverage_output.rules(),
55	*first_party_pkg.rules(),
56	*go_mod.rules(),
57	*link.rules(),
58	*sdk.rules(),
59	*target_type_rules.rules(),
60	*tests_analysis.rules(),
61	*third_party_pkg.rules(),
62	*source_files.rules(),
63	get_filtered_environment,
64	QueryRule(TestResult, (GoTestRequest.Batch,)),
65	QueryRule(CoverageReports, (GoCoverageDataCollection,)),
66	QueryRule(DigestContents, (Digest,)),
67	],
68	target_types=[GoModTarget, GoPackageTarget, FileTarget],
69	)
70	rule_runner.set_options(	1✔
71	["--go-test-args=-v -bench=.", "--test-use-coverage"], env_inherit={"PATH"}
72	)
73	return rule_runner	1✔
74
75
76	def test_basic_coverage(rule_runner: RuleRunner) -> None:	1✔
77	rule_runner.write_files(	1✔
78	{
79	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
80	"foo/go.mod": "module foo",
81	"foo/add.go": textwrap.dedent(
82	"""
83	package foo
84	func add(x, y int) int {
85	return x + y
86	}
87	"""
88	),
89	"foo/add_test.go": textwrap.dedent(
90	"""
91	package foo
92	import "testing"
93	func TestAdd(t *testing.T) {
94	if add(2, 3) != 5 {
95	t.Fail()
96	}
97	}
98	"""
99	),
100	}
101	)
102	tgt = rule_runner.get_target(Address("foo"))	1✔
103	result = rule_runner.request(	1✔
104	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
105	)
UNCOV 106	assert result.exit_code == 0	×
UNCOV 107	assert b"PASS: TestAdd" in result.stdout_bytes	×
UNCOV 108	coverage_data = result.coverage_data	×
UNCOV 109	assert coverage_data is not None	×
UNCOV 110	assert isinstance(coverage_data, GoCoverageData)	×
UNCOV 111	assert coverage_data.import_path == "foo"	×
UNCOV 112	coverage_reports = rule_runner.request(	×
113	CoverageReports, [GoCoverageDataCollection([coverage_data])]
114	)
UNCOV 115	assert len(coverage_reports.reports) == 2	×
UNCOV 116	reports: list[CoverageReport] = list(coverage_reports.reports)	×
117
UNCOV 118	go_report = reports[0]	×
UNCOV 119	assert isinstance(go_report, FilesystemCoverageReport)	×
UNCOV 120	digest_contents = rule_runner.request(DigestContents, (go_report.result_snapshot.digest,))	×
UNCOV 121	assert len(digest_contents) == 1	×
UNCOV 122	assert digest_contents[0].path == "cover.out"	×
123
UNCOV 124	html_report = reports[1]	×
UNCOV 125	assert isinstance(html_report, FilesystemCoverageReport)	×
UNCOV 126	digest_contents = rule_runner.request(DigestContents, (html_report.result_snapshot.digest,))	×
UNCOV 127	assert len(digest_contents) == 1	×
UNCOV 128	assert digest_contents[0].path == "coverage.html"	×
129
130
131	def test_coverage_of_multiple_packages(rule_runner: RuleRunner) -> None:	1✔
132	rule_runner.write_files(	1✔
133	{
134	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
135	"foo/go.mod": "module foo",
136	# `foo/adder` is a separate package so the test can attempt to include it into coverage of the
137	# `foo` package.
138	"foo/adder/BUILD": "go_package()",
139	"foo/adder/add.go": textwrap.dedent(
140	"""\
141	package adder
142	func Add(x, y int) int {
143	return x + y
144	}
145	"""
146	),
147	"foo/add.go": textwrap.dedent(
148	"""\
149	package foo
150	import "foo/adder"
151	func add(x, y int) int {
152	return adder.Add(x, y)
153	}
154	"""
155	),
156	"foo/add_test.go": textwrap.dedent(
157	"""\
158	package foo
159	import "testing"
160	func TestAdd(t *testing.T) {
161	if add(2, 3) != 5 {
162	t.Fail()
163	}
164	}
165	"""
166	),
167	}
168	)
169
170	def run_test(tgt: Target) -> str:	1✔
171	result = rule_runner.request(	1✔
172	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
173	)
UNCOV 174	assert result.exit_code == 0	×
UNCOV 175	assert b"PASS: TestAdd" in result.stdout_bytes	×
UNCOV 176	coverage_data = result.coverage_data	×
UNCOV 177	assert coverage_data is not None	×
UNCOV 178	assert isinstance(coverage_data, GoCoverageData)	×
UNCOV 179	assert coverage_data.import_path == "foo"	×
UNCOV 180	coverage_reports = rule_runner.request(	×
181	CoverageReports, [GoCoverageDataCollection([coverage_data])]
182	)
UNCOV 183	assert len(coverage_reports.reports) == 2	×
UNCOV 184	reports: list[CoverageReport] = list(coverage_reports.reports)	×
185
UNCOV 186	go_report = reports[0]	×
UNCOV 187	assert isinstance(go_report, FilesystemCoverageReport)	×
UNCOV 188	digest_contents = rule_runner.request(DigestContents, (go_report.result_snapshot.digest,))	×
UNCOV 189	assert len(digest_contents) == 1	×
UNCOV 190	assert digest_contents[0].path == "cover.out"	×
191
UNCOV 192	raw_go_report = digest_contents[0].content.decode()	×
193
UNCOV 194	html_report = reports[1]	×
UNCOV 195	assert isinstance(html_report, FilesystemCoverageReport)	×
UNCOV 196	digest_contents = rule_runner.request(DigestContents, (html_report.result_snapshot.digest,))	×
UNCOV 197	assert len(digest_contents) == 1	×
UNCOV 198	assert digest_contents[0].path == "coverage.html"	×
199
UNCOV 200	return raw_go_report	×
201
202	# Test that the `foo/adder` package is missing when it is not configured to be covered
203	# via the `--go-test-coverage-include-patterns` option.
204	tgt = rule_runner.get_target(Address("foo"))	1✔
205	cover_report = run_test(tgt)	1✔
UNCOV 206	assert "foo/add.go" in cover_report	×
UNCOV 207	assert "foo/adder/add.go" not in cover_report	×
208
209	# Then set `--go-test-coverage-include-patterns` to include the `foo/adder` package in coverage.
210	# It should now show up in the raw coverage report.
UNCOV 211	rule_runner.set_options(	×
212	[
213	"--go-test-args=-v -bench=.",
214	"--test-use-coverage",
215	"--go-test-coverage-packages=foo/adder",
216	],
217	env_inherit={"PATH"},
218	)
UNCOV 219	multi_cover_report = run_test(tgt)	×
UNCOV 220	assert "foo/add.go" in multi_cover_report	×
UNCOV 221	assert "foo/adder/add.go" in multi_cover_report	×

pantsbuild / pants / 18822648545

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