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

67.13

/src/python/pants/backend/go/goals/test_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 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.goals.test import transform_test_args
from pants.backend.go.target_types import GoModTarget, GoPackageTarget
from pants.backend.go.util_rules import (
    assembly,
    build_pkg,
    build_pkg_target,
    first_party_pkg,
    go_mod,
    implicit_linker_deps,
    import_analysis,
    link,
    sdk,
    tests_analysis,
    third_party_pkg,
)
from pants.backend.go.util_rules.sdk import GoSdkProcess
from pants.core.goals.test import TestResult, get_filtered_environment
from pants.core.target_types import FileTarget
from pants.core.util_rules import source_files
from pants.engine.addresses import Address
from pants.engine.process import ProcessResult
from pants.testutil.rule_runner import QueryRule, RuleRunner

ATTEMPTS_DEFAULT_OPTION = 2


@pytest.fixture
def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *test_rules(),
            *assembly.rules(),
            *build_pkg.rules(),
            *build_pkg_target.rules(),
            *first_party_pkg.rules(),
            *go_mod.rules(),
            *link.rules(),
            *import_analysis.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, FileTarget],
    )
    rule_runner.set_options(
        ["--go-test-args=-v -bench=.", f"--test-attempts-default={ATTEMPTS_DEFAULT_OPTION}"],
        env_inherit={"PATH"},
    )
    return rule_runner


def test_transform_test_args() -> None:
    assert transform_test_args(["-v", "--", "-v"], timeout_field_value=None) == (
        "-test.v",
        "--",
        "-v",
    )
    assert transform_test_args(["-run=TestFoo", "-v"], timeout_field_value=None) == (
        "-test.run=TestFoo",
        "-test.v",
    )
    assert transform_test_args(["-run", "TestFoo", "-foo", "-v"], timeout_field_value=None) == (
        "-test.run",
        "TestFoo",
        "-foo",
        "-test.v",
    )

    assert transform_test_args(["-timeout=1m", "-v"], timeout_field_value=None) == (
        "-test.timeout=1m",
        "-test.v",
    )
    assert transform_test_args(["-timeout", "1m", "-v"], timeout_field_value=None) == (
        "-test.timeout",
        "1m",
        "-test.v",
    )
    assert transform_test_args(["-v"], timeout_field_value=100) == ("-test.v", "-test.timeout=100s")
    assert transform_test_args(["-timeout=1m", "-v"], timeout_field_value=100) == (
        "-test.timeout=1m",
        "-test.v",
    )
    assert transform_test_args(["-timeout", "1m", "-v"], timeout_field_value=100) == (
        "-test.timeout",
        "1m",
        "-test.v",
    )


