buildkite: handle matrix attributes in unexpected locations

soft_fail contains a list of dicts, and the matrix processing was seeing
it and getting confused. This change makes lists and dicts get processed
all the way down, and also completely ignores data types it doesn't know
how to process, rather than blowing up on them.

Fixes #2486

Author: novas0x2a

buildkite/bazelci.py

@@ -921,6 +921,20 @@ def match_matrix_attr_pattern(s):
     return re.match(r"^\${{\s*(\w+)\s*}}$", s)
 
 
+def get_matrix_attributes_for_value(value):
+    if isinstance(value, str):
+        res = match_matrix_attr_pattern(value)
+        if res:
+            yield res.groups()[0]
+    elif isinstance(value, list):
+        for subvalue in value:
+            yield from get_matrix_attributes_for_value(subvalue)
+    elif isinstance(value, dict):
+        for subkey, subvalue in value.items():
+            yield from get_matrix_attributes_for_value(subkey)
+            yield from get_matrix_attributes_for_value(subvalue)
+
+
 def get_matrix_attributes(task):
     """Get unexpanded matrix attributes from the given task.
 
@@ -929,16 +943,7 @@ def get_matrix_attributes(task):
     """
     attributes = set()
     for value in task.values():
-        if type(value) is str:
-            res = match_matrix_attr_pattern(value)
-            if res:
-                attributes.add(res.groups()[0])
-        elif type(value) is list:
-            for subvalue in value:
-                res = match_matrix_attr_pattern(subvalue)
-                if res:
-                    attributes.add(res.groups()[0])
-
+        attributes.update(get_matrix_attributes_for_value(value))
     return sorted(attributes)
 
 
@@ -1005,22 +1010,27 @@ def get_combinations(matrix, attributes, excludes=None):
     return all_combinations
 
 
+def expand_task_for_value(value, parent, parent_item, lookup):
+    if isinstance(value, str):
+        res = match_matrix_attr_pattern(value)
+        if res:
+            attr = res.groups()[0]
+            parent[parent_item] = lookup[attr].value
+    elif isinstance(value, list):
+        for i, subvalue in enumerate(value):
+            expand_task_for_value(subvalue, parent[parent_item], i, lookup)
+    elif isinstance(value, dict):
+        for subkey, subvalue in value.items():
+            expand_task_for_value(subvalue, parent[parent_item], subkey, lookup)
+            expand_task_for_value(subvalue, parent[parent_item], subkey, lookup)
+
+
 def get_expanded_task(task, combination):
     """Expand a task with the given combination of values of attributes."""
     combination = dict(combination)
     expanded_task = copy.deepcopy(task)
     for key, value in task.items():
-        if type(value) is str:
-            res = match_matrix_attr_pattern(value)
-            if res:
-                attr = res.groups()[0]
-                expanded_task[key] = combination[attr].value
-        elif type(value) is list:
-            for i, subvalue in enumerate(value):
-                res = match_matrix_attr_pattern(subvalue)
-                if res:
-                    attr = res.groups()[0]
-                    expanded_task[key][i] = combination[attr].value
+        expand_task_for_value(value, expanded_task, key, combination)
 
     if "name" in expanded_task:
         alias_combination = {k: a.alias for k, a in combination.items()}

buildkite/bazelci_test.py

@@ -222,6 +222,7 @@ class MatrixExpansion(unittest.TestCase):
 matrix:
   bazel: ["1.2.3", "2.3.4"]
   platform: ["pf1", "pf2"]
+  exit_status: [1, 2]
 tasks:
   basic:
     name: "Basic"
@@ -234,26 +235,36 @@ class MatrixExpansion(unittest.TestCase):
     name: "Formatted w/ Bazel v{bazel} on {platform}"
     bazel: ${{ bazel }}
     platform: ${{ platform }}
+  exit_status:
+    name: "Exit Status: {exit_status}"
+    soft_fail:
+      - exit_status: ${{exit_status}}
     """
     )
 
     def test_basic_functionality(self):
-        config = self._CONFIGS
+        import copy
+        config = copy.deepcopy(self._CONFIGS)
 
         bazelci.expand_task_config(config)
         expanded_tasks = config["tasks"]
-        self.assertEqual(len(expanded_tasks), 9)
-        expanded_task_names = [task.get("name", None) for id, task in expanded_tasks.items()]
-        self.assertEqual(expanded_task_names, [
-            "Basic", # no matrix expansion
-            "Unformatted", # bazel v1.2.3
-            "Unformatted",  # bazel v2.3.4
-            None, # no name, bazel v1.2.3
-            None, # no name, bazel v2.3.4
-            "Formatted w/ Bazel v1.2.3 on pf1",
-            "Formatted w/ Bazel v1.2.3 on pf2",
-            "Formatted w/ Bazel v2.3.4 on pf1",
-            "Formatted w/ Bazel v2.3.4 on pf2",
+
+        self.assertEqual(list(expanded_tasks.values()), [
+            # no matrix expansion
+            dict(name = "Basic"),
+
+            dict(name = "Unformatted", bazel = "1.2.3"),
+            dict(name = "Unformatted", bazel = "2.3.4"),
+
+            # no name
+            dict(bazel = "1.2.3"),
+            dict(bazel = "2.3.4"),
+            dict(name = "Formatted w/ Bazel v1.2.3 on pf1", bazel = "1.2.3", platform = "pf1"),
+            dict(name = "Formatted w/ Bazel v1.2.3 on pf2", bazel = "1.2.3", platform = "pf2"),
+            dict(name = "Formatted w/ Bazel v2.3.4 on pf1", bazel = "2.3.4", platform = "pf1"),
+            dict(name = "Formatted w/ Bazel v2.3.4 on pf2", bazel = "2.3.4", platform = "pf2"),
+            dict(name ="Exit Status: 1", soft_fail = [dict(exit_status = 1)]),
+            dict(name ="Exit Status: 2", soft_fail = [dict(exit_status = 2)]),
         ])