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

75.0

/src/python/pants/backend/go/goals/package_binary_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

import os.path
import subprocess
from textwrap import dedent

import pytest

from pants.backend.go import target_type_rules
from pants.backend.go.goals import package_binary
from pants.backend.go.goals.package_binary import GoBinaryFieldSet
from pants.backend.go.target_types import GoBinaryTarget, GoModTarget, GoPackageTarget
from pants.backend.go.testutil import gen_module_gomodproxy
from pants.backend.go.util_rules import (
    assembly,
    build_pkg,
    build_pkg_target,
    first_party_pkg,
    go_mod,
    import_analysis,
    link,
    sdk,
    third_party_pkg,
)
from pants.core.goals.package import BuiltPackage
from pants.engine.addresses import Address
from pants.engine.rules import QueryRule
from pants.engine.target import Target
from pants.testutil.rule_runner import RuleRunner, engine_error


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


def build_package(rule_runner: RuleRunner, binary_target: Target) -> BuiltPackage:
    field_set = GoBinaryFieldSet.create(binary_target)
    result = rule_runner.request(BuiltPackage, [field_set])
    rule_runner.write_digest(result.digest)
    return result


def test_package_simple(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "go.mod": dedent(
                """\
                module foo.example.com
                go 1.17
                """
            ),
            "main.go": dedent(
                """\
                package main

                import (
                    "fmt"
                )

                func main() {
                    fmt.Println("Hello world!")
                }
                """
            ),
            "BUILD": dedent(
                """\
                go_mod(name='mod')
                go_package(name='pkg')
                go_binary(name='bin')
                """
            ),
        }
    )
    binary_tgt = rule_runner.get_target(Address("", target_name="bin"))
    built_package = build_package(rule_runner, binary_tgt)
    assert len(built_package.artifacts) == 1
    assert built_package.artifacts[0].relpath == "bin"

    result = subprocess.run([os.path.join(rule_runner.build_root, "bin")], stdout=subprocess.PIPE)
    assert result.returncode == 0
    assert result.stdout == b"Hello world!\n"


def test_package_third_party_requires_main(rule_runner: RuleRunner) -> None:
    import_path = "pantsbuild.org/go-sample-for-test"
    version = "v0.0.1"

    fake_gomod = gen_module_gomodproxy(
        version,
        import_path,
        (
            (
                "pkg/hello/hello.go",
                dedent(
                    """\
        package hello
        import "fmt"


        func Hello() {
            fmt.Println("Hello world!")
        }
        """
                ),
            ),
            (
                "cmd/hello/main.go",
                dedent(
                    f"""\
        package main
        import "{import_path}/pkg/hello"


        func main() {{
            hello.Hello()
        }}
        """
                ),
            ),
        ),
    )

    fake_gomod.update(
        {
            "BUILD": dedent(
                f"""\
                go_mod(name='mod')
                go_binary(name="bin", main='//:mod#{import_path}/pkg/hello')
                """
            ),
            "go.mod": dedent(
                f"""\
                module go.example.com/foo
                go 1.16

                require (
                \t{import_path} {version}
                )
                """
            ),
        }
    )

    rule_runner.write_files(fake_gomod)

    rule_runner.set_options(
        [
            "--go-test-args=-v -bench=.",
            f"--golang-subprocess-env-vars=GOPROXY=file://{rule_runner.build_root}/go-mod-proxy",
            "--golang-subprocess-env-vars=GOSUMDB=off",
        ],
        env_inherit={"PATH"},
    )

    binary_tgt = rule_runner.get_target(Address("", target_name="bin"))
    with engine_error(ValueError, contains="but uses package name `hello` instead of `main`"):
        build_package(rule_runner, binary_tgt)


