23074067894

Committed 13 Mar 2026 11:06PM UTC coverage: 64.165% (-28.8%) from 92.932%

Build # 23074067894

Build Type

Pull #23171

github

Committed by

web-flow

Commit Message

Merge 17d8ea7d8 into f07276df6

Pull Request Pull Request #23171: Debug reapi test cache misses

Run Details

42163 of 65710 relevant lines covered (64.17%)

0.99 hits per line

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

94.0

/src/python/pants/backend/go/util_rules/tests_analysis.py

# Copyright 2021 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import annotations

import json
from dataclasses import dataclass

from pants.backend.go.go_sources import load_go_binary
from pants.backend.go.go_sources.load_go_binary import LoadedGoBinaryRequest, setup_go_binary
from pants.engine.addresses import Address
from pants.engine.engine_aware import EngineAwareParameter
from pants.engine.fs import Digest, MergeDigests
from pants.engine.internals.native_engine import EMPTY_DIGEST
from pants.engine.intrinsics import execute_process, merge_digests
from pants.engine.process import Process
from pants.engine.rules import collect_rules, implicitly, rule
from pants.util.logging import LogLevel
from pants.util.ordered_set import FrozenOrderedSet


@dataclass(frozen=True)
class GenerateTestMainRequest(EngineAwareParameter):
    digest: Digest
    test_paths: FrozenOrderedSet[str]
    xtest_paths: FrozenOrderedSet[str]
    import_path: str
    register_cover: bool
    address: Address

    def debug_hint(self) -> str:
        return self.address.spec


@dataclass(frozen=True)
class GeneratedTestMain:
    digest: Digest
    has_tests: bool
    has_xtests: bool
    failed_exit_code_and_stderr: tuple[int, str] | None

    TEST_MAIN_FILE = "testmain.go"
    TEST_PKG = "_test"
    XTEST_PKG = "_xtest"


@rule
async def generate_testmain(request: GenerateTestMainRequest) -> GeneratedTestMain:
    generator_binary_name = "./generator"
    analyzer = await setup_go_binary(
        LoadedGoBinaryRequest("generate_testmain", ("main.go",), generator_binary_name),
        **implicitly(),
    )
    input_digest = await merge_digests(MergeDigests([request.digest, analyzer.digest]))

    test_paths = tuple(f"{GeneratedTestMain.TEST_PKG}:{path}" for path in request.test_paths)
    xtest_paths = tuple(f"{GeneratedTestMain.XTEST_PKG}:{path}" for path in request.xtest_paths)

    env = {}
    if request.register_cover:
        env["GENERATE_COVER"] = "1"

    result = await execute_process(
        Process(
            argv=(
                generator_binary_name,
                GeneratedTestMain.TEST_MAIN_FILE,
                request.import_path,
                *test_paths,
                *xtest_paths,
            ),
            input_digest=input_digest,
            env=env,
            description=f"Analyze Go test sources for {request.address}",
            level=LogLevel.DEBUG,
            output_files=(GeneratedTestMain.TEST_MAIN_FILE,),
        ),
        **implicitly(),
    )

    if result.exit_code != 0:
        return GeneratedTestMain(
            digest=EMPTY_DIGEST,
            has_tests=False,
            has_xtests=False,
            failed_exit_code_and_stderr=(result.exit_code, result.stderr.decode("utf-8")),
        )

    metadata = json.loads(result.stdout.decode("utf-8"))
    return GeneratedTestMain(
        digest=result.output_digest,
        has_tests=metadata["has_tests"],
        has_xtests=metadata["has_xtests"],
        failed_exit_code_and_stderr=None,
    )


def rules():
    return (*collect_rules(), *load_go_binary.rules())

