fix: fallback to origin when lab/runtime is missing in standardize_labs (#1844)

* fix: fallback to origin when lab/runtime is missing in standardize_labs

When a build or test has no lab (builds) or runtime (tests) field in misc,
use the origin field as a fallback value. This avoids losing origin context
for entries that lack explicit lab information.

Closes #1752

* refactor: extract _standardize_lab_field to remove duplicated logic

Move the shared build/test lab normalization logic into a private helper
_standardize_lab_field(item, field). Both builds ("lab") and tests
("runtime") now delegate to it, eliminating the duplicated
AUTOMATIC_LAB_FIELD + origin-fallback blocks.

Add TestStandardizeLabField unit tests covering all branches of the helper.

Author: André Luiz

backend/kernelCI_app/management/commands/helpers/kcidbng_ingester.py

@@ -91,24 +91,37 @@ def standardize_tree_names(
                 checkout["tree_name"] = correct_tree
 
 
+def _standardize_lab_field(item: dict[str, Any], field: str) -> None:
+    """
+    Moves automatic lab/runtime value to AUTOMATIC_LAB_FIELD and falls back to origin.
+
+        lab is AUTOMATIC_LAB -> fallback to origin
+        lab is None -> fallback to origin
+        lab is not None -> do nothing
+    """
+    lab = item.get("misc", {}).get(field)
+    is_automatic = lab and AUTOMATIC_LABS.match(lab)
+    if is_automatic:
+        item["misc"][AUTOMATIC_LAB_FIELD] = lab
+        item["misc"].pop(field, None)
+        lab = None
+
+    if not lab or is_automatic:
+        origin = item.get("origin")
+        if origin:
+            item.setdefault("misc", {})[field] = origin
+
+
 def standardize_labs(input_data: dict[str, Any]) -> None:
     """
-    Standardize labs in data, moving automatic lab names to AUTOMATIC_LAB_FIELD
+    Standardize labs in data, moving automatic lab names to AUTOMATIC_LAB_FIELD.
+    Falls back to 'origin' when 'lab' (builds) or 'runtime' (tests) is missing.
     """
+    for build in input_data.get("builds", []):
+        _standardize_lab_field(build, "lab")
 
-    builds: list[dict[str, Any]] = input_data.get("builds", [])
-    for build in builds:
-        lab = build.get("misc", {}).get("lab")
-        if lab and AUTOMATIC_LABS.match(lab):
-            build["misc"][AUTOMATIC_LAB_FIELD] = lab
-            build["misc"].pop("lab", None)
-
-    tests: list[dict[str, Any]] = input_data.get("tests", [])
-    for test in tests:
-        lab = test.get("misc", {}).get("runtime")
-        if lab and AUTOMATIC_LABS.match(lab):
-            test["misc"][AUTOMATIC_LAB_FIELD] = lab
-            test["misc"].pop("runtime", None)
+    for test in input_data.get("tests", []):
+        _standardize_lab_field(test, "runtime")
 
 
 def _extract_origins_info(data: Optional[dict[str, Any]]) -> str:

backend/kernelCI_app/tests/unitTests/commands/monitorSubmissions/kcidbng_ingester_test.py

@@ -20,6 +20,7 @@
     SubmissionFileMetadata,
     standardize_tree_names,
     standardize_labs,
+    _standardize_lab_field,
     prepare_file_data,
     consume_buffer,
     flush_buffers,
@@ -200,17 +201,64 @@ def test_standardize_tree_names_missing_tree_name(self):
         assert "tree_name" not in input_data["checkouts"][1]
 
 
+class TestStandardizeLabField:
+    """Test cases for _standardize_lab_field helper."""
+
+    # Test cases:
+    # - automatic value with origin → moved to AUTOMATIC_LAB_FIELD, origin used as fallback
+    # - automatic value without origin → moved to AUTOMATIC_LAB_FIELD, field left absent
+    # - missing field with origin → origin used as fallback
+    # - missing field without origin → field stays absent
+    # - real value → unchanged
+
+    def test_automatic_lab_with_origin(self):
+        """Automatic value is moved to AUTOMATIC_LAB_FIELD and origin fills the field."""
+        item = {"misc": {"lab": "shell"}, "origin": "maestro"}
+        _standardize_lab_field(item, "lab")
+        assert item["misc"][AUTOMATIC_LAB_FIELD] == "shell"
+        assert item["misc"]["lab"] == "maestro"
+
+    def test_automatic_lab_without_origin(self):
+        """Automatic value is moved to AUTOMATIC_LAB_FIELD; field stays absent."""
+        item = {"misc": {"lab": "k8s"}}
+        _standardize_lab_field(item, "lab")
+        assert item["misc"][AUTOMATIC_LAB_FIELD] == "k8s"
+        assert "lab" not in item["misc"]
+
+    def test_missing_field_with_origin(self):
+        """Missing field is filled with origin."""
+        item = {"misc": {}, "origin": "broonie"}
+        _standardize_lab_field(item, "runtime")
+        assert item["misc"]["runtime"] == "broonie"
+
+    def test_missing_field_without_origin(self):
+        """Missing field stays absent when there is no origin."""
+        item = {"misc": {}}
+        _standardize_lab_field(item, "runtime")
+        assert "runtime" not in item["misc"]
+
+    def test_real_value_unchanged(self):
+        """A real (non-automatic) lab value is left untouched."""
+        item = {"misc": {"lab": "collabora"}, "origin": "redhat"}
+        _standardize_lab_field(item, "lab")
+        assert item["misc"]["lab"] == "collabora"
+        assert AUTOMATIC_LAB_FIELD not in item["misc"]
+
+
 class TestStandardizeLabs:
     """Test cases for standardize_labs function."""
 
     # Test cases:
-    # - builds/tests with missing misc field
-    # - builds/tests with misc but not lab field
+    # - builds/tests with missing misc field, no origin
+    # - builds/tests with missing misc field, with origin (fallback)
+    # - builds/tests with misc but not lab field, no origin
+    # - builds/tests with misc but not lab field, with origin (fallback)
     # - empty builds/tests data
     # - builds/tests with real/automatic labs/runtimes
+    # - builds/tests with automatic lab and origin (origin IS used as fallback)
 
-    def test_standardize_labs_missing_misc(self):
-        """Test with builds/tests missing misc field."""
+    def test_standardize_labs_missing_misc_no_origin(self):
+        """Test with builds/tests missing misc field and no origin: misc not created."""
         input_data = {
             "builds": [
                 {"id": "build1"},
@@ -225,8 +273,25 @@ def test_standardize_labs_missing_misc(self):
         assert "misc" not in input_data["builds"][0]
         assert "misc" not in input_data["tests"][0]
 
-    def test_standardize_labs_missing_lab_runtime(self):
-        """Test with builds/tests having misc but missing lab/runtime field."""
+    def test_standardize_labs_missing_misc_with_origin_fallback(self):
+        """Test with builds/tests missing misc but with origin: misc created with origin as lab."""
+        origin = "broonie"
+        input_data = {
+            "builds": [
+                {"id": "build1", "origin": origin},
+            ],
+            "tests": [
+                {"id": "test1", "origin": origin},
+            ],
+        }
+
+        standardize_labs(input_data)
+
+        assert input_data["builds"][0]["misc"]["lab"] == origin
+        assert input_data["tests"][0]["misc"]["runtime"] == origin
+
+    def test_standardize_labs_missing_lab_runtime_no_origin(self):
+        """Test with builds/tests having misc but missing lab/runtime and no origin: unchanged."""
         input_data = {
             "builds": [
                 {
@@ -251,6 +316,25 @@ def test_standardize_labs_missing_lab_runtime(self):
         assert "runtime" not in input_data["tests"][0]["misc"]
         assert AUTOMATIC_LAB_FIELD not in input_data["tests"][0]["misc"]
 
+    def test_standardize_labs_missing_lab_runtime_with_origin_fallback(self):
+        """Test with builds/tests having misc but missing lab/runtime with origin: origin used."""
+        origin = "redhat"
+        input_data = {
+            "builds": [
+                {"misc": {"other_field": "value"}, "origin": origin},
+            ],
+            "tests": [
+                {"misc": {"platform": "x86"}, "origin": origin},
+            ],
+        }
+
+        standardize_labs(input_data)
+
+        assert input_data["builds"][0]["misc"]["lab"] == origin
+        assert AUTOMATIC_LAB_FIELD not in input_data["builds"][0]["misc"]
+        assert input_data["tests"][0]["misc"]["runtime"] == origin
+        assert AUTOMATIC_LAB_FIELD not in input_data["tests"][0]["misc"]
+
     def test_standardize_labs_empty_data(self):
         """Test with empty builds and tests."""
         input_data = {
@@ -263,6 +347,26 @@ def test_standardize_labs_empty_data(self):
         assert input_data["builds"] == []
         assert input_data["tests"] == []
 
+    def test_standardize_labs_automatic_lab_with_origin_falls_back(self):
+        """Test that when an automatic lab is present, origin IS used as fallback for lab/runtime."""
+        origin = "maestro"
+        input_data = {
+            "builds": [
+                {"misc": {"lab": "shell"}, "origin": origin},
+            ],
+            "tests": [
+                {"misc": {"runtime": "k8s"}, "origin": origin},
+            ],
+        }
+
+        standardize_labs(input_data)
+
+        # Automatic lab moved to AUTOMATIC_LAB_FIELD, origin used as fallback for lab/runtime
+        assert input_data["builds"][0]["misc"][AUTOMATIC_LAB_FIELD] == "shell"
+        assert input_data["builds"][0]["misc"]["lab"] == origin
+        assert input_data["tests"][0]["misc"][AUTOMATIC_LAB_FIELD] == "k8s"
+        assert input_data["tests"][0]["misc"]["runtime"] == origin
+
     def test_standardize_labs_mixed_builds_and_tests(self):
         """Test with a mix of automatic and real labs/runtimes."""
         input_data = {