Fix GitHub status not updating to pending before evaluation

The status generator wasn't catching STARTED events because of confusion
between enum names (STARTED_NIX_EVAL) and values (started-nix-eval).
Events were produced with one format but the generator expected another,
so GitHub never received the pending status when evaluation started.

Standardized on using enum.value throughout for consistency with how
Buildbot's event system works.

Author: Mic92

buildbot_nix/buildbot_nix/__init__.py

@@ -101,14 +101,14 @@ def __init__(
         )
 
     async def run(self) -> int:  # type: ignore[override]
-        if self.build:
+        if self.build and self.master:
             await CombinedBuildEvent.produce_event_for_build(
                 self.master, CombinedBuildEvent.STARTED_NIX_EFFECTS, self.build, None
             )
 
         results = await super().run()
 
-        if self.build:
+        if self.build and self.master:
             await CombinedBuildEvent.produce_event_for_build(
                 self.master, CombinedBuildEvent.FINISHED_NIX_EFFECTS, self.build, None
             )
@@ -176,9 +176,8 @@ async def produce_event(self, event: str, result: None | int) -> None:
         )
         if result is not None:
             build["results"] = result
-        self.master.mq.produce(
-            ("builds", str(self.build.buildid), event), copy.deepcopy(build)
-        )
+        event_key = ("builds", str(self.build.buildid), event)
+        self.master.mq.produce(event_key, copy.deepcopy(build))
 
     async def run(self) -> int:
         await self.produce_event(CombinedBuildEvent.STARTED_NIX_EVAL.value, None)

buildbot_nix/buildbot_nix/nix_status_generator.py

@@ -72,28 +72,26 @@ async def produce_event_for_build(
             build_db: Any = await master.data.get(("builds", str(build.buildid)))
             if result is not None:
                 build_db["results"] = result
-            master.mq.produce(
-                ("builds", str(build.buildid), event.name), copy.deepcopy(build_db)
-            )
+            event_key = ("builds", str(build.buildid), event.value)
+            master.mq.produce(event_key, copy.deepcopy(build_db))
         elif isinstance(build, dict):
             if result is not None:
                 build["results"] = result
-            master.mq.produce(
-                ("builds", str(build["buildid"]), event.name), copy.deepcopy(build)
-            )
+            event_key = ("builds", str(build["buildid"]), event.value)
+            master.mq.produce(event_key, copy.deepcopy(build))
 
 
 @implementer(IReportGenerator)
 class BuildNixEvalStatusGenerator(BuildStatusGeneratorMixin):
     wanted_event_keys: ClassVar[list[Any]] = [
-        ("builds", None, str(CombinedBuildEvent.STARTED_NIX_EVAL.name)),
-        ("builds", None, str(CombinedBuildEvent.FINISHED_NIX_EVAL.name)),
-        ("builds", None, str(CombinedBuildEvent.STARTED_NIX_BUILD.name)),
-        ("builds", None, str(CombinedBuildEvent.FINISHED_NIX_BUILD.name)),
-        ("builds", None, str(CombinedBuildEvent.STARTED_NIX_EFFECTS.name)),
-        ("builds", None, str(CombinedBuildEvent.FINISHED_NIX_EFFECTS.name)),
-        ("buildrequests", None, str(CombinedBuildEvent.STARTED_NIX_BUILD.name)),
-        ("buildrequests", None, str(CombinedBuildEvent.FINISHED_NIX_BUILD.name)),
+        ("builds", None, CombinedBuildEvent.STARTED_NIX_EVAL.value),
+        ("builds", None, CombinedBuildEvent.FINISHED_NIX_EVAL.value),
+        ("builds", None, CombinedBuildEvent.STARTED_NIX_BUILD.value),
+        ("builds", None, CombinedBuildEvent.FINISHED_NIX_BUILD.value),
+        ("builds", None, CombinedBuildEvent.STARTED_NIX_EFFECTS.value),
+        ("builds", None, CombinedBuildEvent.FINISHED_NIX_EFFECTS.value),
+        ("buildrequests", None, CombinedBuildEvent.STARTED_NIX_BUILD.value),
+        ("buildrequests", None, CombinedBuildEvent.FINISHED_NIX_BUILD.value),
     ]
 
     compare_attrs: ClassVar[list[str]] = ["start_formatter", "end_formatter"]
@@ -185,9 +183,14 @@ async def generate(
     ) -> None | dict[str, Any]:
         what, _, event = key
         if what == "builds":
-            is_new = event == "new"
+            # Check if this is a start event
+            is_start_event = event in [
+                CombinedBuildEvent.STARTED_NIX_EVAL.value,
+                CombinedBuildEvent.STARTED_NIX_BUILD.value,
+                CombinedBuildEvent.STARTED_NIX_EFFECTS.value,
+            ]
 
-            formatter = self.start_formatter if is_new else self.end_formatter
+            formatter = self.start_formatter if is_start_event else self.end_formatter
 
             await getDetailsForBuild(
                 master,
@@ -204,9 +207,8 @@ async def generate(
             report: dict[str, Any] = await self.build_message(
                 formatter, master, reporter, data
             )
-
-            event_typed: CombinedBuildEvent = CombinedBuildEvent.__members__[event]
-            match event_typed:
+            event_type = CombinedBuildEvent(event)
+            match event_type:
                 case (
                     CombinedBuildEvent.STARTED_NIX_EVAL
                     | CombinedBuildEvent.FINISHED_NIX_EVAL
@@ -236,10 +238,10 @@ async def generate(
                         "generator",
                     )
                 case _:
-                    msg = f"Unexpected event: {event_typed}"
+                    msg = f"Unexpected event: {event_type}"
                     raise ValueError(msg)
 
-            match event_typed:
+            match event_type:
                 case (
                     CombinedBuildEvent.FINISHED_NIX_EVAL
                     | CombinedBuildEvent.FINISHED_NIX_BUILD