morphloader: Require systems have at least one stratum

It doesn't currently make sense to build a system which contains no
strata. We may later add other fields, such as initramfs to contribute
to the system's artifact, but until then it's another bug to trip over.

This uses collections.Sequence for checking the type of the systems entry
in the morphology as a style choice, though it allows more flexibility
if the types in the parsed morphology change.

2 files changed, 140 insertions, 34 deletions

diff --git a/morphlib/morphloader.py b/morphlib/morphloader.py
index 9ac248da..fdc3b62f 100644
--- a/morphlib/morphloader.py
+++ b/morphlib/morphloader.py
@@ -16,6 +16,7 @@
 # =*= License: GPL-2 =*=
 
 
+import collections
 import logging
 import yaml
 
@@ -102,6 +103,16 @@ class DuplicateChunkError(morphlib.Error):
                   'in stratum %(stratum_name)s' % locals())
 
 
+class SystemStrataNotListError(morphlib.Error):
+
+    def __init__(self, system_name, strata_type):
+        self.system_name = system_name
+        self.strata_type = strata_type
+        typename = strata_type.__name__
+        morphlib.Error.__init__(
+            self, 'System %(system_name)s has the wrong type for its strata: '\
+                  '%(typename)s, expected list' % locals())
+
 class DuplicateStratumError(morphlib.Error):
 
     def __init__(self, system_name, stratum_name):
@@ -112,6 +123,23 @@ class DuplicateStratumError(morphlib.Error):
                   'in system %(system_name)s' % locals())
 
 
+class SystemStratumSpecsNotMappingError(morphlib.Error):
+
+    def __init__(self, system_name, strata):
+        self.system_name = system_name
+        self.strata = strata
+        morphlib.Error.__init__(
+            self, 'System %(system_name)s has stratum specs '\
+                  'that are not mappings.' % locals())
+
+
+class EmptySystemError(morphlib.Error):
+
+    def __init__(self, system_name):
+        morphlib.Error.__init__(
+            self, 'System %(system_name)s has no strata.' % locals())
+
+
 class MorphologyLoader(object):
 
     '''Load morphologies from disk, or save them back to disk.'''
@@ -126,6 +154,7 @@ class MorphologyLoader(object):
         'system': [
             'name',
             'arch',
+            'strata',
         ],
         'cluster': [
           'name',
@@ -166,7 +195,6 @@ class MorphologyLoader(object):
             'build-depends': [],
         },
         'system': {
-            'strata': [],
             'description': '',
             'arch': None,
             'configuration-extensions': [],
@@ -270,9 +298,23 @@ class MorphologyLoader(object):
             assert kind == 'cluster'
 
     def _validate_system(self, morph):
+        # A system must contain at least one stratum
+        strata = morph['strata']
+        if (not isinstance(strata, collections.Iterable)
+            or isinstance(strata, collections.Mapping)):
+
+            raise SystemStrataNotListError(morph['name'],
+                                           type(strata))
+
+        if not strata:
+            raise EmptySystemError(morph['name'])
+
+        if not all(isinstance(o, collections.Mapping) for o in strata):
+            raise SystemStratumSpecsNotMappingError(morph['name'], strata)
+
         # All stratum names should be unique within a system.
         names = set()
-        for spec in morph['strata']:
+        for spec in strata:
             name = spec.get('alias', spec['morph'])
             if name in names:
                raise DuplicateStratumError(morph['name'], name)
diff --git a/morphlib/morphloader_tests.py b/morphlib/morphloader_tests.py
index b6ebff6a..8b87467a 100644
--- a/morphlib/morphloader_tests.py
+++ b/morphlib/morphloader_tests.py
@@ -99,6 +99,9 @@ build-system: dummy
             'kind': 'system',
             'name': 'foo',
             'arch': 'x86_64',
+            'strata': [
+                {'morph': 'bar'},
+            ],
             'system-kind': 'foo',
         })
         self.assertRaises(
@@ -109,6 +112,9 @@ build-system: dummy
             'kind': 'system',
             'name': 'foo',
             'arch': 'x86_64',
+            'strata': [
+                {'morph': 'bar'},
+            ],
             'disk-size': 'over 9000',
         })
         self.assertRaises(
@@ -122,12 +128,14 @@ build-system: dummy
             morphlib.morphloader.MissingFieldError, self.loader.validate, m)
 
     def test_fails_to_validate_system_with_invalid_field(self):
