Assembly type field should honor inheritance

doozerlib/assembly.py

@@ -112,21 +112,14 @@ def _check_recursion(releases_config: Model, assembly: str):
 
 
 def assembly_type(releases_config: Model, assembly: typing.Optional[str]) -> AssemblyTypes:
-
+    # If the assembly is not defined in releases.yml, it defaults to stream
     if not assembly or not isinstance(releases_config, Model):
         return AssemblyTypes.STREAM
-
     target_assembly = releases_config.releases[assembly].assembly
-
     if not target_assembly:
-        # If the assembly is not defined in releases.yml, it defaults to stream
         return AssemblyTypes.STREAM
 
-    str_type = target_assembly['type']
-    if not str_type:
-        # Assemblies which are defined in releases.yml default to standard
-        return AssemblyTypes.STANDARD
-
+    str_type = _assembly_config_struct(releases_config, assembly, 'type', 'standard')
     for assem_type in AssemblyTypes:
         if str_type == assem_type.value:
             return assem_type
@@ -226,15 +219,24 @@ def _assembly_config_struct(releases_config: Model, assembly: typing.Optional[st
 
     _check_recursion(releases_config, assembly)
     target_assembly = releases_config.releases[assembly].assembly
-    key_struct = target_assembly.get(key, default)
+
     if target_assembly.basis.assembly:  # Does this assembly inherit from another?
         # Recursive apply ancestor assemblies
         parent_config_struct = _assembly_config_struct(releases_config, target_assembly.basis.assembly, key, default)
-        key_struct = merger(key_struct, parent_config_struct.primitive())
+        if key in target_assembly:
+            key_struct = target_assembly[key]
+
+            key_struct = merger(key_struct, parent_config_struct.primitive() if hasattr(parent_config_struct, "primitive") else parent_config_struct)
+        else:
+            key_struct = parent_config_struct
+    else:
+        key_struct = target_assembly.get(key, default)
     if isinstance(default, dict):
         return Model(dict_to_model=key_struct)
     elif isinstance(default, list):
         return ListModel(list_to_model=key_struct)
+    elif isinstance(default, (bool, int, float, str, bytes, type(None))):
+        return key_struct
     else:
         raise ValueError(f'Unknown how to derive for default type: {type(default)}')
 

tests/test_assembly.py

@@ -1,9 +1,12 @@
-import yaml
-
 from unittest import TestCase
 
-from doozerlib.assembly import assembly_rhcos_config, merger, assembly_group_config, assembly_metadata_config, assembly_basis_event
-from doozerlib.model import Model, Missing
+import yaml
+
+from doozerlib.assembly import (_assembly_config_struct, assembly_basis_event,
+                                assembly_group_config,
+                                assembly_metadata_config,
+                                assembly_rhcos_config, merger)
+from doozerlib.model import Missing, Model
 
 
 class TestAssembly(TestCase):
@@ -354,3 +357,110 @@ def test_asembly_metadata_config(self):
     def test_assembly_rhcos_config(self):
         rhcos_config = assembly_rhcos_config(self.releases_config, "ART_8")
         self.assertEqual(len(rhcos_config.dependencies.rpms), 3)
+
+    def test_assembly_config_struct(self):
+        release_configs = {
+            "releases": {
+                "child": {
+                    "assembly": {
+                        "basis": {
+                            "assembly": "parent",
+                        }
+                    }
+                },
+                "parent": {
+                    "assembly": {
+                        "type": "custom"
+                    }
+                },
+            }
+        }
+        actual = _assembly_config_struct(Model(release_configs), "child", "type", "standard")
+        self.assertEqual(actual, "custom")
+
+        release_configs = {
+            "releases": {
+                "child": {
+                    "assembly": {
+                        "basis": {
+                            "assembly": "parent",
+                        },
+                        "type": "candidate"
+                    }
+                },
+                "parent": {
+                    "assembly": {
+                        "type": "custom"
+                    }
+                },
+            }
+        }
+        actual = _assembly_config_struct(Model(release_configs), "child", "type", "standard")
+        self.assertEqual(actual, "candidate")
+
+        release_configs = {
+            "releases": {
+                "child": {
+                    "assembly": {
+                        "basis": {
+                            "assembly": "parent",
+                        },
+                    }
+                },
+                "parent": {
+                    "assembly": {
+                    }
+                },
+            }
+        }
+        actual = _assembly_config_struct(Model(release_configs), "child", "type", "standard")
+        self.assertEqual(actual, "standard")
+
+        release_configs = {
+            "releases": {
+                "child": {
+                    "assembly": {
+                        "basis": {
+                            "assembly": "parent",
+                        },
+                    }
+                },
+                "parent": {
+                    "assembly": {
+                        "type": None
+                    },
+                },
+            }
+        }
+        actual = _assembly_config_struct(Model(release_configs), "child", "type", "standard")
+        self.assertEqual(actual, None)
+
+        release_configs = {
+            "releases": {
+                "child": {
+                    "assembly": {
+                        "basis": {
+                            "assembly": "parent",
+                        },
+                        "foo": {
+                            "a": 1,
+                            "b": 2
+                        }
+                    }
+                },
+                "parent": {
+                    "assembly": {
+                        "foo": {
+                            "b": 3,
+                            "c": 4,
+                        }
+                    }
+                },
+            }
+        }
+        actual = _assembly_config_struct(Model(release_configs), "child", "foo", {})
+        self.assertEqual(actual, {
+            "a": 1,
+            "b": 2,
+            "c": 4,
+        })