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

69.05

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

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

from __future__ import annotations

import os.path
from textwrap import dedent

import pytest

from pants.backend.go import target_type_rules
from pants.backend.go.target_types import GoModTarget
from pants.backend.go.util_rules import (
    assembly,
    build_pkg,
    first_party_pkg,
    go_mod,
    import_analysis,
    link,
    sdk,
    third_party_pkg,
)
from pants.backend.go.util_rules.build_opts import GoBuildOptions
from pants.backend.go.util_rules.build_pkg import (
    BuildGoPackageRequest,
    BuiltGoPackage,
    FallibleBuiltGoPackage,
)
from pants.engine.fs import Snapshot
from pants.engine.rules import QueryRule
from pants.testutil.rule_runner import RuleRunner
from pants.util.strutil import path_safe


@pytest.fixture
def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *sdk.rules(),
            *assembly.rules(),
            *build_pkg.rules(),
            *import_analysis.rules(),
            *go_mod.rules(),
            *first_party_pkg.rules(),
            *link.rules(),
            *third_party_pkg.rules(),
            *target_type_rules.rules(),
            QueryRule(BuiltGoPackage, [BuildGoPackageRequest]),
            QueryRule(FallibleBuiltGoPackage, [BuildGoPackageRequest]),
        ],
        target_types=[GoModTarget],
    )
    rule_runner.set_options([], env_inherit={"PATH"})
    return rule_runner


def assert_built(
    rule_runner: RuleRunner, request: BuildGoPackageRequest, *, expected_import_paths: list[str]
) -> None:
    built_package = rule_runner.request(BuiltGoPackage, [request])
    result_files = rule_runner.request(Snapshot, [built_package.digest]).files
    expected = {
        import_path: os.path.join("__pkgs__", path_safe(import_path), "__pkg__.a")
        for import_path in expected_import_paths
    }
    assert dict(built_package.import_paths_to_pkg_a_files) == expected
    assert sorted(result_files) == sorted(expected.values())


def test_build_pkg(rule_runner: RuleRunner) -> None:
    transitive_dep = BuildGoPackageRequest(
        import_path="example.com/foo/dep/transitive",
        pkg_name="transitive",
        dir_path="dep/transitive",
        build_opts=GoBuildOptions(),
        go_files=("f.go",),
        digest=rule_runner.make_snapshot(
            {
                "dep/transitive/f.go": dedent(
                    """\
                    package transitive

                    func Quote(s string) string {
                        return ">>" + s + "<<"
                    }
                    """
                )
            }
        ).digest,
        s_files=(),
        direct_dependencies=(),
        minimum_go_version="1.21.2",
    )
    direct_dep = BuildGoPackageRequest(
        import_path="example.com/foo/dep",
        pkg_name="dep",
        dir_path="dep",
        build_opts=GoBuildOptions(),
        go_files=("f.go",),
        digest=rule_runner.make_snapshot(
            {
                "dep/f.go": dedent(
                    """\
                    package dep

                    import "example.com/foo/dep/transitive"

                    func Quote(s string) string {
                        return transitive.Quote(s)
                    }
                    """
                )
            }
        ).digest,
        s_files=(),
        direct_dependencies=(transitive_dep,),
        minimum_go_version=None,
    )
    main = BuildGoPackageRequest(
        import_path="example.com/foo",
        pkg_name="foo",
        dir_path="",
        build_opts=GoBuildOptions(),
        go_files=("f.go",),
        digest=rule_runner.make_snapshot(
            {
                "f.go": dedent(
                    """\
                    package foo

                    import "example.com/foo/dep"

                    func main() {
                        dep.Quote("Hello world!")
                    }
                    """
                )
            }
        ).digest,
        s_files=(),
        direct_dependencies=(direct_dep,),
        minimum_go_version=None,
    )

    assert_built(
        rule_runner, transitive_dep, expected_import_paths=["example.com/foo/dep/transitive"]
    )
    assert_built(
        rule_runner,
        direct_dep,
        expected_import_paths=["example.com/foo/dep", "example.com/foo/dep/transitive"],
    )
    assert_built(
        rule_runner,
        main,
        expected_import_paths=[
            "example.com/foo",
            "example.com/foo/dep",
            "example.com/foo/dep/transitive",
        ],
    )