1	# Copyright 2021 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3	from __future__ import annotations	1✔
4
5	import json	1✔
6	from dataclasses import dataclass	1✔
7
8	from pants.backend.go.go_sources import load_go_binary	1✔
9	from pants.backend.go.go_sources.load_go_binary import LoadedGoBinaryRequest, setup_go_binary	1✔
10	from pants.engine.addresses import Address	1✔
11	from pants.engine.engine_aware import EngineAwareParameter	1✔
12	from pants.engine.fs import Digest, MergeDigests	1✔
13	from pants.engine.internals.native_engine import EMPTY_DIGEST	1✔
14	from pants.engine.intrinsics import execute_process, merge_digests	1✔
15	from pants.engine.process import Process	1✔
16	from pants.engine.rules import collect_rules, implicitly, rule	1✔
17	from pants.util.logging import LogLevel	1✔
18	from pants.util.ordered_set import FrozenOrderedSet	1✔
19
20
21	@dataclass(frozen=True)	1✔
22	class GenerateTestMainRequest(EngineAwareParameter):	1✔
23	digest: Digest	1✔
24	test_paths: FrozenOrderedSet[str]	1✔
25	xtest_paths: FrozenOrderedSet[str]	1✔
26	import_path: str	1✔
27	register_cover: bool	1✔
28	address: Address	1✔
29
30	def debug_hint(self) -> str:	1✔
31	return self.address.spec	×
32
33
34	@dataclass(frozen=True)	1✔
35	class GeneratedTestMain:	1✔
36	digest: Digest	1✔
37	has_tests: bool	1✔
38	has_xtests: bool	1✔
39	failed_exit_code_and_stderr: tuple[int, str] \| None	1✔
40
41	TEST_MAIN_FILE = "testmain.go"	1✔
42	TEST_PKG = "_test"	1✔
43	XTEST_PKG = "_xtest"	1✔
44
45
46	@rule	1✔
47	async def generate_testmain(request: GenerateTestMainRequest) -> GeneratedTestMain:	1✔
48	generator_binary_name = "./generator"	1✔
49	analyzer = await setup_go_binary(	1✔
50	LoadedGoBinaryRequest("generate_testmain", ("main.go",), generator_binary_name),
51	**implicitly(),
52	)
53	input_digest = await merge_digests(MergeDigests([request.digest, analyzer.digest]))	1✔
54
55	test_paths = tuple(f"{GeneratedTestMain.TEST_PKG}:{path}" for path in request.test_paths)	1✔
56	xtest_paths = tuple(f"{GeneratedTestMain.XTEST_PKG}:{path}" for path in request.xtest_paths)	1✔
57
58	env = {}	1✔
59	if request.register_cover:	1✔
60	env["GENERATE_COVER"] = "1"	×
61
62	result = await execute_process(	1✔
63	Process(
64	argv=(
65	generator_binary_name,
66	GeneratedTestMain.TEST_MAIN_FILE,
67	request.import_path,
68	*test_paths,
69	*xtest_paths,
70	),
71	input_digest=input_digest,
72	env=env,
73	description=f"Analyze Go test sources for {request.address}",
74	level=LogLevel.DEBUG,
75	output_files=(GeneratedTestMain.TEST_MAIN_FILE,),
76	),
77	**implicitly(),
78	)
79
80	if result.exit_code != 0:	1✔
81	return GeneratedTestMain(	×
82	digest=EMPTY_DIGEST,
83	has_tests=False,
84	has_xtests=False,
85	failed_exit_code_and_stderr=(result.exit_code, result.stderr.decode("utf-8")),
86	)
87
88	metadata = json.loads(result.stdout.decode("utf-8"))	1✔
89	return GeneratedTestMain(	1✔
90	digest=result.output_digest,
91	has_tests=metadata["has_tests"],
92	has_xtests=metadata["has_xtests"],
93	failed_exit_code_and_stderr=None,
94	)
95
96
97	def rules():	1✔
98	return (collect_rules(), load_go_binary.rules())	1✔

pantsbuild / pants / 23074067894

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