feat(api): add support for build status

The schema v5 will replace Builds.valid for Builds.status that has the
same values as Tests.status. To prepare for this change, we map the
current Builds.valid to its corresponding status (true -> PASS, false ->
FAIL and null -> NULL) and change every system that used the old values
for the new ones

Closes #1022

backend/kernelCI_app/constants/general.py

@@ -5,3 +5,5 @@
 UNCATEGORIZED_STRING = "Uncategorized"
 
 MAESTRO_DUMMY_BUILD_PREFIX = "maestro:dummy_"
+
+SCHEMA_VERSION_ENV = "SCHEMA_VERSION"

backend/kernelCI_app/helpers/build.py

@@ -1 +1,17 @@
-build_status_map = {True: "valid", False: "invalid", None: "null"}
+from typing import Optional
+import os
+
+from kernelCI_app.constants.general import SCHEMA_VERSION_ENV
+from kernelCI_app.typeModels.databases import PASS_STATUS, FAIL_STATUS, NULL_STATUS
+
+
+def build_status_map(status: Optional[bool | str]) -> str:
+    if isinstance(status, str):
+        return status
+    status_map = {True: PASS_STATUS, False: FAIL_STATUS, None: NULL_STATUS}
+    return status_map.get(status)
+
+
+def valid_status_field() -> str:
+    is_new_schema = os.getenv(SCHEMA_VERSION_ENV, "4") == "5"
+    return "status" if is_new_schema else "valid"

backend/kernelCI_app/helpers/commonDetails.py

@@ -9,11 +9,11 @@ def add_unfiltered_issue(
     issue_version: int,
     should_increment: bool,
     issue_set: Set,
-    is_invalid: bool,
+    is_failed_build: bool,
     unknown_issue_flag_dict: Dict[PossibleTabs, bool],
     unknown_issue_flag_tab: PossibleTabs,
 ) -> None:
     if issue_id is not None and issue_version is not None and should_increment:
         issue_set.add((issue_id, issue_version))
-    elif is_invalid is True:
+    elif is_failed_build is True:
         unknown_issue_flag_dict[unknown_issue_flag_tab] = True

backend/kernelCI_app/helpers/filters.py

@@ -4,15 +4,21 @@
 import re
 from kernelCI_app.constants.general import UNCATEGORIZED_STRING
 from kernelCI_app.helpers.commonDetails import PossibleTabs
-from kernelCI_app.typeModels.databases import PASS_STATUS, failure_status_list
+from kernelCI_app.typeModels.databases import (
+    PASS_STATUS,
+    NULL_STATUS,
+    FAIL_STATUS,
+    StatusValues,
+    failure_status_list,
+)
 from kernelCI_app.utils import get_error_body_response
 from kernelCI_app.constants.general import UNKNOWN_STRING
 
 NULL_STRINGS = set(["null", UNKNOWN_STRING, "NULL"])
 
 
-def is_build_invalid(build_valid: Optional[bool]) -> bool:
-    return build_valid is None or build_valid is False
+def is_build_invalid(build_status: StatusValues) -> bool:
+    return build_status == NULL_STATUS or build_status == FAIL_STATUS
 
 
 def is_test_failure(test_status: str) -> bool:
@@ -161,13 +167,13 @@ def should_filter_build_issue(
     issue_id: Optional[str],
     issue_version: Optional[int],
     incident_test_id: Optional[str],
-    build_valid: Optional[bool],
+    build_status: StatusValues,
 ) -> bool:
     has_issue_filter = len(issue_filters) > 0
     if not has_issue_filter:
         return False
 
-    if not is_build_invalid(build_valid):
+    if not is_build_invalid(build_status):
         return True
 
     has_uncategorized_filter = UNCATEGORIZED_STRING in issue_filters
@@ -222,7 +228,7 @@ def should_increment_build_issue(
     issue_id: Optional[str],
     issue_version: Optional[int],
     incident_test_id: Optional[str],
-    build_valid: Optional[bool],
+    build_status: StatusValues,
 ) -> Tuple[str, int, bool]:
     is_exclusively_test_issue_result = is_exclusively_test_issue(
         issue_id=issue_id,
@@ -238,7 +244,7 @@ def should_increment_build_issue(
         incident_test_id=incident_test_id,
     )
 
-    result = is_issue_from_build_result and is_build_invalid(build_valid)
+    result = is_issue_from_build_result and is_build_invalid(build_status)
 
     return (issue_id, issue_version, result)
 
@@ -255,11 +261,11 @@ def to_int_or_default(value, default):
     "boot.duration",
     "test.status",
     "test.duration",
+    "build.status",
     "duration",
     "config_name",
     "compiler",
     "architecture",
-    "valid",
     "test.hardware",
     "test.path",
     "boot.path",
@@ -321,7 +327,7 @@ def __init__(self, data: Dict, process_body=False) -> None:
         self.filterHardware = set()
         self.filterTestPath = ""
         self.filterBootPath = ""
-        self.filterBuildValid = set()
+        self.filterBuildStatus = set()
         self.filterIssues: dict[PossibleTabs, set[tuple[str, Optional[int]]]] = {
             "build": set(),
             "boot": set(),
@@ -337,11 +343,11 @@ def __init__(self, data: Dict, process_body=False) -> None:
             "boot.duration": self._handle_boot_duration,
             "test.status": self._handle_test_status,
             "test.duration": self._handle_test_duration,
-            "duration": self._handle_build_duration,
+            "build.status": self._handle_build_status,
+            "build.duration": self._handle_build_duration,
             "config_name": self._handle_config_name,
             "compiler": self._handle_compiler,
             "architecture": self._handle_architecture,
-            "valid": self._handle_build_valid,
             "test.hardware": self._handle_hardware,
             "test.path": self._handle_path,
             "boot.path": self._handle_path,
@@ -400,8 +406,8 @@ def _handle_path(self, current_filter: ParsedFilter) -> None:
         else:
             self.filterTestPath = current_filter["value"]
 
-    def _handle_build_valid(self, current_filter: ParsedFilter) -> None:
-        self.filterBuildValid.add(current_filter["value"])
+    def _handle_build_status(self, current_filter: ParsedFilter) -> None:
+        self.filterBuildStatus.add(current_filter["value"])
 
     def _handle_build_duration(self, current_filter: ParsedFilter) -> None:
         value = current_filter["value"][0]
@@ -539,15 +545,15 @@ def is_build_filtered_out(
         self,
         *,
         duration: Optional[int],
-        valid: Optional[bool],
+        build_status: StatusValues,
         issue_id: Optional[str],
         issue_version: Optional[int],
         incident_test_id: Optional[str],
     ) -> bool:
         return (
             (
-                len(self.filterBuildValid) > 0
-                and (str(valid).lower() not in self.filterBuildValid)
+                len(self.filterBuildStatus) > 0
+                and (build_status.upper() not in self.filterBuildStatus)
             )
             or (
                 (
@@ -570,7 +576,7 @@ def is_build_filtered_out(
                     issue_id=issue_id,
                     issue_version=issue_version,
                     incident_test_id=incident_test_id,
-                    build_valid=valid,
+                    build_status=build_status,
                 )
             )
         )