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

54.62

/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 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=[],
    )


def test_stdlib_embed_config(rule_runner: RuleRunner) -> None:
    import_path = "crypto/internal/nistec"
    stdlib_packages = rule_runner.request(
        GoStdLibPackages, [GoStdLibPackagesRequest(with_race_detector=False, cgo_enabled=False)]
    )
    pkg_info = stdlib_packages.get(import_path)
    if not pkg_info:
        pytest.skip(
            f"Skipping test since `{import_path}` import path not available in Go standard library."
        )

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

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