def test_package_third_party_can_run(rule_runner: RuleRunner) -> None:
    import_path = "pantsbuild.org/go-sample-for-test"
    version = "v0.0.1"

    fake_gomod = gen_module_gomodproxy(
        version,
        import_path,
        (
            (
                "pkg/hello/hello.go",
                dedent(
                    """\
        package hello
        import "fmt"


        func Hello() {
            fmt.Println("Hello world!")
        }
        """
                ),
            ),
            (
                "cmd/hello/main.go",
                dedent(
                    f"""\
        package main
        import "{import_path}/pkg/hello"


        func main() {{
            hello.Hello()
        }}
        """
                ),
            ),
        ),
    )

    fake_gomod.update(
        {
            "BUILD": dedent(
                f"""\
                go_mod(name='mod')
                go_binary(name="bin", main='//:mod#{import_path}/cmd/hello')
                """
            ),
            "go.mod": dedent(
                f"""\
                module go.example.com/foo
                go 1.16

                require (
                \t{import_path} {version}
                )
                """
            ),
        }
    )

    rule_runner.write_files(fake_gomod)

    rule_runner.set_options(
        [
            "--go-test-args=-v -bench=.",
            f"--golang-subprocess-env-vars=GOPROXY=file://{rule_runner.build_root}/go-mod-proxy",
            "--golang-subprocess-env-vars=GOSUMDB=off",
        ],
        env_inherit={"PATH"},
    )

    binary_tgt = rule_runner.get_target(Address("", target_name="bin"))
    built_package = build_package(rule_runner, binary_tgt)
    assert len(built_package.artifacts) == 1
    assert built_package.artifacts[0].relpath == "bin"

    result = subprocess.run([os.path.join(rule_runner.build_root, "bin")], stdout=subprocess.PIPE)
    assert result.returncode == 0
    assert result.stdout == b"Hello world!\n"


