18863956295

Committed 28 Oct 2025 04:17AM UTC coverage: 80.276% (-0.009%) from 80.285%

Build # 18863956295

Build Type

push

github

Committed by

web-flow

Commit Message

CI: update Go SDK versions and use Go 1.24 for tests of Go coverage support (#22810)

Update the Go SDK versions available in CI to v1.25.3 and v1.24.9 from
v1.19.x.

Since Pants does not support the Go "coverage redesign" which became the
only coverage implementation in Go 1.25, the coverage tests in
`src/python/pants/backend/go/util_rules/coverage_test.py` are now
conditioned on Go 1.24 being available on the system. (Those tests are
skipped otherwise.)

There are some other test fixes as well due to the upgrade from Go 1.19
to Go 1.25.

Run Details

56 of 69 new or added lines in 3 files covered. (81.16%)

10 existing lines in 2 files now uncovered.

77944 of 97095 relevant lines covered (80.28%)

3.35 hits per line

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

81.3

/src/python/pants/backend/go/util_rules/build_pkg_target_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
from collections import defaultdict
from textwrap import dedent

import pytest

from pants.backend.go import target_type_rules
from pants.backend.go.dependency_inference import (
    GoImportPathsMappingAddressSet,
    GoModuleImportPathsMapping,
    GoModuleImportPathsMappings,
    GoModuleImportPathsMappingsHook,
)
from pants.backend.go.target_types import GoModTarget, GoOwningGoModAddressField, GoPackageTarget
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.backend.go.util_rules.build_opts import GoBuildOptions
from pants.backend.go.util_rules.build_pkg import (
    BuildGoPackageRequest,
    BuiltGoPackage,
    FallibleBuildGoPackageRequest,
    FallibleBuiltGoPackage,
)
from pants.backend.go.util_rules.build_pkg_target import (
    BuildGoPackageRequestForStdlibRequest,
    BuildGoPackageTargetRequest,
    GoCodegenBuildRequest,
    setup_build_go_package_target_request,
)
from pants.backend.go.util_rules.go_mod import OwningGoModRequest, find_owning_go_mod
from pants.backend.go.util_rules.import_analysis import (
    GoStdLibPackage,
    GoStdLibPackages,
    GoStdLibPackagesRequest,
)
from pants.core.target_types import FilesGeneratorTarget, FileSourceField, FileTarget
from pants.engine.addresses import Address
from pants.engine.fs import CreateDigest, FileContent, Snapshot
from pants.engine.internals.graph import resolve_dependencies
from pants.engine.intrinsics import create_digest
from pants.engine.rules import QueryRule, concurrently, implicitly, rule
from pants.engine.target import AllTargets, Dependencies, DependenciesRequest
from pants.engine.unions import UnionRule
from pants.testutil.rule_runner import RuleRunner
from pants.util.frozendict import FrozenDict
from pants.util.logging import LogLevel
from pants.util.strutil import path_safe


# Set up a semi-complex codegen plugin. Note that we cyclically call into the
# `BuildGoPackageTargetRequest` rule to set up a dependency on a third-party package, as this
# is common for codegen plugins to need to do.
class GoCodegenBuildFilesRequest(GoCodegenBuildRequest):
    generate_from = FileSourceField


class GenerateFromFileImportPathsMappingHook(GoModuleImportPathsMappingsHook):
    pass


@rule(desc="Map import paths for all 'generate from file' targets.", level=LogLevel.DEBUG)
async def map_import_paths(
    _request: GenerateFromFileImportPathsMappingHook,
    all_targets: AllTargets,
) -> GoModuleImportPathsMappings:
    file_targets = [tgt for tgt in all_targets if tgt.has_field(FileSourceField)]

    owning_go_mod_targets = await concurrently(
        find_owning_go_mod(OwningGoModRequest(tgt.address), **implicitly()) for tgt in file_targets
    )

    import_paths_by_module: dict[Address, dict[str, set[Address]]] = defaultdict(
        lambda: defaultdict(set)
    )

    for owning_go_mod, tgt in zip(owning_go_mod_targets, file_targets):
        import_paths_by_module[owning_go_mod.address]["codegen.com/gen"].add(tgt.address)

    return GoModuleImportPathsMappings(
        FrozenDict(
            {
                go_mod_addr: GoModuleImportPathsMapping(
                    mapping=FrozenDict(
                        {
                            import_path: GoImportPathsMappingAddressSet(
                                addresses=tuple(sorted(addresses)), infer_all=True
                            )
                            for import_path, addresses in import_path_mapping.items()
                        }
                    ),
                    address_to_import_path=FrozenDict(
                        {
                            address: import_path
                            for import_path, addresses in import_path_mapping.items()
                            for address in addresses
                        }
                    ),
                )
                for go_mod_addr, import_path_mapping in import_paths_by_module.items()
            }
        )
    )


@rule
async def generate_from_file(request: GoCodegenBuildFilesRequest) -> FallibleBuildGoPackageRequest:
    content = dedent(
        """\
        package gen

        import "fmt"
        import "github.com/google/uuid"

        func Quote(s string) string {
            uuid.SetClockSequence(-1)  // A trivial line to use uuid.
            return fmt.Sprintf(">> %s <<", s)
        }
        """
    )
    digest = await create_digest(CreateDigest([FileContent("codegen/f.go", content.encode())]))

    deps = await resolve_dependencies(
        DependenciesRequest(request.target[Dependencies]), **implicitly()
    )
    assert len(deps) == 1
    assert deps[0].generated_name == "github.com/google/uuid"
    thirdparty_dep = await setup_build_go_package_target_request(
        BuildGoPackageTargetRequest(deps[0], build_opts=GoBuildOptions()), **implicitly()
    )
    assert thirdparty_dep.request is not None

    return FallibleBuildGoPackageRequest(
        request=BuildGoPackageRequest(
            import_path="codegen.com/gen",
            pkg_name="gen",
            digest=digest,
            dir_path="codegen",
            build_opts=GoBuildOptions(),
            go_files=("f.go",),
            s_files=(),
            direct_dependencies=(thirdparty_dep.request,),
            minimum_go_version=None,
        ),
        import_path="codegen.com/gen",
    )


@pytest.fixture
def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *sdk.rules(),
            *assembly.rules(),
            *build_pkg.rules(),
            *build_pkg_target.rules(),
            *import_analysis.rules(),
            *link.rules(),
            *go_mod.rules(),
            *first_party_pkg.rules(),
            *third_party_pkg.rules(),
            *target_type_rules.rules(),
            generate_from_file,
            map_import_paths,
            QueryRule(BuiltGoPackage, [BuildGoPackageRequest]),
            QueryRule(FallibleBuiltGoPackage, [BuildGoPackageRequest]),
            QueryRule(BuildGoPackageRequest, [BuildGoPackageTargetRequest]),
            QueryRule(FallibleBuildGoPackageRequest, [BuildGoPackageTargetRequest]),
            QueryRule(GoStdLibPackages, (GoStdLibPackagesRequest,)),
            QueryRule(BuildGoPackageRequest, (BuildGoPackageRequestForStdlibRequest,)),
            UnionRule(GoCodegenBuildRequest, GoCodegenBuildFilesRequest),
            UnionRule(GoModuleImportPathsMappingsHook, GenerateFromFileImportPathsMappingHook),
            FileTarget.register_plugin_field(GoOwningGoModAddressField),
            FilesGeneratorTarget.register_plugin_field(GoOwningGoModAddressField),
        ],
        target_types=[
            GoModTarget,
            GoPackageTarget,
            FilesGeneratorTarget,
        ],
    )
    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
    }
    actual = dict(built_package.import_paths_to_pkg_a_files)
    for import_path, pkg_archive_path in expected.items():
        assert import_path in actual, f"expected {import_path} to be in build output"
        assert actual[import_path] == expected[import_path], (
            "expected package archive paths to match"
        )
    assert set(expected.values()).issubset(set(result_files))