def test_all_the_tests_are_successful(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
                }
                func Add(x, y int) int {
                  return add(x, y)
                }
                """
            ),
            "foo/fib.go": textwrap.dedent(
                """
                package foo
                func Fib(n int) int {
                  if n < 2 {
                    return n
                  }
                  return Fib(n-1) + Fib(n-2)
                }
                """
            ),
            "foo/internal_test.go": textwrap.dedent(
                """
                package foo

                import (
                   "fmt"
                   "testing"
                )

                func TestAddInternal(t *testing.T) {
                  if add(2, 3) != 5 {
                    t.Fail()
                  }
                }

                func BenchmarkAddInternal(b *testing.B) {
                  for n := 0; n < b.N; n++ {
                    Fib(10)
                  }
                }

                func ExamplePrintInternal() {
                  fmt.Println("foo")
                  // Output: foo
                }
                """
            ),
            "foo/external_test.go": textwrap.dedent(
                """
                package foo_test

                import (
                   "foo"

                   "fmt"
                   "testing"
                )

                func TestAddExternal(t *testing.T) {
                  if foo.Add(2, 3) != 5 {
                    t.Fail()
                  }
                }

                func BenchmarkAddExternal(b *testing.B) {
                  for n := 0; n < b.N; n++ {
                    foo.Fib(10)
                  }
                }

                func ExamplePrintExternal() {
                  fmt.Println("foo")
                  // Output: foo
                }
                """
            ),
        }
    )
    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: TestAddInternal" in result.stdout_bytes
    assert b"PASS: ExamplePrintInternal" in result.stdout_bytes
    assert b"BenchmarkAddInternal" in result.stdout_bytes
    assert b"PASS: TestAddExternal" in result.stdout_bytes
    assert b"PASS: ExamplePrintExternal" in result.stdout_bytes
    assert b"BenchmarkAddExternal" in result.stdout_bytes


def test_internal_test_fails(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "foo/BUILD": "go_mod(name='mod')\ngo_package()",
            "foo/go.mod": "module foo",
            "foo/bar_test.go": textwrap.dedent(
                """
                package foo
                import "testing"
                func TestAdd(t *testing.T) {
                  t.Fail()
                }
                """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("foo"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 1
    assert b"FAIL: TestAdd" in result.stdout_bytes
    assert len(result.process_results) == ATTEMPTS_DEFAULT_OPTION


def test_internal_test_with_test_main(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "foo/BUILD": "go_mod(name='mod')\ngo_package()",
            "foo/go.mod": "module foo",
            "foo/add_test.go": textwrap.dedent(
                """
                package foo
                import (
                  "fmt"
                  "testing"
                )
                func TestAdd(t *testing.T) {
                  t.Fail()
                }
                func TestMain(m *testing.M) {
                  fmt.Println("foo.TestMain called")
                  m.Run()
                }
                """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("foo"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 1
    assert b"foo.TestMain called" in result.stdout_bytes
    assert b"FAIL: TestAdd" in result.stdout_bytes


def test_internal_test_fails_to_compile(rule_runner: RuleRunner) -> None:
    """A compilation failure should not cause Pants to error, only the test to fail."""
    rule_runner.write_files(
        {
            "foo/BUILD": "go_mod(name='mod')\ngo_package()",
            "foo/go.mod": "module foo",
            # Test itself is bad.
            "foo/bad_test.go": "invalid!!!",
            # A dependency of the test is bad.
            "foo/dep/f.go": "invalid!!!",
            "foo/dep/BUILD": "go_package()",
            "foo/uses_dep/BUILD": "go_package()",
            "foo/uses_dep/f_test.go": textwrap.dedent(
                """
                package uses_dep

                import (
                  "foo/dep"
                  "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 == 1
    assert b"bad_test.go:1:1: expected 'package', found invalid\n" in result.stderr_bytes

    tgt = rule_runner.get_target(Address("foo/uses_dep"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 1
    assert b"dep/f.go:1:1: expected 'package', found invalid\n" in result.stderr_bytes


def test_external_test_fails(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_test
                import (
                  _ "foo"
                  "testing"
                )
                func TestAdd(t *testing.T) {
                  t.Fail()
                }
                """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("foo", generated_name="./"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 1
    assert b"FAIL: TestAdd" in result.stdout_bytes
    assert len(result.process_results) == ATTEMPTS_DEFAULT_OPTION


def test_external_test_with_test_main(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_test
                import (
                  "foo"
                  "fmt"
                  "testing"
                )
                func TestAdd(t *testing.T) {
                  if foo.Add(2, 3) != 5 {
                    t.Fail()
                  }
                }
                func TestMain(m *testing.M) {
                  fmt.Println("foo_test.TestMain called")
                  m.Run()
                }
                """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("foo", generated_name="./"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 0
    assert b"foo_test.TestMain called" in result.stdout_bytes


def test_both_internal_and_external_tests_fail(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_int_test.go": textwrap.dedent(
                """
                package foo
                import (
                  "testing"
                )
                func TestAddInternal(t *testing.T) {
                  t.Fail()
                }
                """
            ),
            "foo/add_ext_test.go": textwrap.dedent(
                """
                package foo_test
                import (
                  _ "foo"
                  "testing"
                )
                func TestAddExternal(t *testing.T) {
                  t.Fail()
                }
                """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("foo"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 1
    assert b"FAIL: TestAddInternal" in result.stdout_bytes
    assert b"FAIL: TestAddExternal" in result.stdout_bytes
    assert len(result.process_results) == ATTEMPTS_DEFAULT_OPTION


@pytest.mark.no_error_if_skipped
def test_fuzz_target_supported(rule_runner: RuleRunner) -> None:
    go_version_result = rule_runner.request(
        ProcessResult, [GoSdkProcess(["version"], description="Get `go` version.")]
    )
    if "go1.18" not in go_version_result.stdout.decode():
        pytest.skip("Skipping because Go SDK is not 1.18 or higher.")

    rule_runner.write_files(
        {
            "foo/BUILD": "go_mod(name='mod')\ngo_package()",
            "foo/go.mod": "module foo",
            "foo/fuzz_test.go": textwrap.dedent(
                """
                package foo
                import (
                  "testing"
                )
                func FuzzFoo(f *testing.F) {
                  f.Add("foo")
                  f.Fuzz(func(t *testing.T, v string) {
                    if v != "foo" {
                      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: FuzzFoo" in result.stdout_bytes


def test_extra_env_vars(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "foo/BUILD": textwrap.dedent(
                """
                go_mod(name='mod')
                go_package(
                    test_extra_env_vars=(
                        "GO_PACKAGE_VAR_WITHOUT_VALUE",
                        "GO_PACKAGE_VAR_WITH_VALUE=go_package_var_with_value",
                        "GO_PACKAGE_OVERRIDE_WITH_VALUE_VAR=go_package_override_with_value_var_override",
                    )
                )
                """
            ),
            "foo/go.mod": "module foo",
            "foo/add.go": textwrap.dedent(
                """
                package foo
                import "os"
                func envIs(e, v string) bool {
                  return (os.Getenv(e) == v)
                }
                """
            ),
            "foo/add_test.go": textwrap.dedent(
                """
                package foo
                import "testing"
                func TestEnvs(t *testing.T) {
                  if !envIs("ARG_WITH_VALUE_VAR", "arg_with_value_var") {
                      t.Fail()
                  }
                  if !envIs("ARG_WITHOUT_VALUE_VAR", "arg_without_value_var") {
                      t.Fail()
                  }
                  if !envIs("GO_PACKAGE_VAR_WITH_VALUE", "go_package_var_with_value") {
                      t.Fail()
                  }
                  if !envIs("GO_PACKAGE_VAR_WITHOUT_VALUE", "go_package_var_without_value") {
                      t.Fail()
                  }
                  if !envIs("GO_PACKAGE_OVERRIDE_WITH_VALUE_VAR", "go_package_override_with_value_var_override") {
                      t.Fail()
                  }
                }
                """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("foo"))
    rule_runner.set_options(
        args=[
            "--go-test-args=-v -bench=.",
            '--test-extra-env-vars=["ARG_WITH_VALUE_VAR=arg_with_value_var", "ARG_WITHOUT_VALUE_VAR", "GO_PACKAGE_OVERRIDE_ARG_WITH_VALUE_VAR"]',
        ],
        env={
            "ARG_WITHOUT_VALUE_VAR": "arg_without_value_var",
            "GO_PACKAGE_VAR_WITHOUT_VALUE": "go_package_var_without_value",
            "GO_PACKAGE_OVERRIDE_WITH_VALUE_VAR": "go_package_override_with_value_var",
        },
        env_inherit={"PATH"},
    )
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 0
    assert b"PASS: TestEnvs" in result.stdout_bytes


def test_skip_tests(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "f_test.go": "",
            "BUILD": textwrap.dedent(
                """\
                go_package(name='run')
                go_package(name='skip', skip_tests=True)
                """
            ),
        }
    )

    def is_applicable(tgt_name: str) -> bool:
        tgt = rule_runner.get_target(Address("", target_name=tgt_name))
        return GoTestFieldSet.is_applicable(tgt)

    assert is_applicable("run")
    assert not is_applicable("skip")


def test_no_tests(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
                }
                """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("foo"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code is None


def test_compilation_error(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 == 1
    assert b"failed to parse" in result.stderr_bytes


def test_file_dependencies(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "f.txt": "",
            "BUILD": "file(name='root', source='f.txt')",
            "foo/BUILD": textwrap.dedent(
                """
                go_mod(name='mod')
                go_package(dependencies=[":testdata", "//:root"])
                file(name="testdata", source="testdata/f.txt")
                """
            ),
            "foo/go.mod": "module foo",
            "foo/foo_test.go": textwrap.dedent(
                """
                package foo
                import (
                  "os"
                  "testing"
                )

                func TestFilesAvailable(t *testing.T) {
                  _, err1 := os.Stat("testdata/f.txt")
                  if err1 != nil {
                    t.Fatalf("Could not stat foo/testdata/f.txt: %v", err1)
                  }
                  _, err2 := os.Stat("../f.txt")
                  if err2 != nil {
                    t.Fatalf("Could not stat f.txt: %v", err2)
                  }
                }
                """
            ),
            "foo/testdata/f.txt": "",
        }
    )
    tgt = rule_runner.get_target(Address("foo"))
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 0


def test_profile_options_write_results(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()
                  }
                }
                """
            ),
        }
    )
    rule_runner.set_options(
        [
            "--go-test-args=-v -bench=.",
            "--go-test-block-profile",
            "--go-test-cpu-profile",
            "--go-test-mem-profile",
            "--go-test-mutex-profile",
            "--go-test-trace",
        ],
        env_inherit={"PATH"},
    )
    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

    extra_output = result.extra_output
    assert extra_output is not None
    assert sorted(extra_output.files) == [
        "block.out",
        "cpu.out",
        "mem.out",
        "mutex.out",
        "test_runner",
        "trace.out",
    ]


def test_external_test_with_use_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_test
                import (
                  "foo"
                  "testing"
                )
                func TestAdd(t *testing.T) {
                  if foo.Add(2, 3) != 5 {
                    t.Fail()
                  }
                }
                """
            ),
        }
    )
    tgt = rule_runner.get_target(Address("foo", generated_name="./"))
    rule_runner.set_options(
        [
            "--test-use-coverage",
        ],
        env_inherit={"PATH"},
    )
    result = rule_runner.request(
        TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
    )
    assert result.exit_code == 0

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 textwrap	1✔
7
8	import pytest	1✔
9
10	from pants.backend.go import target_type_rules	1✔
11	from pants.backend.go.goals.test import GoTestFieldSet, GoTestRequest	1✔
12	from pants.backend.go.goals.test import rules as test_rules	1✔
13	from pants.backend.go.goals.test import transform_test_args	1✔
14	from pants.backend.go.target_types import GoModTarget, GoPackageTarget	1✔
15	from pants.backend.go.util_rules import (	1✔
16	assembly,
17	build_pkg,
18	build_pkg_target,
19	first_party_pkg,
20	go_mod,
21	implicit_linker_deps,
22	import_analysis,
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.core.goals.test import TestResult, get_filtered_environment	1✔
30	from pants.core.target_types import FileTarget	1✔
31	from pants.core.util_rules import source_files	1✔
32	from pants.engine.addresses import Address	1✔
33	from pants.engine.process import ProcessResult	1✔
34	from pants.testutil.rule_runner import QueryRule, RuleRunner	1✔
35
36	ATTEMPTS_DEFAULT_OPTION = 2	1✔
37
38
39	@pytest.fixture	1✔
40	def rule_runner() -> RuleRunner:	1✔
41	rule_runner = RuleRunner(	1✔
42	rules=[
43	*test_rules(),
44	*assembly.rules(),
45	*build_pkg.rules(),
46	*build_pkg_target.rules(),
47	*first_party_pkg.rules(),
48	*go_mod.rules(),
49	*link.rules(),
50	*import_analysis.rules(),
51	*implicit_linker_deps.rules(),
52	*sdk.rules(),
53	*target_type_rules.rules(),
54	*tests_analysis.rules(),
55	*third_party_pkg.rules(),
56	*source_files.rules(),
57	get_filtered_environment,
58	QueryRule(TestResult, [GoTestRequest.Batch]),
59	QueryRule(ProcessResult, [GoSdkProcess]),
60	],
61	target_types=[GoModTarget, GoPackageTarget, FileTarget],
62	)
63	rule_runner.set_options(	1✔
64	["--go-test-args=-v -bench=.", f"--test-attempts-default={ATTEMPTS_DEFAULT_OPTION}"],
65	env_inherit={"PATH"},
66	)
67	return rule_runner	1✔
68
69
70	def test_transform_test_args() -> None:	1✔
71	assert transform_test_args(["-v", "--", "-v"], timeout_field_value=None) == (	1✔
72	"-test.v",
73	"--",
74	"-v",
75	)
76	assert transform_test_args(["-run=TestFoo", "-v"], timeout_field_value=None) == (	1✔
77	"-test.run=TestFoo",
78	"-test.v",
79	)
80	assert transform_test_args(["-run", "TestFoo", "-foo", "-v"], timeout_field_value=None) == (	1✔
81	"-test.run",
82	"TestFoo",
83	"-foo",
84	"-test.v",
85	)
86
87	assert transform_test_args(["-timeout=1m", "-v"], timeout_field_value=None) == (	1✔
88	"-test.timeout=1m",
89	"-test.v",
90	)
91	assert transform_test_args(["-timeout", "1m", "-v"], timeout_field_value=None) == (	1✔
92	"-test.timeout",
93	"1m",
94	"-test.v",
95	)
96	assert transform_test_args(["-v"], timeout_field_value=100) == ("-test.v", "-test.timeout=100s")	1✔
97	assert transform_test_args(["-timeout=1m", "-v"], timeout_field_value=100) == (	1✔
98	"-test.timeout=1m",
99	"-test.v",
100	)
101	assert transform_test_args(["-timeout", "1m", "-v"], timeout_field_value=100) == (	1✔
102	"-test.timeout",
103	"1m",
104	"-test.v",
105	)
106
107
108	def test_all_the_tests_are_successful(rule_runner: RuleRunner) -> None:	1✔
109	rule_runner.write_files(	1✔
110	{
111	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
112	"foo/go.mod": "module foo",
113	"foo/add.go": textwrap.dedent(
114	"""
115	package foo
116	func add(x, y int) int {
117	return x + y
118	}
119	func Add(x, y int) int {
120	return add(x, y)
121	}
122	"""
123	),
124	"foo/fib.go": textwrap.dedent(
125	"""
126	package foo
127	func Fib(n int) int {
128	if n < 2 {
129	return n
130	}
131	return Fib(n-1) + Fib(n-2)
132	}
133	"""
134	),
135	"foo/internal_test.go": textwrap.dedent(
136	"""
137	package foo
138
139	import (
140	"fmt"
141	"testing"
142	)
143
144	func TestAddInternal(t *testing.T) {
145	if add(2, 3) != 5 {
146	t.Fail()
147	}
148	}
149
150	func BenchmarkAddInternal(b *testing.B) {
151	for n := 0; n < b.N; n++ {
152	Fib(10)
153	}
154	}
155
156	func ExamplePrintInternal() {
157	fmt.Println("foo")
158	// Output: foo
159	}
160	"""
161	),
162	"foo/external_test.go": textwrap.dedent(
163	"""
164	package foo_test
165
166	import (
167	"foo"
168
169	"fmt"
170	"testing"
171	)
172
173	func TestAddExternal(t *testing.T) {
174	if foo.Add(2, 3) != 5 {
175	t.Fail()
176	}
177	}
178
179	func BenchmarkAddExternal(b *testing.B) {
180	for n := 0; n < b.N; n++ {
181	foo.Fib(10)
182	}
183	}
184
185	func ExamplePrintExternal() {
186	fmt.Println("foo")
187	// Output: foo
188	}
189	"""
190	),
191	}
192	)
193	tgt = rule_runner.get_target(Address("foo"))	1✔
194	result = rule_runner.request(	1✔
195	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
196	)
UNCOV 197	assert result.exit_code == 0	×
UNCOV 198	assert b"PASS: TestAddInternal" in result.stdout_bytes	×
UNCOV 199	assert b"PASS: ExamplePrintInternal" in result.stdout_bytes	×
UNCOV 200	assert b"BenchmarkAddInternal" in result.stdout_bytes	×
UNCOV 201	assert b"PASS: TestAddExternal" in result.stdout_bytes	×
UNCOV 202	assert b"PASS: ExamplePrintExternal" in result.stdout_bytes	×
UNCOV 203	assert b"BenchmarkAddExternal" in result.stdout_bytes	×
204
205
206	def test_internal_test_fails(rule_runner: RuleRunner) -> None:	1✔
207	rule_runner.write_files(	1✔
208	{
209	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
210	"foo/go.mod": "module foo",
211	"foo/bar_test.go": textwrap.dedent(
212	"""
213	package foo
214	import "testing"
215	func TestAdd(t *testing.T) {
216	t.Fail()
217	}
218	"""
219	),
220	}
221	)
222	tgt = rule_runner.get_target(Address("foo"))	1✔
223	result = rule_runner.request(	1✔
224	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
225	)
UNCOV 226	assert result.exit_code == 1	×
UNCOV 227	assert b"FAIL: TestAdd" in result.stdout_bytes	×
UNCOV 228	assert len(result.process_results) == ATTEMPTS_DEFAULT_OPTION	×
229
230
231	def test_internal_test_with_test_main(rule_runner: RuleRunner) -> None:	1✔
232	rule_runner.write_files(	1✔
233	{
234	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
235	"foo/go.mod": "module foo",
236	"foo/add_test.go": textwrap.dedent(
237	"""
238	package foo
239	import (
240	"fmt"
241	"testing"
242	)
243	func TestAdd(t *testing.T) {
244	t.Fail()
245	}
246	func TestMain(m *testing.M) {
247	fmt.Println("foo.TestMain called")
248	m.Run()
249	}
250	"""
251	),
252	}
253	)
254	tgt = rule_runner.get_target(Address("foo"))	1✔
255	result = rule_runner.request(	1✔
256	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
257	)
UNCOV 258	assert result.exit_code == 1	×
UNCOV 259	assert b"foo.TestMain called" in result.stdout_bytes	×
UNCOV 260	assert b"FAIL: TestAdd" in result.stdout_bytes	×
261
262
263	def test_internal_test_fails_to_compile(rule_runner: RuleRunner) -> None:	1✔
264	"""A compilation failure should not cause Pants to error, only the test to fail."""
265	rule_runner.write_files(	1✔
266	{
267	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
268	"foo/go.mod": "module foo",
269	# Test itself is bad.
270	"foo/bad_test.go": "invalid!!!",
271	# A dependency of the test is bad.
272	"foo/dep/f.go": "invalid!!!",
273	"foo/dep/BUILD": "go_package()",
274	"foo/uses_dep/BUILD": "go_package()",
275	"foo/uses_dep/f_test.go": textwrap.dedent(
276	"""
277	package uses_dep
278
279	import (
280	"foo/dep"
281	"testing"
282	)
283
284	func TestAdd(t *testing.T) {
285	if add(2, 3) != 5 {
286	t.Fail()
287	}
288	}
289	"""
290	),
291	}
292	)
293	tgt = rule_runner.get_target(Address("foo"))	1✔
294	result = rule_runner.request(	1✔
295	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
296	)
UNCOV 297	assert result.exit_code == 1	×
UNCOV 298	assert b"bad_test.go:1:1: expected 'package', found invalid\n" in result.stderr_bytes	×
299
UNCOV 300	tgt = rule_runner.get_target(Address("foo/uses_dep"))	×
UNCOV 301	result = rule_runner.request(	×
302	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
303	)
UNCOV 304	assert result.exit_code == 1	×
UNCOV 305	assert b"dep/f.go:1:1: expected 'package', found invalid\n" in result.stderr_bytes	×
306
307
308	def test_external_test_fails(rule_runner: RuleRunner) -> None:	1✔
309	rule_runner.write_files(	1✔
310	{
311	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
312	"foo/go.mod": "module foo",
313	"foo/add.go": textwrap.dedent(
314	"""
315	package foo
316	func Add(x, y int) int {
317	return x + y
318	}
319	"""
320	),
321	"foo/add_test.go": textwrap.dedent(
322	"""
323	package foo_test
324	import (
325	_ "foo"
326	"testing"
327	)
328	func TestAdd(t *testing.T) {
329	t.Fail()
330	}
331	"""
332	),
333	}
334	)
335	tgt = rule_runner.get_target(Address("foo", generated_name="./"))	1✔
336	result = rule_runner.request(	1✔
337	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
338	)
UNCOV 339	assert result.exit_code == 1	×
UNCOV 340	assert b"FAIL: TestAdd" in result.stdout_bytes	×
UNCOV 341	assert len(result.process_results) == ATTEMPTS_DEFAULT_OPTION	×
342
343
344	def test_external_test_with_test_main(rule_runner: RuleRunner) -> None:	1✔
345	rule_runner.write_files(	1✔
346	{
347	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
348	"foo/go.mod": "module foo",
349	"foo/add.go": textwrap.dedent(
350	"""
351	package foo
352	func Add(x, y int) int {
353	return x + y
354	}
355	"""
356	),
357	"foo/add_test.go": textwrap.dedent(
358	"""
359	package foo_test
360	import (
361	"foo"
362	"fmt"
363	"testing"
364	)
365	func TestAdd(t *testing.T) {
366	if foo.Add(2, 3) != 5 {
367	t.Fail()
368	}
369	}
370	func TestMain(m *testing.M) {
371	fmt.Println("foo_test.TestMain called")
372	m.Run()
373	}
374	"""
375	),
376	}
377	)
378	tgt = rule_runner.get_target(Address("foo", generated_name="./"))	1✔
379	result = rule_runner.request(	1✔
380	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
381	)
UNCOV 382	assert result.exit_code == 0	×
UNCOV 383	assert b"foo_test.TestMain called" in result.stdout_bytes	×
384
385
386	def test_both_internal_and_external_tests_fail(rule_runner: RuleRunner) -> None:	1✔
387	rule_runner.write_files(	1✔
388	{
389	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
390	"foo/go.mod": "module foo",
391	"foo/add.go": textwrap.dedent(
392	"""
393	package foo
394	func Add(x, y int) int {
395	return x + y
396	}
397	"""
398	),
399	"foo/add_int_test.go": textwrap.dedent(
400	"""
401	package foo
402	import (
403	"testing"
404	)
405	func TestAddInternal(t *testing.T) {
406	t.Fail()
407	}
408	"""
409	),
410	"foo/add_ext_test.go": textwrap.dedent(
411	"""
412	package foo_test
413	import (
414	_ "foo"
415	"testing"
416	)
417	func TestAddExternal(t *testing.T) {
418	t.Fail()
419	}
420	"""
421	),
422	}
423	)
424	tgt = rule_runner.get_target(Address("foo"))	1✔
425	result = rule_runner.request(	1✔
426	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
427	)
UNCOV 428	assert result.exit_code == 1	×
UNCOV 429	assert b"FAIL: TestAddInternal" in result.stdout_bytes	×
UNCOV 430	assert b"FAIL: TestAddExternal" in result.stdout_bytes	×
UNCOV 431	assert len(result.process_results) == ATTEMPTS_DEFAULT_OPTION	×
432
433
434	@pytest.mark.no_error_if_skipped	1✔
435	def test_fuzz_target_supported(rule_runner: RuleRunner) -> None:	1✔
436	go_version_result = rule_runner.request(	1✔
437	ProcessResult, [GoSdkProcess(["version"], description="Get `go` version.")]
438	)
UNCOV 439	if "go1.18" not in go_version_result.stdout.decode():	×
UNCOV 440	pytest.skip("Skipping because Go SDK is not 1.18 or higher.")	×
441
442	rule_runner.write_files(	×
443	{
444	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
445	"foo/go.mod": "module foo",
446	"foo/fuzz_test.go": textwrap.dedent(
447	"""
448	package foo
449	import (
450	"testing"
451	)
452	func FuzzFoo(f *testing.F) {
453	f.Add("foo")
454	f.Fuzz(func(t *testing.T, v string) {
455	if v != "foo" {
456	t.Fail()
457	}
458	})
459	}
460	"""
461	),
462	}
463	)
464	tgt = rule_runner.get_target(Address("foo"))	×
465	result = rule_runner.request(	×
466	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
467	)
468	assert result.exit_code == 0	×
469	assert b"PASS: FuzzFoo" in result.stdout_bytes	×
470
471
472	def test_extra_env_vars(rule_runner: RuleRunner) -> None:	1✔
473	rule_runner.write_files(	1✔
474	{
475	"foo/BUILD": textwrap.dedent(
476	"""
477	go_mod(name='mod')
478	go_package(
479	test_extra_env_vars=(
480	"GO_PACKAGE_VAR_WITHOUT_VALUE",
481	"GO_PACKAGE_VAR_WITH_VALUE=go_package_var_with_value",
482	"GO_PACKAGE_OVERRIDE_WITH_VALUE_VAR=go_package_override_with_value_var_override",
483	)
484	)
485	"""
486	),
487	"foo/go.mod": "module foo",
488	"foo/add.go": textwrap.dedent(
489	"""
490	package foo
491	import "os"
492	func envIs(e, v string) bool {
493	return (os.Getenv(e) == v)
494	}
495	"""
496	),
497	"foo/add_test.go": textwrap.dedent(
498	"""
499	package foo
500	import "testing"
501	func TestEnvs(t *testing.T) {
502	if !envIs("ARG_WITH_VALUE_VAR", "arg_with_value_var") {
503	t.Fail()
504	}
505	if !envIs("ARG_WITHOUT_VALUE_VAR", "arg_without_value_var") {
506	t.Fail()
507	}
508	if !envIs("GO_PACKAGE_VAR_WITH_VALUE", "go_package_var_with_value") {
509	t.Fail()
510	}
511	if !envIs("GO_PACKAGE_VAR_WITHOUT_VALUE", "go_package_var_without_value") {
512	t.Fail()
513	}
514	if !envIs("GO_PACKAGE_OVERRIDE_WITH_VALUE_VAR", "go_package_override_with_value_var_override") {
515	t.Fail()
516	}
517	}
518	"""
519	),
520	}
521	)
522	tgt = rule_runner.get_target(Address("foo"))	1✔
523	rule_runner.set_options(	1✔
524	args=[
525	"--go-test-args=-v -bench=.",
526	'--test-extra-env-vars=["ARG_WITH_VALUE_VAR=arg_with_value_var", "ARG_WITHOUT_VALUE_VAR", "GO_PACKAGE_OVERRIDE_ARG_WITH_VALUE_VAR"]',
527	],
528	env={
529	"ARG_WITHOUT_VALUE_VAR": "arg_without_value_var",
530	"GO_PACKAGE_VAR_WITHOUT_VALUE": "go_package_var_without_value",
531	"GO_PACKAGE_OVERRIDE_WITH_VALUE_VAR": "go_package_override_with_value_var",
532	},
533	env_inherit={"PATH"},
534	)
535	result = rule_runner.request(	1✔
536	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
537	)
UNCOV 538	assert result.exit_code == 0	×
UNCOV 539	assert b"PASS: TestEnvs" in result.stdout_bytes	×
540
541
542	def test_skip_tests(rule_runner: RuleRunner) -> None:	1✔
543	rule_runner.write_files(	1✔
544	{
545	"f_test.go": "",
546	"BUILD": textwrap.dedent(
547	"""\
548	go_package(name='run')
549	go_package(name='skip', skip_tests=True)
550	"""
551	),
552	}
553	)
554
555	def is_applicable(tgt_name: str) -> bool:	1✔
556	tgt = rule_runner.get_target(Address("", target_name=tgt_name))	1✔
557	return GoTestFieldSet.is_applicable(tgt)	1✔
558
559	assert is_applicable("run")	1✔
560	assert not is_applicable("skip")	1✔
561
562
563	def test_no_tests(rule_runner: RuleRunner) -> None:	1✔
564	rule_runner.write_files(	1✔
565	{
566	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
567	"foo/go.mod": "module foo",
568	"foo/add.go": textwrap.dedent(
569	"""
570	package foo
571	func add(x, y int) int {
572	return x + y
573	}
574	"""
575	),
576	}
577	)
578	tgt = rule_runner.get_target(Address("foo"))	1✔
579	result = rule_runner.request(	1✔
580	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
581	)
UNCOV 582	assert result.exit_code is None	×
583
584
585	def test_compilation_error(rule_runner: RuleRunner) -> None:	1✔
586	rule_runner.write_files(	1✔
587	{
588	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
589	"foo/go.mod": "module foo",
590	"foo/add.go": textwrap.dedent(
591	"""
592	package foo
593	func add(x, y int) int {
594	return x + y
595	}
596	"""
597	),
598	"foo/add_test.go": textwrap.dedent(
599	"""
600	package foo
601	import "testing"
602	!!!
603	func TestAdd(t *testing.T) {
604	if add(2, 3) != 5 {
605	t.Fail()
606	}
607	}
608	"""
609	),
610	}
611	)
612	tgt = rule_runner.get_target(Address("foo"))	1✔
613	result = rule_runner.request(	1✔
614	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
615	)
UNCOV 616	assert result.exit_code == 1	×
UNCOV 617	assert b"failed to parse" in result.stderr_bytes	×
618
619
620	def test_file_dependencies(rule_runner: RuleRunner) -> None:	1✔
621	rule_runner.write_files(	1✔
622	{
623	"f.txt": "",
624	"BUILD": "file(name='root', source='f.txt')",
625	"foo/BUILD": textwrap.dedent(
626	"""
627	go_mod(name='mod')
628	go_package(dependencies=[":testdata", "//:root"])
629	file(name="testdata", source="testdata/f.txt")
630	"""
631	),
632	"foo/go.mod": "module foo",
633	"foo/foo_test.go": textwrap.dedent(
634	"""
635	package foo
636	import (
637	"os"
638	"testing"
639	)
640
641	func TestFilesAvailable(t *testing.T) {
642	_, err1 := os.Stat("testdata/f.txt")
643	if err1 != nil {
644	t.Fatalf("Could not stat foo/testdata/f.txt: %v", err1)
645	}
646	_, err2 := os.Stat("../f.txt")
647	if err2 != nil {
648	t.Fatalf("Could not stat f.txt: %v", err2)
649	}
650	}
651	"""
652	),
653	"foo/testdata/f.txt": "",
654	}
655	)
656	tgt = rule_runner.get_target(Address("foo"))	1✔
657	result = rule_runner.request(	1✔
658	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
659	)
UNCOV 660	assert result.exit_code == 0	×
661
662
663	def test_profile_options_write_results(rule_runner: RuleRunner) -> None:	1✔
664	rule_runner.write_files(	1✔
665	{
666	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
667	"foo/go.mod": "module foo",
668	"foo/add.go": textwrap.dedent(
669	"""
670	package foo
671	func add(x, y int) int {
672	return x + y
673	}
674	"""
675	),
676	"foo/add_test.go": textwrap.dedent(
677	"""
678	package foo
679	import "testing"
680	func TestAdd(t *testing.T) {
681	if add(2, 3) != 5 {
682	t.Fail()
683	}
684	}
685	"""
686	),
687	}
688	)
689	rule_runner.set_options(	1✔
690	[
691	"--go-test-args=-v -bench=.",
692	"--go-test-block-profile",
693	"--go-test-cpu-profile",
694	"--go-test-mem-profile",
695	"--go-test-mutex-profile",
696	"--go-test-trace",
697	],
698	env_inherit={"PATH"},
699	)
700	tgt = rule_runner.get_target(Address("foo"))	1✔
701	result = rule_runner.request(	1✔
702	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
703	)
UNCOV 704	assert result.exit_code == 0	×
UNCOV 705	assert b"PASS: TestAdd" in result.stdout_bytes	×
706
UNCOV 707	extra_output = result.extra_output	×
UNCOV 708	assert extra_output is not None	×
UNCOV 709	assert sorted(extra_output.files) == [	×
710	"block.out",
711	"cpu.out",
712	"mem.out",
713	"mutex.out",
714	"test_runner",
715	"trace.out",
716	]
717
718
719	def test_external_test_with_use_coverage(rule_runner: RuleRunner) -> None:	1✔
720	rule_runner.write_files(	1✔
721	{
722	"foo/BUILD": "go_mod(name='mod')\ngo_package()",
723	"foo/go.mod": "module foo",
724	"foo/add.go": textwrap.dedent(
725	"""
726	package foo
727	func Add(x, y int) int {
728	return x + y
729	}
730	"""
731	),
732	"foo/add_test.go": textwrap.dedent(
733	"""
734	package foo_test
735	import (
736	"foo"
737	"testing"
738	)
739	func TestAdd(t *testing.T) {
740	if foo.Add(2, 3) != 5 {
741	t.Fail()
742	}
743	}
744	"""
745	),
746	}
747	)
748	tgt = rule_runner.get_target(Address("foo", generated_name="./"))	1✔
749	rule_runner.set_options(	1✔
750	[
751	"--test-use-coverage",
752	],
753	env_inherit={"PATH"},
754	)
755	result = rule_runner.request(	1✔
756	TestResult, [GoTestRequest.Batch("", (GoTestFieldSet.create(tgt),), None)]
757	)
UNCOV 758	assert result.exit_code == 0	×

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