def test_package_with_dependencies(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "lib/lib.go": dedent(
                """\
                package lib

                import (
                    "fmt"
                    "rsc.io/quote"
                )

                func Quote(s string) string {
                    return fmt.Sprintf(">> %s <<", s)
                }

                func GoProverb() string {
                    return quote.Go()
                }
                """
            ),
            "lib/BUILD": "go_package()",
            "main.go": dedent(
                """\
                package main

                import (
                    "fmt"
                    "foo.example.com/lib"
                )

                func main() {
                    fmt.Println(lib.Quote("Hello world!"))
                    fmt.Println(lib.GoProverb())
                }
                """
            ),
            "go.mod": dedent(
                """\
                module foo.example.com
                go 1.17
                require (
                    golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c // indirect
                    rsc.io/quote v1.5.2
                    rsc.io/sampler v1.3.0 // indirect
                )
                """
            ),
            "go.sum": dedent(
                """\
                golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c h1:qgOY6WgZOaTkIIMiVjBQcw93ERBE4m30iBm00nkL0i8=
                golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
                rsc.io/quote v1.5.2 h1:w5fcysjrx7yqtD/aO+QwRjYZOKnaM9Uh2b40tElTs3Y=
                rsc.io/quote v1.5.2/go.mod h1:LzX7hefJvL54yjefDEDHNONDjII0t9xZLPXsUe+TKr0=
                rsc.io/sampler v1.3.0 h1:7uVkIFmeBqHfdjD+gZwtXXI+RODJ2Wc4O7MPEh/QiW4=
                rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
                """
            ),
            "BUILD": dedent(
                """\
                go_mod(name='mod')
                go_package(name='pkg')
                go_binary(name='bin')
                """
            ),
        }
    )
    binary_tgt = rule_runner.get_target(Address("", target_name="bin"))
    built_package = build_package(rule_runner, binary_tgt)
    assert len(built_package.artifacts) == 1
    assert built_package.artifacts[0].relpath == "bin"

    result = subprocess.run([os.path.join(rule_runner.build_root, "bin")], stdout=subprocess.PIPE)
    assert result.returncode == 0
    assert result.stdout == (
        b">> Hello world! <<\nDon't communicate by sharing memory, share memory by communicating.\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	import subprocess	1✔
8	from textwrap import dedent	1✔
9
10	import pytest	1✔
11
12	from pants.backend.go import target_type_rules	1✔
13	from pants.backend.go.goals import package_binary	1✔
14	from pants.backend.go.goals.package_binary import GoBinaryFieldSet	1✔
15	from pants.backend.go.target_types import GoBinaryTarget, GoModTarget, GoPackageTarget	1✔
16	from pants.backend.go.testutil import gen_module_gomodproxy	1✔
17	from pants.backend.go.util_rules import (	1✔
18	assembly,
19	build_pkg,
20	build_pkg_target,
21	first_party_pkg,
22	go_mod,
23	import_analysis,
24	link,
25	sdk,
26	third_party_pkg,
27	)
28	from pants.core.goals.package import BuiltPackage	1✔
29	from pants.engine.addresses import Address	1✔
30	from pants.engine.rules import QueryRule	1✔
31	from pants.engine.target import Target	1✔
32	from pants.testutil.rule_runner import RuleRunner, engine_error	1✔
33
34
35	@pytest.fixture()	1✔
36	def rule_runner() -> RuleRunner:	1✔
37	rule_runner = RuleRunner(	1✔
38	rules=[
39	*assembly.rules(),
40	*import_analysis.rules(),
41	*package_binary.rules(),
42	*build_pkg.rules(),
43	*build_pkg_target.rules(),
44	*first_party_pkg.rules(),
45	*go_mod.rules(),
46	*link.rules(),
47	*target_type_rules.rules(),
48	*third_party_pkg.rules(),
49	*sdk.rules(),
50	QueryRule(BuiltPackage, (GoBinaryFieldSet,)),
51	],
52	target_types=[
53	GoBinaryTarget,
54	GoModTarget,
55	GoPackageTarget,
56	],
57	)
58	rule_runner.set_options([], env_inherit={"PATH"})	1✔
59	return rule_runner	1✔
60
61
62	def build_package(rule_runner: RuleRunner, binary_target: Target) -> BuiltPackage:	1✔
63	field_set = GoBinaryFieldSet.create(binary_target)	1✔
64	result = rule_runner.request(BuiltPackage, [field_set])	1✔
UNCOV 65	rule_runner.write_digest(result.digest)	×
UNCOV 66	return result	×
67
68
69	def test_package_simple(rule_runner: RuleRunner) -> None:	1✔
70	rule_runner.write_files(	1✔
71	{
72	"go.mod": dedent(
73	"""\
74	module foo.example.com
75	go 1.17
76	"""
77	),
78	"main.go": dedent(
79	"""\
80	package main
81
82	import (
83	"fmt"
84	)
85
86	func main() {
87	fmt.Println("Hello world!")
88	}
89	"""
90	),
91	"BUILD": dedent(
92	"""\
93	go_mod(name='mod')
94	go_package(name='pkg')
95	go_binary(name='bin')
96	"""
97	),
98	}
99	)
100	binary_tgt = rule_runner.get_target(Address("", target_name="bin"))	1✔
101	built_package = build_package(rule_runner, binary_tgt)	1✔
UNCOV 102	assert len(built_package.artifacts) == 1	×
UNCOV 103	assert built_package.artifacts[0].relpath == "bin"	×
104
UNCOV 105	result = subprocess.run([os.path.join(rule_runner.build_root, "bin")], stdout=subprocess.PIPE)	×
UNCOV 106	assert result.returncode == 0	×
UNCOV 107	assert result.stdout == b"Hello world!\n"	×
108
109
110	def test_package_third_party_requires_main(rule_runner: RuleRunner) -> None:	1✔
111	import_path = "pantsbuild.org/go-sample-for-test"	1✔
112	version = "v0.0.1"	1✔
113
114	fake_gomod = gen_module_gomodproxy(	1✔
115	version,
116	import_path,
117	(
118	(
119	"pkg/hello/hello.go",
120	dedent(
121	"""\
122	package hello
123	import "fmt"
124
125
126	func Hello() {
127	fmt.Println("Hello world!")
128	}
129	"""
130	),
131	),
132	(
133	"cmd/hello/main.go",
134	dedent(
135	f"""\
136	package main
137	import "{import_path}/pkg/hello"
138
139
140	func main() {{
141	hello.Hello()
142	}}
143	"""
144	),
145	),
146	),
147	)
148
149	fake_gomod.update(	1✔
150	{
151	"BUILD": dedent(
152	f"""\
153	go_mod(name='mod')
154	go_binary(name="bin", main='//:mod#{import_path}/pkg/hello')
155	"""
156	),
157	"go.mod": dedent(
158	f"""\
159	module go.example.com/foo
160	go 1.16
161
162	require (
163	\t{import_path} {version}
164	)
165	"""
166	),
167	}
168	)
169
170	rule_runner.write_files(fake_gomod)	1✔
171
172	rule_runner.set_options(	1✔
173	[
174	"--go-test-args=-v -bench=.",
175	f"--golang-subprocess-env-vars=GOPROXY=file://{rule_runner.build_root}/go-mod-proxy",
176	"--golang-subprocess-env-vars=GOSUMDB=off",
177	],
178	env_inherit={"PATH"},
179	)
180
181	binary_tgt = rule_runner.get_target(Address("", target_name="bin"))	1✔
182	with engine_error(ValueError, contains="but uses package name `hello` instead of `main`"):	1✔
183	build_package(rule_runner, binary_tgt)	1✔
184
185
186	def test_package_third_party_can_run(rule_runner: RuleRunner) -> None:	1✔
187	import_path = "pantsbuild.org/go-sample-for-test"	1✔
188	version = "v0.0.1"	1✔
189
190	fake_gomod = gen_module_gomodproxy(	1✔
191	version,
192	import_path,
193	(
194	(
195	"pkg/hello/hello.go",
196	dedent(
197	"""\
198	package hello
199	import "fmt"
200
201
202	func Hello() {
203	fmt.Println("Hello world!")
204	}
205	"""
206	),
207	),
208	(
209	"cmd/hello/main.go",
210	dedent(
211	f"""\
212	package main
213	import "{import_path}/pkg/hello"
214
215
216	func main() {{
217	hello.Hello()
218	}}
219	"""
220	),
221	),
222	),
223	)
224
225	fake_gomod.update(	1✔
226	{
227	"BUILD": dedent(
228	f"""\
229	go_mod(name='mod')
230	go_binary(name="bin", main='//:mod#{import_path}/cmd/hello')
231	"""
232	),
233	"go.mod": dedent(
234	f"""\
235	module go.example.com/foo
236	go 1.16
237
238	require (
239	\t{import_path} {version}
240	)
241	"""
242	),
243	}
244	)
245
246	rule_runner.write_files(fake_gomod)	1✔
247
248	rule_runner.set_options(	1✔
249	[
250	"--go-test-args=-v -bench=.",
251	f"--golang-subprocess-env-vars=GOPROXY=file://{rule_runner.build_root}/go-mod-proxy",
252	"--golang-subprocess-env-vars=GOSUMDB=off",
253	],
254	env_inherit={"PATH"},
255	)
256
257	binary_tgt = rule_runner.get_target(Address("", target_name="bin"))	1✔
258	built_package = build_package(rule_runner, binary_tgt)	1✔
UNCOV 259	assert len(built_package.artifacts) == 1	×
UNCOV 260	assert built_package.artifacts[0].relpath == "bin"	×
261
UNCOV 262	result = subprocess.run([os.path.join(rule_runner.build_root, "bin")], stdout=subprocess.PIPE)	×
UNCOV 263	assert result.returncode == 0	×
UNCOV 264	assert result.stdout == b"Hello world!\n"	×
265
266
267	def test_package_with_dependencies(rule_runner: RuleRunner) -> None:	1✔
268	rule_runner.write_files(	1✔
269	{
270	"lib/lib.go": dedent(
271	"""\
272	package lib
273
274	import (
275	"fmt"
276	"rsc.io/quote"
277	)
278
279	func Quote(s string) string {
280	return fmt.Sprintf(">> %s <<", s)
281	}
282
283	func GoProverb() string {
284	return quote.Go()
285	}
286	"""
287	),
288	"lib/BUILD": "go_package()",
289	"main.go": dedent(
290	"""\
291	package main
292
293	import (
294	"fmt"
295	"foo.example.com/lib"
296	)
297
298	func main() {
299	fmt.Println(lib.Quote("Hello world!"))
300	fmt.Println(lib.GoProverb())
301	}
302	"""
303	),
304	"go.mod": dedent(
305	"""\
306	module foo.example.com
307	go 1.17
308	require (
309	golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c // indirect
310	rsc.io/quote v1.5.2
311	rsc.io/sampler v1.3.0 // indirect
312	)
313	"""
314	),
315	"go.sum": dedent(
316	"""\
317	golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c h1:qgOY6WgZOaTkIIMiVjBQcw93ERBE4m30iBm00nkL0i8=
318	golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
319	rsc.io/quote v1.5.2 h1:w5fcysjrx7yqtD/aO+QwRjYZOKnaM9Uh2b40tElTs3Y=
320	rsc.io/quote v1.5.2/go.mod h1:LzX7hefJvL54yjefDEDHNONDjII0t9xZLPXsUe+TKr0=
321	rsc.io/sampler v1.3.0 h1:7uVkIFmeBqHfdjD+gZwtXXI+RODJ2Wc4O7MPEh/QiW4=
322	rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
323	"""
324	),
325	"BUILD": dedent(
326	"""\
327	go_mod(name='mod')
328	go_package(name='pkg')
329	go_binary(name='bin')
330	"""
331	),
332	}
333	)
334	binary_tgt = rule_runner.get_target(Address("", target_name="bin"))	1✔
335	built_package = build_package(rule_runner, binary_tgt)	1✔
UNCOV 336	assert len(built_package.artifacts) == 1	×
UNCOV 337	assert built_package.artifacts[0].relpath == "bin"	×
338
UNCOV 339	result = subprocess.run([os.path.join(rule_runner.build_root, "bin")], stdout=subprocess.PIPE)	×
UNCOV 340	assert result.returncode == 0	×
UNCOV 341	assert result.stdout == (	×
342	b">> Hello world! <<\nDon't communicate by sharing memory, share memory by communicating.\n"
343	)

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