def assert_pkg_target_built(
    rule_runner: RuleRunner,
    addr: Address,
    *,
    expected_import_path: str,
    expected_dir_path: str,
    expected_direct_dependency_import_paths: list[str],
    expected_transitive_dependency_import_paths: list[str],
    expected_go_file_names: list[str],
) -> None:
    build_request = rule_runner.request(
        BuildGoPackageRequest, [BuildGoPackageTargetRequest(addr, build_opts=GoBuildOptions())]
    )
    assert build_request.import_path == expected_import_path
    assert build_request.dir_path == expected_dir_path
    assert build_request.go_files == tuple(expected_go_file_names)
    assert not build_request.s_files
    assert sorted([dep.import_path for dep in build_request.direct_dependencies]) == sorted(
        expected_direct_dependency_import_paths
    )
    assert_built(
        rule_runner,
        build_request,
        expected_import_paths=[
            expected_import_path,
            *expected_direct_dependency_import_paths,
            *expected_transitive_dependency_import_paths,
        ],
    )


def test_build_first_party_pkg_target(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "go.mod": dedent(
                """\
                module example.com/greeter
                go 1.17
                """
            ),
            "greeter.go": dedent(
                """\
                package greeter

                import "fmt"

                func Hello() {
                    fmt.Println("Hello world!")
                }
                """
            ),
            "BUILD": "go_mod(name='mod')\ngo_package(name='pkg')",
        }
    )
    assert_pkg_target_built(
        rule_runner,
        Address("", target_name="pkg"),
        expected_import_path="example.com/greeter",
        expected_dir_path="",
        expected_go_file_names=["greeter.go"],
        expected_direct_dependency_import_paths=["fmt"],
        expected_transitive_dependency_import_paths=[],
    )


def test_build_third_party_pkg_target(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "go.mod": dedent(
                """\
                module example.com/greeter
                go 1.17
                require github.com/google/uuid v1.3.0
                """
            ),
            "go.sum": dedent(
                """\
                github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
                github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
                """
            ),
            "BUILD": "go_mod(name='mod')",
        }
    )
    import_path = "github.com/google/uuid"
    assert_pkg_target_built(
        rule_runner,
        Address("", target_name="mod", generated_name=import_path),
        expected_import_path=import_path,
        expected_dir_path="gopath/pkg/mod/github.com/google/uuid@v1.3.0",
        expected_go_file_names=[
            "dce.go",
            "doc.go",
            "hash.go",
            "marshal.go",
            "node.go",
            "node_net.go",
            "null.go",
            "sql.go",
            "time.go",
            "util.go",
            "uuid.go",
            "version1.go",
            "version4.go",
        ],
        expected_direct_dependency_import_paths=[
            "bytes",
            "crypto/md5",
            "crypto/rand",
            "crypto/sha1",
            "database/sql/driver",
            "encoding/binary",
            "encoding/hex",
            "encoding/json",
            "errors",
            "fmt",
            "hash",
            "io",
            "net",
            "os",
            "strings",
            "sync",
            "time",
        ],
        expected_transitive_dependency_import_paths=[],
    )