-        m = morphlib.morph3.Morphology({
-            'kind': 'system',
-            'name': 'name',
-            'arch': 'x86_64',
-            'invalid': 'field',
-        })
+        m = morphlib.morph3.Morphology(
+            kind="system",
+            name="foo",
+            arch="blah",
+            strata=[
+                {'morph': 'bar'},
+            ],
+            invalid='field')
         self.assertRaises(
             morphlib.morphloader.InvalidFieldError, self.loader.validate, m)
 
@@ -183,24 +191,24 @@ build-system: dummy
 
     def test_validate_requires_a_valid_architecture(self):
         m = morphlib.morph3.Morphology(
-            {
-                "kind": "system",
-                "name": "foo",
-                "arch": "blah",
-                "strata": [],
-            })
+            kind="system",
+            name="foo",
+            arch="blah",
+            strata=[
+                {'morph': 'bar'},
+            ])
         self.assertRaises(
             morphlib.morphloader.UnknownArchitectureError,
             self.loader.validate, m)
 
     def test_validate_normalises_architecture_armv7_to_armv7l(self):
         m = morphlib.morph3.Morphology(
-            {
-                "kind": "system",
-                "name": "foo",
-                "arch": "armv7",
-                "strata": [],
-            })
+            kind="system",
+            name="foo",
+            arch="armv7",
+            strata=[
+                {'morph': 'bar'},
+            ])
         self.loader.validate(m)
         self.assertEqual(m['arch'], 'armv7l')
 
@@ -276,6 +284,50 @@ build-system: dummy
             morphlib.morphloader.EmptyStratumError,
             self.loader.validate, m)
 
+    def test_validate_requires_strata_in_system(self):
+        m = morphlib.morph3.Morphology(
+            name='system',
+            kind='system',
+            arch='testarch')
+        self.assertRaises(
+            morphlib.morphloader.MissingFieldError,
+            self.loader.validate, m)
+
+    def test_validate_requires_list_of_strata_in_system(self):
+        for v in (None, {}):
+            m = morphlib.morph3.Morphology(
+                name='system',
+                kind='system',
+                arch='testarch',
+                strata=v)
+            with self.assertRaises(
+                morphlib.morphloader.SystemStrataNotListError) as cm:
+
+                self.loader.validate(m)
+            self.assertEqual(cm.exception.strata_type, type(v))
+
+    def test_validate_requires_non_empty_strata_in_system(self):
+        m = morphlib.morph3.Morphology(
+            name='system',
+            kind='system',
+            arch='testarch',
+            strata=[])
+        self.assertRaises(
+            morphlib.morphloader.EmptySystemError,
+            self.loader.validate, m)
+
+    def test_validate_requires_stratum_specs_in_system(self):
+        m = morphlib.morph3.Morphology(
+            name='system',
+            kind='system',
+            arch='testarch',
+            strata=["foo"])
+        with self.assertRaises(
+            morphlib.morphloader.SystemStratumSpecsNotMappingError) as cm:
+
+            self.loader.validate(m)
+        self.assertEqual(cm.exception.strata, ["foo"])
+
     def test_loads_yaml_from_string(self):
         string = '''\
 name: foo
@@ -463,11 +515,13 @@ name: foo
             test_dict)
 
     def test_sets_defaults_for_system(self):
-        m = morphlib.morph3.Morphology({
-            'kind': 'system',
-            'name': 'foo',
-            'arch': 'x86_64',
-        })
+        m = morphlib.morph3.Morphology(
+            kind='system',
+            name='foo',
+            arch='testarch',
+            strata=[
+                {'morph': 'bar'},
+            ])
         self.loader.set_defaults(m)
         self.loader.validate(m)
         self.assertEqual(
@@ -476,25 +530,35 @@ name: foo
                 'kind': 'system',
                 'name': 'foo',
                 'description': '',
-                'arch': 'x86_64',
-                'strata': [],
+                'arch': 'testarch',
+                'strata': [
+                    {'morph': 'bar'},
+                ],
                 'configuration-extensions': [],
             })
 
     def test_unsets_defaults_for_system(self):
-        m = morphlib.morph3.Morphology({
-            'kind': 'system',
-            'name': 'foo',
-            'arch': 'x86_64',
-            'strata': [],
-        })
+        m = morphlib.morph3.Morphology(
+            {
+                'description': '',
+                'kind': 'system',
+                'name': 'foo',
+                'arch': 'testarch',
+                'strata': [
+                    {'morph': 'bar'},
+                ],
+                'configuration-extensions': [],
+            })
         self.loader.unset_defaults(m)
         self.assertEqual(
             dict(m),
             {
                 'kind': 'system',
                 'name': 'foo',
-                'arch': 'x86_64',
+                'arch': 'testarch',
+                'strata': [
+                    {'morph': 'bar'},
+                ],
             })
 
     def test_sets_defaults_for_cluster(self):