18252174847

Committed 05 Oct 2025 01:36AM UTC coverage: 43.382% (-36.9%) from 80.261%

Build # 18252174847

Build Type

push

github

Committed by

web-flow

Commit Message

run tests on mac arm (#22717)

Just doing the minimal to pull forward the x86_64 pattern.

ref #20993

Run Details

25776 of 59416 relevant lines covered (43.38%)

1.3 hits per line

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

0.0

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

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

from dataclasses import dataclass

from pants.backend.go.subsystems.gotest import GoTestSubsystem
from pants.backend.go.util_rules import coverage_html
from pants.backend.go.util_rules.coverage import GoCoverageData
from pants.backend.go.util_rules.coverage_html import (
    RenderGoCoverageProfileToHtmlRequest,
    render_go_coverage_profile_to_html,
)
from pants.core.goals.test import CoverageDataCollection, CoverageReports, FilesystemCoverageReport
from pants.core.util_rules import distdir
from pants.core.util_rules.distdir import DistDir
from pants.engine.engine_aware import EngineAwareParameter
from pants.engine.fs import CreateDigest, FileContent
from pants.engine.internals.selectors import concurrently
from pants.engine.intrinsics import digest_to_snapshot, get_digest_contents
from pants.engine.rules import collect_rules, implicitly, rule
from pants.engine.unions import UnionRule
from pants.util.logging import LogLevel


class GoCoverageDataCollection(CoverageDataCollection):
    element_type = GoCoverageData


@dataclass(frozen=True)
class RenderGoCoverageReportRequest(EngineAwareParameter):
    raw_report: GoCoverageData

    def debug_hint(self) -> str | None:
        return self.raw_report.import_path


@dataclass(frozen=True)
class RenderGoCoverageReportResult:
    coverage_report: FilesystemCoverageReport
    html_report: FilesystemCoverageReport | None = None


@rule
async def go_render_coverage_report(
    request: RenderGoCoverageReportRequest,
    distdir_value: DistDir,
    go_test_subsystem: GoTestSubsystem,
) -> RenderGoCoverageReportResult:
    output_dir = go_test_subsystem.coverage_output_dir(
        distdir=distdir_value,
        address=request.raw_report.pkg_target_address,
        import_path=request.raw_report.import_path,
    )
    snapshot, digest_contents = await concurrently(
        digest_to_snapshot(request.raw_report.coverage_digest),
        get_digest_contents(request.raw_report.coverage_digest),
    )

    html_coverage_report: FilesystemCoverageReport | None = None
    if go_test_subsystem.coverage_html:
        html_result = await render_go_coverage_profile_to_html(
            RenderGoCoverageProfileToHtmlRequest(
                raw_coverage_profile=digest_contents[0].content,
                description_of_origin=f"Go package with import path `{request.raw_report.import_path}`",
                sources_digest=request.raw_report.sources_digest,
                sources_dir_path=request.raw_report.sources_dir_path,
            )
        )
        html_report_snapshot = await digest_to_snapshot(
            **implicitly(
                CreateDigest(
                    [
                        FileContent(
                            path="coverage.html",
                            content=html_result.html_output,
                        )
                    ]
                )
            )
        )

        html_coverage_report = FilesystemCoverageReport(
            coverage_insufficient=False,
            result_snapshot=html_report_snapshot,
            directory_to_materialize_to=output_dir,
            report_file=output_dir / "coverage.html",
            report_type="go_cover_html",
        )

    coverage_report = FilesystemCoverageReport(
        coverage_insufficient=False,
        result_snapshot=snapshot,
        directory_to_materialize_to=output_dir,
        report_file=output_dir / "cover.out",
        report_type="go_cover",
    )
    return RenderGoCoverageReportResult(
        coverage_report=coverage_report,
        html_report=html_coverage_report,
    )


@rule(desc="Merge Go coverage data", level=LogLevel.DEBUG)
async def go_gather_coverage_reports(
    raw_coverage_reports: GoCoverageDataCollection,
) -> CoverageReports:
    coverage_report_results = await concurrently(
        go_render_coverage_report(
            RenderGoCoverageReportRequest(
                raw_report=raw_coverage_report,
            ),
            **implicitly(),
        )
        for raw_coverage_report in raw_coverage_reports
    )

    coverage_reports = []
    for result in coverage_report_results:
        coverage_reports.append(result.coverage_report)
        if result.html_report:
            coverage_reports.append(result.html_report)

    return CoverageReports(reports=tuple(coverage_reports))


def rules():
    return (
        *collect_rules(),
        *coverage_html.rules(),
        *distdir.rules(),
        UnionRule(CoverageDataCollection, GoCoverageDataCollection),
    )

1	# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3	from __future__ import annotations	×
4
5	from dataclasses import dataclass	×
6
7	from pants.backend.go.subsystems.gotest import GoTestSubsystem	×
8	from pants.backend.go.util_rules import coverage_html	×
9	from pants.backend.go.util_rules.coverage import GoCoverageData	×
10	from pants.backend.go.util_rules.coverage_html import (	×
11	RenderGoCoverageProfileToHtmlRequest,
12	render_go_coverage_profile_to_html,
13	)
14	from pants.core.goals.test import CoverageDataCollection, CoverageReports, FilesystemCoverageReport	×
15	from pants.core.util_rules import distdir	×
16	from pants.core.util_rules.distdir import DistDir	×
17	from pants.engine.engine_aware import EngineAwareParameter	×
18	from pants.engine.fs import CreateDigest, FileContent	×
19	from pants.engine.internals.selectors import concurrently	×
20	from pants.engine.intrinsics import digest_to_snapshot, get_digest_contents	×
21	from pants.engine.rules import collect_rules, implicitly, rule	×
22	from pants.engine.unions import UnionRule	×
23	from pants.util.logging import LogLevel	×
24
25
26	class GoCoverageDataCollection(CoverageDataCollection):	×
27	element_type = GoCoverageData	×
28
29
30	@dataclass(frozen=True)	×
31	class RenderGoCoverageReportRequest(EngineAwareParameter):	×
32	raw_report: GoCoverageData	×
33
34	def debug_hint(self) -> str \| None:	×
35	return self.raw_report.import_path	×
36
37
38	@dataclass(frozen=True)	×
39	class RenderGoCoverageReportResult:	×
40	coverage_report: FilesystemCoverageReport	×
41	html_report: FilesystemCoverageReport \| None = None	×
42
43
44	@rule	×
45	async def go_render_coverage_report(	×
46	request: RenderGoCoverageReportRequest,
47	distdir_value: DistDir,
48	go_test_subsystem: GoTestSubsystem,
49	) -> RenderGoCoverageReportResult:
50	output_dir = go_test_subsystem.coverage_output_dir(	×
51	distdir=distdir_value,
52	address=request.raw_report.pkg_target_address,
53	import_path=request.raw_report.import_path,
54	)
55	snapshot, digest_contents = await concurrently(	×
56	digest_to_snapshot(request.raw_report.coverage_digest),
57	get_digest_contents(request.raw_report.coverage_digest),
58	)
59
60	html_coverage_report: FilesystemCoverageReport \| None = None	×
61	if go_test_subsystem.coverage_html:	×
62	html_result = await render_go_coverage_profile_to_html(	×
63	RenderGoCoverageProfileToHtmlRequest(
64	raw_coverage_profile=digest_contents[0].content,
65	description_of_origin=f"Go package with import path `{request.raw_report.import_path}`",
66	sources_digest=request.raw_report.sources_digest,
67	sources_dir_path=request.raw_report.sources_dir_path,
68	)
69	)
70	html_report_snapshot = await digest_to_snapshot(	×
71	**implicitly(
72	CreateDigest(
73	[
74	FileContent(
75	path="coverage.html",
76	content=html_result.html_output,
77	)
78	]
79	)
80	)
81	)
82
83	html_coverage_report = FilesystemCoverageReport(	×
84	coverage_insufficient=False,
85	result_snapshot=html_report_snapshot,
86	directory_to_materialize_to=output_dir,
87	report_file=output_dir / "coverage.html",
88	report_type="go_cover_html",
89	)
90
91	coverage_report = FilesystemCoverageReport(	×
92	coverage_insufficient=False,
93	result_snapshot=snapshot,
94	directory_to_materialize_to=output_dir,
95	report_file=output_dir / "cover.out",
96	report_type="go_cover",
97	)
98	return RenderGoCoverageReportResult(	×
99	coverage_report=coverage_report,
100	html_report=html_coverage_report,
101	)
102
103
104	@rule(desc="Merge Go coverage data", level=LogLevel.DEBUG)	×
105	async def go_gather_coverage_reports(	×
106	raw_coverage_reports: GoCoverageDataCollection,
107	) -> CoverageReports:
108	coverage_report_results = await concurrently(	×
109	go_render_coverage_report(
110	RenderGoCoverageReportRequest(
111	raw_report=raw_coverage_report,
112	),
113	**implicitly(),
114	)
115	for raw_coverage_report in raw_coverage_reports
116	)
117
118	coverage_reports = []	×
119	for result in coverage_report_results:	×
120	coverage_reports.append(result.coverage_report)	×
121	if result.html_report:	×
122	coverage_reports.append(result.html_report)	×
123
124	return CoverageReports(reports=tuple(coverage_reports))	×
125
126
127	def rules():	×
128	return (	×
129	*collect_rules(),
130	*coverage_html.rules(),
131	*distdir.rules(),
132	UnionRule(CoverageDataCollection, GoCoverageDataCollection),
133	)

pantsbuild / pants / 18252174847

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