def test_build_target_with_dependencies(rule_runner: RuleRunner) -> None:
    """Check that we properly include (transitive) dependencies."""
    rule_runner.write_files(
        {
            "greeter/quoter/lib.go": dedent(
                """\
                package quoter

                import "fmt"

                func Quote(s string) string {
                    return fmt.Sprintf(">> %s <<", s)
                }
                """
            ),
            "greeter/quoter/BUILD": "go_package()",
            "greeter/lib.go": dedent(
                """\
                package greeter

                import (
                    "fmt"
                    "example.com/project/greeter/quoter"
                    "golang.org/x/xerrors"
                )

                func QuotedHello() {
                    xerrors.New("some error")
                    fmt.Println(quoter.Quote("Hello world!"))
                }
                """
            ),
            "greeter/BUILD": "go_package()",
            "main.go": dedent(
                """\
                package main

                import "example.com/project/greeter"

                func main() {
                    greeter.QuotedHello()
                }
                """
            ),
            "go.mod": dedent(
                """\
                module example.com/project
                go 1.17
                require golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
                """
            ),
            "go.sum": dedent(
                """\
                golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
                golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
                """
            ),
            "BUILD": "go_mod(name='mod')\ngo_package(name='pkg')",
        }
    )

    xerrors_internal_import_path = "golang.org/x/xerrors/internal"
    assert_pkg_target_built(
        rule_runner,
        Address("", target_name="mod", generated_name=xerrors_internal_import_path),
        expected_import_path=xerrors_internal_import_path,
        expected_dir_path="gopath/pkg/mod/golang.org/x/xerrors@v0.0.0-20191204190536-9bdfabe68543/internal",
        expected_go_file_names=["internal.go"],
        expected_direct_dependency_import_paths=[],
        expected_transitive_dependency_import_paths=[],
    )

    xerrors_import_path = "golang.org/x/xerrors"
    assert_pkg_target_built(
        rule_runner,
        Address("", target_name="mod", generated_name=xerrors_import_path),
        expected_import_path=xerrors_import_path,
        expected_dir_path="gopath/pkg/mod/golang.org/x/xerrors@v0.0.0-20191204190536-9bdfabe68543",
        expected_go_file_names=[
            "adaptor.go",
            "doc.go",
            "errors.go",
            "fmt.go",
            "format.go",
            "frame.go",
            "wrap.go",
        ],
        expected_direct_dependency_import_paths=[
            "bytes",
            "fmt",
            xerrors_internal_import_path,
            "io",
            "reflect",
            "runtime",
            "strconv",
            "strings",
            "unicode",
            "unicode/utf8",
        ],
        expected_transitive_dependency_import_paths=[],
    )

    quoter_import_path = "example.com/project/greeter/quoter"
    assert_pkg_target_built(
        rule_runner,
        Address("greeter/quoter"),
        expected_import_path=quoter_import_path,
        expected_dir_path="greeter/quoter",
        expected_go_file_names=["lib.go"],
        expected_direct_dependency_import_paths=["fmt"],
        expected_transitive_dependency_import_paths=[],
    )

    greeter_import_path = "example.com/project/greeter"
    assert_pkg_target_built(
        rule_runner,
        Address("greeter"),
        expected_import_path=greeter_import_path,
        expected_dir_path="greeter",
        expected_go_file_names=["lib.go"],
        expected_direct_dependency_import_paths=["fmt", xerrors_import_path, quoter_import_path],
        expected_transitive_dependency_import_paths=[xerrors_internal_import_path],
    )

    assert_pkg_target_built(
        rule_runner,
        Address("", target_name="pkg"),
        expected_import_path="example.com/project",
        expected_dir_path="",
        expected_go_file_names=["main.go"],
        expected_direct_dependency_import_paths=[greeter_import_path],
        expected_transitive_dependency_import_paths=[
            quoter_import_path,
            xerrors_import_path,
            xerrors_internal_import_path,
        ],
    )


def test_build_invalid_target(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "go.mod": dedent(
                """\
                module example.com/greeter
                go 1.17
                """
            ),
            "BUILD": "go_mod(name='mod')",
            "direct/f.go": "invalid!!!",
            "direct/BUILD": "go_package()",
            "dep/f.go": "invalid!!!",
            "dep/BUILD": "go_package()",
            "uses_dep/f.go": dedent(
                """\
                package uses_dep

                import "example.com/greeter/dep"

                func Hello() {
                    dep.Foo("Hello world!")
                }
                """
            ),
            "uses_dep/BUILD": "go_package()",
        }
    )

    direct_build_request = rule_runner.request(
        FallibleBuildGoPackageRequest,
        [BuildGoPackageTargetRequest(Address("direct"), build_opts=GoBuildOptions())],
    )
    assert direct_build_request.request is None
    assert direct_build_request.exit_code == 1
    assert "direct/f.go:1:1: expected 'package', found invalid\n" in (
        direct_build_request.stderr or ""
    )

    dep_build_request = rule_runner.request(
        FallibleBuildGoPackageRequest,
        [BuildGoPackageTargetRequest(Address("uses_dep"), build_opts=GoBuildOptions())],
    )
    assert dep_build_request.request is None
    assert dep_build_request.exit_code == 1
    assert "dep/f.go:1:1: expected 'package', found invalid\n" in (dep_build_request.stderr or "")


