18860513584

Committed 28 Oct 2025 12:53AM UTC coverage: 80.277%. First build

Build # 18860513584

Build Type

Pull #22810

github

Committed by

web-flow

Commit Message

Merge 4841a9179 into 71e4578a4

Pull Request Pull Request #22810: CI: update Go SDK version to v1.25.3

Coverage Stats

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

77945 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
673	assert "embed" in pkg_info.imports	×
674	assert pkg_info.embed_patterns	×
675	assert pkg_info.embed_files	×
676
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
686	embed_config = build_request.embed_config	×
687	assert embed_config is not None	×
688	assert embed_config.patterns	×
689	assert embed_config.files	×

pantsbuild / pants / 18860513584

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