22285099215

Committed 22 Feb 2026 08:52PM UTC coverage: 75.854% (-17.1%) from 92.936%

Build # 22285099215

Build Type

Pull #23121

github

Committed by

web-flow

Commit Message

Merge c7299df9c into ba8359840

Pull Request Pull Request #23121: fix issue with optional fields in dependency validator

Run Details

28 of 29 new or added lines in 2 files covered. (96.55%)

11174 existing lines in 400 files now uncovered.

53694 of 70786 relevant lines covered (75.85%)

1.88 hits per line

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

96.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	3✔
4
5	import json	3✔
6	from dataclasses import dataclass	3✔
7
8	from pants.backend.go.go_sources import load_go_binary	3✔
9	from pants.backend.go.go_sources.load_go_binary import LoadedGoBinaryRequest, setup_go_binary	3✔
10	from pants.engine.addresses import Address	3✔
11	from pants.engine.engine_aware import EngineAwareParameter	3✔
12	from pants.engine.fs import Digest, MergeDigests	3✔
13	from pants.engine.internals.native_engine import EMPTY_DIGEST	3✔
14	from pants.engine.intrinsics import execute_process, merge_digests	3✔
15	from pants.engine.process import Process	3✔
16	from pants.engine.rules import collect_rules, implicitly, rule	3✔
17	from pants.util.logging import LogLevel	3✔
18	from pants.util.ordered_set import FrozenOrderedSet	3✔
19
20
21	@dataclass(frozen=True)	3✔
22	class GenerateTestMainRequest(EngineAwareParameter):	3✔
23	digest: Digest	3✔
24	test_paths: FrozenOrderedSet[str]	3✔
25	xtest_paths: FrozenOrderedSet[str]	3✔
26	import_path: str	3✔
27	register_cover: bool	3✔
28	address: Address	3✔
29
30	def debug_hint(self) -> str:	3✔
31	return self.address.spec	×
32
33
34	@dataclass(frozen=True)	3✔
35	class GeneratedTestMain:	3✔
36	digest: Digest	3✔
37	has_tests: bool	3✔
38	has_xtests: bool	3✔
39	failed_exit_code_and_stderr: tuple[int, str] \| None	3✔
40
41	TEST_MAIN_FILE = "testmain.go"	3✔
42	TEST_PKG = "_test"	3✔
43	XTEST_PKG = "_xtest"	3✔
44
45
46	@rule	3✔
47	async def generate_testmain(request: GenerateTestMainRequest) -> GeneratedTestMain:	3✔
48	generator_binary_name = "./generator"	3✔
49	analyzer = await setup_go_binary(	3✔
50	LoadedGoBinaryRequest("generate_testmain", ("main.go",), generator_binary_name),
51	**implicitly(),
52	)
53	input_digest = await merge_digests(MergeDigests([request.digest, analyzer.digest]))	3✔
54
55	test_paths = tuple(f"{GeneratedTestMain.TEST_PKG}:{path}" for path in request.test_paths)	3✔
56	xtest_paths = tuple(f"{GeneratedTestMain.XTEST_PKG}:{path}" for path in request.xtest_paths)	3✔
57
58	env = {}	3✔
59	if request.register_cover:	3✔
60	env["GENERATE_COVER"] = "1"	1✔
61
62	result = await execute_process(	3✔
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:	3✔
UNCOV 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"))	3✔
89	return GeneratedTestMain(	3✔
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():	3✔
98	return (collect_rules(), load_go_binary.rules())	3✔

pantsbuild / pants / 22285099215

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