def test_build_codegen_target(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "go.mod": dedent(
                """\
                module example.com/greeter
                go 1.17
                require github.com/google/uuid v1.3.0
                """
            ),
            "go.sum": dedent(
                """\
                github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
                github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
                """
            ),
            "generate_from_me.txt": "",
            "greeter.go": dedent(
                """\
                package greeter

                import "fmt"
                import "codegen.com/gen"

                func Hello() {
                    fmt.Println(gen.Quote("Hello world!"))
                }
                """
            ),
            "BUILD": dedent(
                """\
                go_mod(name='mod')
                go_package(name='pkg', dependencies=[":gen"])
                files(
                    name='gen',
                    sources=['generate_from_me.txt'],
                    dependencies=[':mod#github.com/google/uuid'],
                )
                """
            ),
        }
    )

    # Running directly on a codegen target should work.
    assert_pkg_target_built(
        rule_runner,
        Address("", target_name="gen", relative_file_path="generate_from_me.txt"),
        expected_import_path="codegen.com/gen",
        expected_dir_path="codegen",
        expected_go_file_names=["f.go"],
        expected_direct_dependency_import_paths=["github.com/google/uuid"],
        expected_transitive_dependency_import_paths=[],
    )

    # Direct dependencies on codegen targets must be propagated.
    #
    # Note that the `go_package` depends on the `files` generator target. This should work, even
    # though `files` itself cannot generate, because it's an alias for all generated `file` targets.
    assert_pkg_target_built(
        rule_runner,
        Address("", target_name="pkg"),
        expected_import_path="example.com/greeter",
        expected_dir_path="",
        expected_go_file_names=["greeter.go"],
        expected_direct_dependency_import_paths=["codegen.com/gen", "fmt"],
        expected_transitive_dependency_import_paths=["github.com/google/uuid"],
    )


def test_xtest_deps(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "go.mod": "module example.pantsbuild.org",
            "BUILD": "go_mod(name='mod')\n",
            "pkg/BUILD": "go_package()\n",
            "pkg/example.go": dedent(
                """\
            package pkg

            const ExampleValue = 2137
            """
            ),
            "pkg/example_test.go": dedent(
                """\
            package pkg_test

            import (
                "example.pantsbuild.org/pkg"
                "example.pantsbuild.org/pkg/testutils"
                "testing"
            )

            func TestValue(t *testing.T) {
                t.Run("Test", func(t *testing.T) {
                    if pkg.ExampleValue != testutils.ExampleValueFromTestutils {
                        t.Error("Not equal")
                    }
                })
            }
            """
            ),
            "pkg/testutils/BUILD": "go_package()\n",
            "pkg/testutils/testutils.go": dedent(
                """\
            package testutils

            import "example.pantsbuild.org/pkg"

            const ExampleValueFromTestutils = pkg.ExampleValue
            """
            ),
        }
    )
    assert_pkg_target_built(
        rule_runner,
        Address("pkg"),
        expected_dir_path="pkg",
        expected_import_path="example.pantsbuild.org/pkg",
        expected_go_file_names=["example.go"],
        expected_direct_dependency_import_paths=[],
        expected_transitive_dependency_import_paths=[],
    )


