GitHub/CI: Fix displaying failed PR workflow runs that succeeded already

Author: amotl

CHANGES.md

@@ -1,6 +1,8 @@
 # Change log
 
 ## In progress
+- GitHub/CI: Fixed displaying failed workflow runs on pull requests
+  which succeeded afterward
 
 ## v0.1.0, 2025-02-20
 - Started using `GH_TOKEN` environment variable instead of `GITHUB_TOKEN`,

src/rapporto/github/core.py

@@ -17,6 +17,7 @@
     GitHubActivityQueryBuilder,
     GitHubAttentionQueryBuilder,
     GitHubSearch,
+    MarkdownContent,
     MultiRepositoryInquiry,
     PullRequestMetadata,
 )
@@ -127,13 +128,22 @@ def print(self):
         print(self.markdown_significant)
 
 
-class GitHubActionsReport:
+class GitHubActionsRequest:
     """
-    Report about failed outcomes of GitHub Actions workflow runs.
+    Fetch outcomes of GitHub Actions workflow runs.
+
+    Possible event types are: dynamic, pull_request, push, schedule
     """
 
     DELTA_HOURS = 24
 
+    event_section_map = OrderedDict(
+        schedule="Schedule",
+        pull_request="Pull requests",
+        # push="Pushes",
+        dynamic="Dynamic",
+    )
+
     def __init__(self, inquiry: MultiRepositoryInquiry):
         self.inquiry = inquiry
         self.session = HttpClient.session
@@ -164,41 +174,75 @@ def fetch(self, filter: ActionsFilter) -> t.List[ActionsOutcome]:  # noqa:A002
             runs = munchify(response.json()).workflow_runs
             for run in runs:
                 outcome = ActionsOutcome(
+                    id=run.id,
+                    event=run.event,
                     status=run.status,
-                    repository=repository,
+                    conclusion=run.conclusion,
+                    repository=run.repository,
                     name=run.display_title,
                     url=run.html_url,
                     started=run.run_started_at,
+                    head_branch=run.head_branch,
                 )
                 outcomes.append(outcome)
         return outcomes
 
-    def to_markdown(self, filter: ActionsFilter) -> str:  # noqa:A002
-        return "\n".join([item.markdown for item in self.fetch(filter=filter)])
+    @property
+    def runs_failed(self):
+        return self.fetch(filter=ActionsFilter(status="failure", created=f">{self.yesterday}"))
 
     @property
-    def markdown(self):
-        items_scheduled = self.to_markdown(
-            ActionsFilter(event="schedule", status="failure", created=f">{self.yesterday}")
-        )
-        items_pull_requests = self.to_markdown(
-            ActionsFilter(event="pull_request", status="failure", created=f">{self.yesterday}")
-        )
-        items_dynamic = self.to_markdown(
-            ActionsFilter(event="dynamic", status="failure", created=f">{self.yesterday}")
+    def runs_pr_success(self):
+        return self.fetch(
+            filter=ActionsFilter(
+                event="pull_request", status="success", created=f">{self.yesterday}"
+            )
         )
-        return dedent(f"""
-# CI failures report {dt.datetime.now().strftime("%Y-%m-%d")}
-A report about GitHub Actions workflow runs that failed recently (now-{self.DELTA_HOURS}h).
 
-## Scheduled
-{items_scheduled or "n/a"}
 
-## Pull requests
-{items_pull_requests or "n/a"}
+class GitHubActionsReport:
+    """
+    Report about failed outcomes of GitHub Actions workflow runs.
+    """
+
+    def __init__(self, inquiry: MultiRepositoryInquiry):
+        self.inquiry = inquiry
+        self.request = GitHubActionsRequest(inquiry)
+        self.runs_failed = self.request.runs_failed
+        self.runs_pr_success = self.request.runs_pr_success
+
+    @property
+    def runs(self):
+        """
+        All failed runs, modulo subsequent succeeding PR runs.
+        """
+        for run in self.runs_failed:
+            if run.event == "pull_request" and self.is_pr_successful(run):
+                continue
+            yield run
 
-## Dynamic
-{items_dynamic or "n/a"}
+    def is_pr_successful(self, run):
+        """
+        Find out if a given run has others that succeeded afterward.
+        """
+        for pr in self.runs_pr_success:
+            if (
+                run.repository.full_name == pr.repository.full_name
+                and run.head_branch == pr.head_branch
+            ):
+                if pr.conclusion == "success":
+                    return True
+        return False
+
+    @property
+    def markdown(self):
+        mdc = MarkdownContent(labels=self.request.event_section_map)
+        for run in self.runs:
+            mdc.add(run.event, run.markdown)
+        return dedent(f"""
+# CI failures report {dt.datetime.now().strftime("%Y-%m-%d")}
+A report about GitHub Actions workflow runs that failed recently (now-{self.request.DELTA_HOURS}h).
+{mdc.render()}
         """).strip()  # noqa: E501
 
     def print(self):

src/rapporto/github/model.py

@@ -4,11 +4,13 @@
 import typing as t
 import urllib.parse
 from abc import abstractmethod
+from collections import OrderedDict
 from enum import Enum
 from pathlib import Path
 
 from attrs import define
 from dataclasses_json import CatchAll, Undefined, dataclass_json
+from munch import Munch
 
 from rapporto.util import sanitize_title
 
@@ -239,24 +241,59 @@ def make(cls, repository: str, repositories_file: Path = None) -> "MultiReposito
 
 @dataclasses.dataclass
 class ActionsFilter:
-    event: str
-    status: str
-    created: str
+    event: t.Optional[str] = None
+    status: t.Optional[str] = None
+    created: t.Optional[str] = None
 
     @property
     def query(self) -> str:
-        return f"event={self.event}&status={self.status}&created={self.created}"
+        expression = []
+        if self.event:
+            expression.append(f"event={self.event}")
+        if self.status:
+            expression.append(f"status={self.status}")
+        if self.created:
+            expression.append(f"created={self.created}")
+        return "&".join(expression)
 
 
 @dataclasses.dataclass
 class ActionsOutcome:
+    id: int
+    event: str
     status: str
-    repository: str
+    conclusion: str
+    repository: Munch
     name: str
     url: str
     started: str
+    head_branch: str
 
     @property
     def markdown(self):
-        title = sanitize_title(f"{self.repository}: {self.name}")
+        title = sanitize_title(f"{self.repository.full_name}: {self.name}")
         return f"- [{title}]({self.url})"
+
+
+@dataclasses.dataclass()
+class MarkdownContent:
+    labels: OrderedDict = dataclasses.field(default_factory=OrderedDict)
+    content: t.Dict[str, t.List[str]] = dataclasses.field(default_factory=dict)
+
+    def add(self, section, content):
+        self.content.setdefault(section, [])
+        self.content[section].append(content)
+
+    def render_section(self, section) -> t.Optional[str]:
+        if section not in self.content:
+            return None
+        label = self.labels.get(section, section)
+        body = "\n".join(self.content[section])
+        return f"\n## {label}\n{body}"
+
+    def render(self):
+        sections = []
+        for section in self.labels.keys():
+            if markdown := self.render_section(section):
+                sections.append(markdown)
+        return "\n".join(sections)