def test_build_invalid_pkg(rule_runner: RuleRunner) -> None:
    invalid_dep = BuildGoPackageRequest(
        import_path="example.com/foo/dep",
        pkg_name="dep",
        dir_path="dep",
        build_opts=GoBuildOptions(),
        go_files=("f.go",),
        digest=rule_runner.make_snapshot({"dep/f.go": "invalid!!!"}).digest,
        s_files=(),
        direct_dependencies=(),
        minimum_go_version=None,
    )
    main = BuildGoPackageRequest(
        import_path="example.com/foo",
        pkg_name="main",
        dir_path="",
        build_opts=GoBuildOptions(),
        go_files=("f.go",),
        digest=rule_runner.make_snapshot(
            {
                "f.go": dedent(
                    """\
                    package main

                    import "example.com/foo/dep"

                    func main() {
                        dep.Quote("Hello world!")
                    }
                    """
                )
            }
        ).digest,
        s_files=(),
        direct_dependencies=(invalid_dep,),
        minimum_go_version=None,
    )

    invalid_direct_result = rule_runner.request(FallibleBuiltGoPackage, [invalid_dep])
    assert invalid_direct_result.output is None
    assert invalid_direct_result.exit_code == 1
    assert (
        invalid_direct_result.stdout
        == "dep/f.go:1:1: syntax error: package statement must be first\n"
    )

    invalid_dep_result = rule_runner.request(FallibleBuiltGoPackage, [main])
    assert invalid_dep_result.output is None
    assert invalid_dep_result.exit_code == 1
    assert (
        invalid_dep_result.stdout == "dep/f.go:1:1: syntax error: package statement must be first\n"
    )

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	import os.path	1✔
7	from textwrap import dedent	1✔
8
9	import pytest	1✔
10
11	from pants.backend.go import target_type_rules	1✔
12	from pants.backend.go.target_types import GoModTarget	1✔
13	from pants.backend.go.util_rules import (	1✔
14	assembly,
15	build_pkg,
16	first_party_pkg,
17	go_mod,
18	import_analysis,
19	link,
20	sdk,
21	third_party_pkg,
22	)
23	from pants.backend.go.util_rules.build_opts import GoBuildOptions	1✔
24	from pants.backend.go.util_rules.build_pkg import (	1✔
25	BuildGoPackageRequest,
26	BuiltGoPackage,
27	FallibleBuiltGoPackage,
28	)
29	from pants.engine.fs import Snapshot	1✔
30	from pants.engine.rules import QueryRule	1✔
31	from pants.testutil.rule_runner import RuleRunner	1✔
32	from pants.util.strutil import path_safe	1✔
33
34
35	@pytest.fixture	1✔
36	def rule_runner() -> RuleRunner:	1✔
37	rule_runner = RuleRunner(	1✔
38	rules=[
39	*sdk.rules(),
40	*assembly.rules(),
41	*build_pkg.rules(),
42	*import_analysis.rules(),
43	*go_mod.rules(),
44	*first_party_pkg.rules(),
45	*link.rules(),
46	*third_party_pkg.rules(),
47	*target_type_rules.rules(),
48	QueryRule(BuiltGoPackage, [BuildGoPackageRequest]),
49	QueryRule(FallibleBuiltGoPackage, [BuildGoPackageRequest]),
50	],
51	target_types=[GoModTarget],
52	)
53	rule_runner.set_options([], env_inherit={"PATH"})	1✔
54	return rule_runner	1✔
55
56
57	def assert_built(	1✔
58	rule_runner: RuleRunner, request: BuildGoPackageRequest, *, expected_import_paths: list[str]
59	) -> None:
60	built_package = rule_runner.request(BuiltGoPackage, [request])	1✔
UNCOV 61	result_files = rule_runner.request(Snapshot, [built_package.digest]).files	×
UNCOV 62	expected = {	×
63	import_path: os.path.join("__pkgs__", path_safe(import_path), "__pkg__.a")
64	for import_path in expected_import_paths
65	}
UNCOV 66	assert dict(built_package.import_paths_to_pkg_a_files) == expected	×
UNCOV 67	assert sorted(result_files) == sorted(expected.values())	×
68
69
70	def test_build_pkg(rule_runner: RuleRunner) -> None:	1✔
71	transitive_dep = BuildGoPackageRequest(	1✔
72	import_path="example.com/foo/dep/transitive",
73	pkg_name="transitive",
74	dir_path="dep/transitive",
75	build_opts=GoBuildOptions(),
76	go_files=("f.go",),
77	digest=rule_runner.make_snapshot(
78	{
79	"dep/transitive/f.go": dedent(
80	"""\
81	package transitive
82
83	func Quote(s string) string {
84	return ">>" + s + "<<"
85	}
86	"""
87	)
88	}
89	).digest,
90	s_files=(),
91	direct_dependencies=(),
92	minimum_go_version="1.21.2",
93	)
94	direct_dep = BuildGoPackageRequest(	1✔
95	import_path="example.com/foo/dep",
96	pkg_name="dep",
97	dir_path="dep",
98	build_opts=GoBuildOptions(),
99	go_files=("f.go",),
100	digest=rule_runner.make_snapshot(
101	{
102	"dep/f.go": dedent(
103	"""\
104	package dep
105
106	import "example.com/foo/dep/transitive"
107
108	func Quote(s string) string {
109	return transitive.Quote(s)
110	}
111	"""
112	)
113	}
114	).digest,
115	s_files=(),
116	direct_dependencies=(transitive_dep,),
117	minimum_go_version=None,
118	)
119	main = BuildGoPackageRequest(	1✔
120	import_path="example.com/foo",
121	pkg_name="foo",
122	dir_path="",
123	build_opts=GoBuildOptions(),
124	go_files=("f.go",),
125	digest=rule_runner.make_snapshot(
126	{
127	"f.go": dedent(
128	"""\
129	package foo
130
131	import "example.com/foo/dep"
132
133	func main() {
134	dep.Quote("Hello world!")
135	}
136	"""
137	)
138	}
139	).digest,
140	s_files=(),
141	direct_dependencies=(direct_dep,),
142	minimum_go_version=None,
143	)
144
145	assert_built(	1✔
146	rule_runner, transitive_dep, expected_import_paths=["example.com/foo/dep/transitive"]
147	)
UNCOV 148	assert_built(	×
149	rule_runner,
150	direct_dep,
151	expected_import_paths=["example.com/foo/dep", "example.com/foo/dep/transitive"],
152	)
UNCOV 153	assert_built(	×
154	rule_runner,
155	main,
156	expected_import_paths=[
157	"example.com/foo",
158	"example.com/foo/dep",
159	"example.com/foo/dep/transitive",
160	],
161	)
162
163
164	def test_build_invalid_pkg(rule_runner: RuleRunner) -> None:	1✔
165	invalid_dep = BuildGoPackageRequest(	1✔
166	import_path="example.com/foo/dep",
167	pkg_name="dep",
168	dir_path="dep",
169	build_opts=GoBuildOptions(),
170	go_files=("f.go",),
171	digest=rule_runner.make_snapshot({"dep/f.go": "invalid!!!"}).digest,
172	s_files=(),
173	direct_dependencies=(),
174	minimum_go_version=None,
175	)
176	main = BuildGoPackageRequest(	1✔
177	import_path="example.com/foo",
178	pkg_name="main",
179	dir_path="",
180	build_opts=GoBuildOptions(),
181	go_files=("f.go",),
182	digest=rule_runner.make_snapshot(
183	{
184	"f.go": dedent(
185	"""\
186	package main
187
188	import "example.com/foo/dep"
189
190	func main() {
191	dep.Quote("Hello world!")
192	}
193	"""
194	)
195	}
196	).digest,
197	s_files=(),
198	direct_dependencies=(invalid_dep,),
199	minimum_go_version=None,
200	)
201
202	invalid_direct_result = rule_runner.request(FallibleBuiltGoPackage, [invalid_dep])	1✔
UNCOV 203	assert invalid_direct_result.output is None	×
UNCOV 204	assert invalid_direct_result.exit_code == 1	×
UNCOV 205	assert (	×
206	invalid_direct_result.stdout
207	== "dep/f.go:1:1: syntax error: package statement must be first\n"
208	)
209
UNCOV 210	invalid_dep_result = rule_runner.request(FallibleBuiltGoPackage, [main])	×
UNCOV 211	assert invalid_dep_result.output is None	×
UNCOV 212	assert invalid_dep_result.exit_code == 1	×
UNCOV 213	assert (	×
214	invalid_dep_result.stdout == "dep/f.go:1:1: syntax error: package statement must be first\n"
215	)

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