@pytest.mark.no_error_if_skipped
def test_stdlib_embed_config(rule_runner: RuleRunner) -> None:
    stdlib_packages = rule_runner.request(
        GoStdLibPackages, [GoStdLibPackagesRequest(with_race_detector=False, cgo_enabled=False)]
    )

    pkg_info: GoStdLibPackage | None = None
    for import_path in ("crypto/internal/nistec", "internal/trace/traceviewer/http"):
        pkg_info = stdlib_packages.get(import_path)
        if pkg_info:
            break

    if not pkg_info:
        pytest.skip(
            "Skipping test since no known stdlib import paths using embed are available for the test."
        )

    assert "embed" in pkg_info.imports
    assert pkg_info.embed_patterns
    assert pkg_info.embed_files

    build_request = rule_runner.request(
        BuildGoPackageRequest,
        [
            BuildGoPackageRequestForStdlibRequest(
                import_path=pkg_info.import_path, build_opts=GoBuildOptions(cgo_enabled=False)
            )
        ],
    )

    embed_config = build_request.embed_config
    assert embed_config is not None
    assert embed_config.patterns
    assert embed_config.files

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	1✔
7	from collections import defaultdict	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.dependency_inference import (	1✔
14	GoImportPathsMappingAddressSet,
15	GoModuleImportPathsMapping,
16	GoModuleImportPathsMappings,
17	GoModuleImportPathsMappingsHook,
18	)
19	from pants.backend.go.target_types import GoModTarget, GoOwningGoModAddressField, GoPackageTarget	1✔
20	from pants.backend.go.util_rules import (	1✔
21	assembly,
22	build_pkg,
23	build_pkg_target,
24	first_party_pkg,
25	go_mod,
26	import_analysis,
27	link,
28	sdk,
29	third_party_pkg,
30	)
31	from pants.backend.go.util_rules.build_opts import GoBuildOptions	1✔
32	from pants.backend.go.util_rules.build_pkg import (	1✔
33	BuildGoPackageRequest,
34	BuiltGoPackage,
35	FallibleBuildGoPackageRequest,
36	FallibleBuiltGoPackage,
37	)
38	from pants.backend.go.util_rules.build_pkg_target import (	1✔
39	BuildGoPackageRequestForStdlibRequest,
40	BuildGoPackageTargetRequest,
41	GoCodegenBuildRequest,
42	setup_build_go_package_target_request,
43	)
44	from pants.backend.go.util_rules.go_mod import OwningGoModRequest, find_owning_go_mod	1✔
45	from pants.backend.go.util_rules.import_analysis import (	1✔
46	GoStdLibPackage,
47	GoStdLibPackages,
48	GoStdLibPackagesRequest,
49	)
50	from pants.core.target_types import FilesGeneratorTarget, FileSourceField, FileTarget	1✔
51	from pants.engine.addresses import Address	1✔
52	from pants.engine.fs import CreateDigest, FileContent, Snapshot	1✔
53	from pants.engine.internals.graph import resolve_dependencies	1✔
54	from pants.engine.intrinsics import create_digest	1✔
55	from pants.engine.rules import QueryRule, concurrently, implicitly, rule	1✔
56	from pants.engine.target import AllTargets, Dependencies, DependenciesRequest	1✔
57	from pants.engine.unions import UnionRule	1✔
58	from pants.testutil.rule_runner import RuleRunner	1✔
59	from pants.util.frozendict import FrozenDict	1✔
60	from pants.util.logging import LogLevel	1✔
61	from pants.util.strutil import path_safe	1✔
62
63
64	# Set up a semi-complex codegen plugin. Note that we cyclically call into the
65	# `BuildGoPackageTargetRequest` rule to set up a dependency on a third-party package, as this
66	# is common for codegen plugins to need to do.
67	class GoCodegenBuildFilesRequest(GoCodegenBuildRequest):	1✔
68	generate_from = FileSourceField	1✔
69
70
71	class GenerateFromFileImportPathsMappingHook(GoModuleImportPathsMappingsHook):	1✔
72	pass	1✔
73
74
75	@rule(desc="Map import paths for all 'generate from file' targets.", level=LogLevel.DEBUG)	1✔
76	async def map_import_paths(	1✔
77	_request: GenerateFromFileImportPathsMappingHook,
78	all_targets: AllTargets,
79	) -> GoModuleImportPathsMappings:
80	file_targets = [tgt for tgt in all_targets if tgt.has_field(FileSourceField)]	×
81
82	owning_go_mod_targets = await concurrently(	×
83	find_owning_go_mod(OwningGoModRequest(tgt.address), **implicitly()) for tgt in file_targets
84	)
85
86	import_paths_by_module: dict[Address, dict[str, set[Address]]] = defaultdict(	×
87	lambda: defaultdict(set)
88	)
89
90	for owning_go_mod, tgt in zip(owning_go_mod_targets, file_targets):	×
91	import_paths_by_module[owning_go_mod.address]["codegen.com/gen"].add(tgt.address)	×
92
93	return GoModuleImportPathsMappings(	×
94	FrozenDict(
95	{
96	go_mod_addr: GoModuleImportPathsMapping(
97	mapping=FrozenDict(
98	{
99	import_path: GoImportPathsMappingAddressSet(
100	addresses=tuple(sorted(addresses)), infer_all=True
101	)
102	for import_path, addresses in import_path_mapping.items()
103	}
104	),
105	address_to_import_path=FrozenDict(
106	{
107	address: import_path
108	for import_path, addresses in import_path_mapping.items()
109	for address in addresses
110	}
111	),
112	)
113	for go_mod_addr, import_path_mapping in import_paths_by_module.items()
114	}
115	)
116	)
117
118
119	@rule	1✔
120	async def generate_from_file(request: GoCodegenBuildFilesRequest) -> FallibleBuildGoPackageRequest:	1✔
121	content = dedent(	×
122	"""\
123	package gen
124
125	import "fmt"
126	import "github.com/google/uuid"
127
128	func Quote(s string) string {
129	uuid.SetClockSequence(-1) // A trivial line to use uuid.
130	return fmt.Sprintf(">> %s <<", s)
131	}
132	"""
133	)
134	digest = await create_digest(CreateDigest([FileContent("codegen/f.go", content.encode())]))	×
135
136	deps = await resolve_dependencies(	×
137	DependenciesRequest(request.target[Dependencies]), **implicitly()
138	)
139	assert len(deps) == 1	×
140	assert deps[0].generated_name == "github.com/google/uuid"	×
141	thirdparty_dep = await setup_build_go_package_target_request(	×
142	BuildGoPackageTargetRequest(deps[0], build_opts=GoBuildOptions()), **implicitly()
143	)
144	assert thirdparty_dep.request is not None	×
145
146	return FallibleBuildGoPackageRequest(	×
147	request=BuildGoPackageRequest(
148	import_path="codegen.com/gen",
149	pkg_name="gen",
150	digest=digest,
151	dir_path="codegen",
152	build_opts=GoBuildOptions(),
153	go_files=("f.go",),
154	s_files=(),
155	direct_dependencies=(thirdparty_dep.request,),
156	minimum_go_version=None,
157	),
158	import_path="codegen.com/gen",
159	)
160
161
162	@pytest.fixture	1✔
163	def rule_runner() -> RuleRunner:	1✔
164	rule_runner = RuleRunner(	1✔
165	rules=[
166	*sdk.rules(),
167	*assembly.rules(),
168	*build_pkg.rules(),
169	*build_pkg_target.rules(),
170	*import_analysis.rules(),
171	*link.rules(),
172	*go_mod.rules(),
173	*first_party_pkg.rules(),
174	*third_party_pkg.rules(),
175	*target_type_rules.rules(),
176	generate_from_file,
177	map_import_paths,
178	QueryRule(BuiltGoPackage, [BuildGoPackageRequest]),
179	QueryRule(FallibleBuiltGoPackage, [BuildGoPackageRequest]),
180	QueryRule(BuildGoPackageRequest, [BuildGoPackageTargetRequest]),
181	QueryRule(FallibleBuildGoPackageRequest, [BuildGoPackageTargetRequest]),
182	QueryRule(GoStdLibPackages, (GoStdLibPackagesRequest,)),
183	QueryRule(BuildGoPackageRequest, (BuildGoPackageRequestForStdlibRequest,)),
184	UnionRule(GoCodegenBuildRequest, GoCodegenBuildFilesRequest),
185	UnionRule(GoModuleImportPathsMappingsHook, GenerateFromFileImportPathsMappingHook),
186	FileTarget.register_plugin_field(GoOwningGoModAddressField),
187	FilesGeneratorTarget.register_plugin_field(GoOwningGoModAddressField),
188	],
189	target_types=[
190	GoModTarget,
191	GoPackageTarget,
192	FilesGeneratorTarget,
193	],
194	)
195	rule_runner.set_options([], env_inherit={"PATH"})	1✔
196	return rule_runner	1✔
197
198
199	def assert_built(	1✔
200	rule_runner: RuleRunner, request: BuildGoPackageRequest, *, expected_import_paths: list[str]
201	) -> None:
202	built_package = rule_runner.request(BuiltGoPackage, [request])	1✔
203	result_files = rule_runner.request(Snapshot, [built_package.digest]).files	1✔
204	expected = {	1✔
205	import_path: os.path.join("__pkgs__", path_safe(import_path), "__pkg__.a")
206	for import_path in expected_import_paths
207	}
208	actual = dict(built_package.import_paths_to_pkg_a_files)	1✔
209	for import_path, pkg_archive_path in expected.items():	1✔
210	assert import_path in actual, f"expected {import_path} to be in build output"	1✔
211	assert actual[import_path] == expected[import_path], (	1✔
212	"expected package archive paths to match"
213	)
214	assert set(expected.values()).issubset(set(result_files))	1✔
215
216
217	def assert_pkg_target_built(	1✔
218	rule_runner: RuleRunner,
219	addr: Address,
220	*,
221	expected_import_path: str,
222	expected_dir_path: str,
223	expected_direct_dependency_import_paths: list[str],
224	expected_transitive_dependency_import_paths: list[str],
225	expected_go_file_names: list[str],
226	) -> None:
227	build_request = rule_runner.request(	1✔
228	BuildGoPackageRequest, [BuildGoPackageTargetRequest(addr, build_opts=GoBuildOptions())]
229	)
230	assert build_request.import_path == expected_import_path	1✔
231	assert build_request.dir_path == expected_dir_path	1✔
232	assert build_request.go_files == tuple(expected_go_file_names)	1✔
233	assert not build_request.s_files	1✔
234	assert sorted([dep.import_path for dep in build_request.direct_dependencies]) == sorted(	1✔
235	expected_direct_dependency_import_paths
236	)
237	assert_built(	1✔
238	rule_runner,
239	build_request,
240	expected_import_paths=[
241	expected_import_path,
242	*expected_direct_dependency_import_paths,
243	*expected_transitive_dependency_import_paths,
244	],
245	)
246
247
248	def test_build_first_party_pkg_target(rule_runner: RuleRunner) -> None:	1✔
249	rule_runner.write_files(	1✔
250	{
251	"go.mod": dedent(
252	"""\
253	module example.com/greeter
254	go 1.17
255	"""
256	),
257	"greeter.go": dedent(
258	"""\
259	package greeter
260
261	import "fmt"
262
263	func Hello() {
264	fmt.Println("Hello world!")
265	}
266	"""
267	),
268	"BUILD": "go_mod(name='mod')\ngo_package(name='pkg')",
269	}
270	)
271	assert_pkg_target_built(	1✔
272	rule_runner,
273	Address("", target_name="pkg"),
274	expected_import_path="example.com/greeter",
275	expected_dir_path="",
276	expected_go_file_names=["greeter.go"],
277	expected_direct_dependency_import_paths=["fmt"],
278	expected_transitive_dependency_import_paths=[],
279	)
280
281
282	def test_build_third_party_pkg_target(rule_runner: RuleRunner) -> None:	1✔
283	rule_runner.write_files(	1✔
284	{
285	"go.mod": dedent(
286	"""\
287	module example.com/greeter
288	go 1.17
289	require github.com/google/uuid v1.3.0
290	"""
291	),
292	"go.sum": dedent(
293	"""\
294	github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
295	github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
296	"""
297	),
298	"BUILD": "go_mod(name='mod')",
299	}
300	)
301	import_path = "github.com/google/uuid"	1✔
302	assert_pkg_target_built(	1✔
303	rule_runner,
304	Address("", target_name="mod", generated_name=import_path),
305	expected_import_path=import_path,
306	expected_dir_path="gopath/pkg/mod/github.com/google/uuid@v1.3.0",
307	expected_go_file_names=[
308	"dce.go",
309	"doc.go",
310	"hash.go",
311	"marshal.go",
312	"node.go",
313	"node_net.go",
314	"null.go",
315	"sql.go",
316	"time.go",
317	"util.go",
318	"uuid.go",
319	"version1.go",
320	"version4.go",
321	],
322	expected_direct_dependency_import_paths=[
323	"bytes",
324	"crypto/md5",
325	"crypto/rand",
326	"crypto/sha1",
327	"database/sql/driver",
328	"encoding/binary",
329	"encoding/hex",
330	"encoding/json",
331	"errors",
332	"fmt",
333	"hash",
334	"io",
335	"net",
336	"os",
337	"strings",
338	"sync",
339	"time",
340	],
341	expected_transitive_dependency_import_paths=[],
342	)
343
344
345	def test_build_target_with_dependencies(rule_runner: RuleRunner) -> None:	1✔
346	"""Check that we properly include (transitive) dependencies."""
347	rule_runner.write_files(	1✔
348	{
349	"greeter/quoter/lib.go": dedent(
350	"""\
351	package quoter
352
353	import "fmt"
354
355	func Quote(s string) string {
356	return fmt.Sprintf(">> %s <<", s)
357	}
358	"""
359	),
360	"greeter/quoter/BUILD": "go_package()",
361	"greeter/lib.go": dedent(
362	"""\
363	package greeter
364
365	import (
366	"fmt"
367	"example.com/project/greeter/quoter"
368	"golang.org/x/xerrors"
369	)
370
371	func QuotedHello() {
372	xerrors.New("some error")
373	fmt.Println(quoter.Quote("Hello world!"))
374	}
375	"""
376	),
377	"greeter/BUILD": "go_package()",
378	"main.go": dedent(
379	"""\
380	package main
381
382	import "example.com/project/greeter"
383
384	func main() {
385	greeter.QuotedHello()
386	}
387	"""
388	),
389	"go.mod": dedent(
390	"""\
391	module example.com/project
392	go 1.17
393	require golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
394	"""
395	),
396	"go.sum": dedent(
397	"""\
398	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
399	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
400	"""
401	),
402	"BUILD": "go_mod(name='mod')\ngo_package(name='pkg')",
403	}
404	)
405
406	xerrors_internal_import_path = "golang.org/x/xerrors/internal"	1✔
407	assert_pkg_target_built(	1✔
408	rule_runner,
409	Address("", target_name="mod", generated_name=xerrors_internal_import_path),
410	expected_import_path=xerrors_internal_import_path,
411	expected_dir_path="gopath/pkg/mod/golang.org/x/xerrors@v0.0.0-20191204190536-9bdfabe68543/internal",
412	expected_go_file_names=["internal.go"],
413	expected_direct_dependency_import_paths=[],
414	expected_transitive_dependency_import_paths=[],
415	)
416
417	xerrors_import_path = "golang.org/x/xerrors"	1✔
418	assert_pkg_target_built(	1✔
419	rule_runner,
420	Address("", target_name="mod", generated_name=xerrors_import_path),
421	expected_import_path=xerrors_import_path,
422	expected_dir_path="gopath/pkg/mod/golang.org/x/xerrors@v0.0.0-20191204190536-9bdfabe68543",
423	expected_go_file_names=[
424	"adaptor.go",
425	"doc.go",
426	"errors.go",
427	"fmt.go",
428	"format.go",
429	"frame.go",
430	"wrap.go",
431	],
432	expected_direct_dependency_import_paths=[
433	"bytes",
434	"fmt",
435	xerrors_internal_import_path,
436	"io",
437	"reflect",
438	"runtime",
439	"strconv",
440	"strings",
441	"unicode",
442	"unicode/utf8",
443	],
444	expected_transitive_dependency_import_paths=[],
445	)
446
447	quoter_import_path = "example.com/project/greeter/quoter"	1✔
448	assert_pkg_target_built(	1✔
449	rule_runner,
450	Address("greeter/quoter"),
451	expected_import_path=quoter_import_path,
452	expected_dir_path="greeter/quoter",
453	expected_go_file_names=["lib.go"],
454	expected_direct_dependency_import_paths=["fmt"],
455	expected_transitive_dependency_import_paths=[],
456	)
457
458	greeter_import_path = "example.com/project/greeter"	1✔
459	assert_pkg_target_built(	1✔
460	rule_runner,
461	Address("greeter"),
462	expected_import_path=greeter_import_path,
463	expected_dir_path="greeter",
464	expected_go_file_names=["lib.go"],
465	expected_direct_dependency_import_paths=["fmt", xerrors_import_path, quoter_import_path],
466	expected_transitive_dependency_import_paths=[xerrors_internal_import_path],
467	)
468
469	assert_pkg_target_built(	1✔
470	rule_runner,
471	Address("", target_name="pkg"),
472	expected_import_path="example.com/project",
473	expected_dir_path="",
474	expected_go_file_names=["main.go"],
475	expected_direct_dependency_import_paths=[greeter_import_path],
476	expected_transitive_dependency_import_paths=[
477	quoter_import_path,
478	xerrors_import_path,
479	xerrors_internal_import_path,
480	],
481	)
482
483
484	def test_build_invalid_target(rule_runner: RuleRunner) -> None:	1✔
485	rule_runner.write_files(	1✔
486	{
487	"go.mod": dedent(
488	"""\
489	module example.com/greeter
490	go 1.17
491	"""
492	),
493	"BUILD": "go_mod(name='mod')",
494	"direct/f.go": "invalid!!!",
495	"direct/BUILD": "go_package()",
496	"dep/f.go": "invalid!!!",
497	"dep/BUILD": "go_package()",
498	"uses_dep/f.go": dedent(
499	"""\
500	package uses_dep
501
502	import "example.com/greeter/dep"
503
504	func Hello() {
505	dep.Foo("Hello world!")
506	}
507	"""
508	),
509	"uses_dep/BUILD": "go_package()",
510	}
511	)
512
513	direct_build_request = rule_runner.request(	1✔
514	FallibleBuildGoPackageRequest,
515	[BuildGoPackageTargetRequest(Address("direct"), build_opts=GoBuildOptions())],
516	)
517	assert direct_build_request.request is None	1✔
518	assert direct_build_request.exit_code == 1	1✔
519	assert "direct/f.go:1:1: expected 'package', found invalid\n" in (	1✔
520	direct_build_request.stderr or ""
521	)
522
523	dep_build_request = rule_runner.request(	1✔
524	FallibleBuildGoPackageRequest,
525	[BuildGoPackageTargetRequest(Address("uses_dep"), build_opts=GoBuildOptions())],
526	)
527	assert dep_build_request.request is None	1✔
528	assert dep_build_request.exit_code == 1	1✔
529	assert "dep/f.go:1:1: expected 'package', found invalid\n" in (dep_build_request.stderr or "")	1✔
530
531
532	def test_build_codegen_target(rule_runner: RuleRunner) -> None:	1✔
533	rule_runner.write_files(	1✔
534	{
535	"go.mod": dedent(
536	"""\
537	module example.com/greeter
538	go 1.17
539	require github.com/google/uuid v1.3.0
540	"""
541	),
542	"go.sum": dedent(
543	"""\
544	github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
545	github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
546	"""
547	),
548	"generate_from_me.txt": "",
549	"greeter.go": dedent(
550	"""\
551	package greeter
552
553	import "fmt"
554	import "codegen.com/gen"
555
556	func Hello() {
557	fmt.Println(gen.Quote("Hello world!"))
558	}
559	"""
560	),
561	"BUILD": dedent(
562	"""\
563	go_mod(name='mod')
564	go_package(name='pkg', dependencies=[":gen"])
565	files(
566	name='gen',
567	sources=['generate_from_me.txt'],
568	dependencies=[':mod#github.com/google/uuid'],
569	)
570	"""
571	),
572	}
573	)
574
575	# Running directly on a codegen target should work.
576	assert_pkg_target_built(	1✔
577	rule_runner,
578	Address("", target_name="gen", relative_file_path="generate_from_me.txt"),
579	expected_import_path="codegen.com/gen",
580	expected_dir_path="codegen",
581	expected_go_file_names=["f.go"],
582	expected_direct_dependency_import_paths=["github.com/google/uuid"],
583	expected_transitive_dependency_import_paths=[],
584	)
585
586	# Direct dependencies on codegen targets must be propagated.
587	#
588	# Note that the `go_package` depends on the `files` generator target. This should work, even
589	# though `files` itself cannot generate, because it's an alias for all generated `file` targets.
590	assert_pkg_target_built(	1✔
591	rule_runner,
592	Address("", target_name="pkg"),
593	expected_import_path="example.com/greeter",
594	expected_dir_path="",
595	expected_go_file_names=["greeter.go"],
596	expected_direct_dependency_import_paths=["codegen.com/gen", "fmt"],
597	expected_transitive_dependency_import_paths=["github.com/google/uuid"],
598	)
599
600
601	def test_xtest_deps(rule_runner: RuleRunner) -> None:	1✔
602	rule_runner.write_files(	1✔
603	{
604	"go.mod": "module example.pantsbuild.org",
605	"BUILD": "go_mod(name='mod')\n",
606	"pkg/BUILD": "go_package()\n",
607	"pkg/example.go": dedent(
608	"""\
609	package pkg
610
611	const ExampleValue = 2137
612	"""
613	),
614	"pkg/example_test.go": dedent(
615	"""\
616	package pkg_test
617
618	import (
619	"example.pantsbuild.org/pkg"
620	"example.pantsbuild.org/pkg/testutils"
621	"testing"
622	)
623
624	func TestValue(t *testing.T) {
625	t.Run("Test", func(t *testing.T) {
626	if pkg.ExampleValue != testutils.ExampleValueFromTestutils {
627	t.Error("Not equal")
628	}
629	})
630	}
631	"""
632	),
633	"pkg/testutils/BUILD": "go_package()\n",
634	"pkg/testutils/testutils.go": dedent(
635	"""\
636	package testutils
637
638	import "example.pantsbuild.org/pkg"
639
640	const ExampleValueFromTestutils = pkg.ExampleValue
641	"""
642	),
643	}
644	)
645	assert_pkg_target_built(	1✔
646	rule_runner,
647	Address("pkg"),
648	expected_dir_path="pkg",
649	expected_import_path="example.pantsbuild.org/pkg",
650	expected_go_file_names=["example.go"],
651	expected_direct_dependency_import_paths=[],
652	expected_transitive_dependency_import_paths=[],
653	)
654
655
656	@pytest.mark.no_error_if_skipped	1✔
657	def test_stdlib_embed_config(rule_runner: RuleRunner) -> None:	1✔
658	stdlib_packages = rule_runner.request(	1✔
659	GoStdLibPackages, [GoStdLibPackagesRequest(with_race_detector=False, cgo_enabled=False)]
660	)
661
662	pkg_info: GoStdLibPackage \| None = None	1✔
663	for import_path in ("crypto/internal/nistec", "internal/trace/traceviewer/http"):	1✔
664	pkg_info = stdlib_packages.get(import_path)	1✔
665	if pkg_info:	1✔
NEW 666	break	×
667
668	if not pkg_info:	1✔
669	pytest.skip(	1✔
670	"Skipping test since no known stdlib import paths using embed are available for the test."
671	)
672
UNCOV 673	assert "embed" in pkg_info.imports	×
UNCOV 674	assert pkg_info.embed_patterns	×
UNCOV 675	assert pkg_info.embed_files	×
676
UNCOV 677	build_request = rule_runner.request(	×
678	BuildGoPackageRequest,
679	[
680	BuildGoPackageRequestForStdlibRequest(
681	import_path=pkg_info.import_path, build_opts=GoBuildOptions(cgo_enabled=False)
682	)
683	],
684	)
685
UNCOV 686	embed_config = build_request.embed_config	×
UNCOV 687	assert embed_config is not None	×
UNCOV 688	assert embed_config.patterns	×
UNCOV 689	assert embed_config.files	×

pantsbuild / pants / 18863956295

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