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

80.65

/src/python/pants/backend/go/dependency_inference_test.py

# Copyright 2022 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.go import target_type_rules
from pants.backend.go.dependency_inference import rules as dependency_inference_rules
from pants.backend.go.goals.test import GoTestFieldSet, GoTestRequest
from pants.backend.go.goals.test import (
    rules as rules_for_test,  # Naming this test_rules would cause pytest to attempt to collect tests from it.
)
from pants.backend.go.target_types import GoBinaryTarget, GoModTarget, GoPackageTarget
from pants.backend.go.util_rules import (
    assembly,
    build_pkg,
    build_pkg_target,
    first_party_pkg,
    go_mod,
    implicit_linker_deps,
    link,
    sdk,
    tests_analysis,
    third_party_pkg,
)
from pants.backend.go.util_rules.sdk import GoSdkProcess
from pants.build_graph.address import Address
from pants.core.goals.test import TestResult, get_filtered_environment
from pants.core.util_rules import source_files
from pants.engine.process import ProcessResult
from pants.engine.rules import QueryRule
from pants.testutil.rule_runner import RuleRunner


@pytest.fixture
def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *rules_for_test(),
            *assembly.rules(),
            *build_pkg.rules(),
            *build_pkg_target.rules(),
            *dependency_inference_rules(),
            *first_party_pkg.rules(),
            *go_mod.rules(),
            *link.rules(),
            *implicit_linker_deps.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(ProcessResult, (GoSdkProcess,)),
        ],
        target_types=[GoModTarget, GoPackageTarget, GoBinaryTarget],
    )
    rule_runner.set_options(["--go-test-args=-v"], env_inherit={"PATH"})
    return rule_runner


def test_multiple_go_mod_support(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "foo/BUILD": dedent(
                """\
            go_mod(name="mod")
            go_package()
            """
            ),
            "foo/go.mod": "module foo",
            "foo/add.go": dedent(
                """\
            package foo
            func add(x, y int) int {
              return x + y
            }
            """
            ),
            "foo/add_test.go": dedent(
                """\
            package foo
            import "testing"
            func TestFoo(t *testing.T) {
              if add(2, 3) != 5 {
                t.Fail()
              }
            }
            """
            ),
            "bar/BUILD": dedent(
                """\
            go_mod(name="mod")
            go_package()
            """
            ),
            "bar/go.mod": "module bar",
            "bar/add.go": dedent(
                """\
            package bar
            func add(x, y int) int {
              return x + y
            }
            """
            ),
            "bar/add_test.go": dedent(
                """\
            package bar
            import "testing"
            func TestBar(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: TestFoo" in result.stdout_bytes

    tgt = rule_runner.get_target(Address("bar"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 0
    assert b"PASS: TestBar" in result.stdout_bytes

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	from textwrap import dedent	1✔
6
7	import pytest	1✔
8
9	from pants.backend.go import target_type_rules	1✔
10	from pants.backend.go.dependency_inference import rules as dependency_inference_rules	1✔
11	from pants.backend.go.goals.test import GoTestFieldSet, GoTestRequest	1✔
12	from pants.backend.go.goals.test import (	1✔
13	rules as rules_for_test, # Naming this test_rules would cause pytest to attempt to collect tests from it.
14	)
15	from pants.backend.go.target_types import GoBinaryTarget, GoModTarget, GoPackageTarget	1✔
16	from pants.backend.go.util_rules import (	1✔
17	assembly,
18	build_pkg,
19	build_pkg_target,
20	first_party_pkg,
21	go_mod,
22	implicit_linker_deps,
23	link,
24	sdk,
25	tests_analysis,
26	third_party_pkg,
27	)
28	from pants.backend.go.util_rules.sdk import GoSdkProcess	1✔
29	from pants.build_graph.address import Address	1✔
30	from pants.core.goals.test import TestResult, get_filtered_environment	1✔
31	from pants.core.util_rules import source_files	1✔
32	from pants.engine.process import ProcessResult	1✔
33	from pants.engine.rules import QueryRule	1✔
34	from pants.testutil.rule_runner import RuleRunner	1✔
35
36
37	@pytest.fixture	1✔
38	def rule_runner() -> RuleRunner:	1✔
39	rule_runner = RuleRunner(	1✔
40	rules=[
41	*rules_for_test(),
42	*assembly.rules(),
43	*build_pkg.rules(),
44	*build_pkg_target.rules(),
45	*dependency_inference_rules(),
46	*first_party_pkg.rules(),
47	*go_mod.rules(),
48	*link.rules(),
49	*implicit_linker_deps.rules(),
50	*sdk.rules(),
51	*target_type_rules.rules(),
52	*tests_analysis.rules(),
53	*third_party_pkg.rules(),
54	*source_files.rules(),
55	get_filtered_environment,
56	QueryRule(TestResult, (GoTestRequest.Batch,)),
57	QueryRule(ProcessResult, (GoSdkProcess,)),
58	],
59	target_types=[GoModTarget, GoPackageTarget, GoBinaryTarget],
60	)
61	rule_runner.set_options(["--go-test-args=-v"], env_inherit={"PATH"})	1✔
62	return rule_runner	1✔
63
64
65	def test_multiple_go_mod_support(rule_runner: RuleRunner) -> None:	1✔
66	rule_runner.write_files(	1✔
67	{
68	"foo/BUILD": dedent(
69	"""\
70	go_mod(name="mod")
71	go_package()
72	"""
73	),
74	"foo/go.mod": "module foo",
75	"foo/add.go": dedent(
76	"""\
77	package foo
78	func add(x, y int) int {
79	return x + y
80	}
81	"""
82	),
83	"foo/add_test.go": dedent(
84	"""\
85	package foo
86	import "testing"
87	func TestFoo(t *testing.T) {
88	if add(2, 3) != 5 {
89	t.Fail()
90	}
91	}
92	"""
93	),
94	"bar/BUILD": dedent(
95	"""\
96	go_mod(name="mod")
97	go_package()
98	"""
99	),
100	"bar/go.mod": "module bar",
101	"bar/add.go": dedent(
102	"""\
103	package bar
104	func add(x, y int) int {
105	return x + y
106	}
107	"""
108	),
109	"bar/add_test.go": dedent(
110	"""\
111	package bar
112	import "testing"
113	func TestBar(t *testing.T) {
114	if add(2, 3) != 5 {
115	t.Fail()
116	}
117	}
118	"""
119	),
120	}
121	)
122	tgt = rule_runner.get_target(Address("foo"))	1✔
123	result = rule_runner.request(	1✔
124	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
125	)
UNCOV 126	assert result.exit_code == 0	×
UNCOV 127	assert b"PASS: TestFoo" in result.stdout_bytes	×
128
UNCOV 129	tgt = rule_runner.get_target(Address("bar"))	×
UNCOV 130	result = rule_runner.request(	×
131	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
132	)
UNCOV 133	assert result.exit_code == 0	×
UNCOV 134	assert b"PASS: TestBar" in result.stdout_bytes	×

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