Merge branch 'master' into developer-documentation

force_bdss/core/kpi_specification.py

@@ -8,4 +8,4 @@ class KPISpecification(HasStrictTraits):
     name = Identifier()
 
     #: The expected outcome of the procedure relative to this KPI.
-    objective = Enum("MINIMISE")
+    objective = Enum("", "MINIMISE")

force_bdss/core/tests/test_verifier.py

@@ -5,6 +5,7 @@ from force_bdss.core.input_slot_info import InputSlotInfo
 from force_bdss.core.output_slot_info import OutputSlotInfo
 from force_bdss.core.verifier import verify_workflow
 from force_bdss.core.workflow import Workflow
+from force_bdss.core.kpi_specification import KPISpecification
 from force_bdss.tests.dummy_classes.extension_plugin import \
     DummyExtensionPlugin
 
@@ -33,7 +34,7 @@ class TestVerifier(unittest.TestCase):
         self.assertEqual(errors[0].subject, wf.mco)
         self.assertIn("no defined parameters", errors[0].error)
 
-    def test_parameters_empty_names(self):
+    def test_empty_parameter_options(self):
         wf = self.workflow
         mco_factory = self.plugin.mco_factories[0]
         wf.mco = mco_factory.create_model()
@@ -43,9 +44,39 @@ class TestVerifier(unittest.TestCase):
         errors = verify_workflow(wf)
         self.assertEqual(len(errors), 3)
         self.assertEqual(errors[0].subject, wf.mco.parameters[0])
-        self.assertIn("empty name", errors[0].error)
+        self.assertIn("Empty Name", errors[0].error)
         self.assertEqual(errors[1].subject, wf.mco.parameters[0])
-        self.assertIn("empty type", errors[1].error)
+        self.assertIn("Empty Type", errors[1].error)
+
+    def test_empty_kpi_options(self):
+        wf = self.workflow
+        mco_factory = self.plugin.mco_factories[0]
+        wf.mco = mco_factory.create_model()
+        kpi = KPISpecification(name='', objective='')
+        wf.mco.kpis.append(kpi)
+
+        errors = verify_workflow(wf)
+
+        self.assertEqual(len(errors), 4)
+        self.assertEqual(errors[1].subject, wf.mco.kpis[0])
+        self.assertIn("Empty Name", errors[1].error)
+        self.assertIn("Empty Objective", errors[2].error)
+
+    def test_empty_execution_layer(self):
+        wf = self.workflow
+        mco_factory = self.plugin.mco_factories[0]
+        wf.mco = mco_factory.create_model()
+        parameter_factory = mco_factory.parameter_factories()[0]
+        wf.mco.parameters.append(parameter_factory.create_model())
+        wf.mco.parameters[0].name = "name"
+        wf.mco.parameters[0].type = "type"
+
+        layer = ExecutionLayer()
+        wf.execution_layers.append(layer)
+        errors = verify_workflow(wf)
+        self.assertEqual(len(errors), 1)
+        self.assertEqual(errors[0].subject, wf.execution_layers[0])
+        self.assertIn("Layer 0 has no data sources", errors[0].error)
 
     def test_data_sources(self):
         wf = self.workflow

force_bdss/core/verifier.py

@@ -15,10 +15,8 @@ def verify_workflow(workflow):
 
     """
     result = []
-
     result.extend(_check_mco(workflow))
     result.extend(_check_execution_layers(workflow))
-
     return result
 
 
@@ -38,13 +36,30 @@ def _check_mco(workflow):
         errors.append(VerifierError(subject=mco,
                                     error="MCO has no defined parameters"))
 
-    for param in mco.parameters:
-        if len(param.name.strip()) == 0:
+    for idx, param in enumerate(mco.parameters):
+        factory_name = param.factory.name
+        if param.name == '':
             errors.append(VerifierError(subject=param,
-                                        error="Parameter has empty name"))
+                                        error="Empty Name - Parameter {} "
+                                              "({})".format(idx,
+                                                            factory_name)))
+
         if len(param.type.strip()) == 0:
             errors.append(VerifierError(subject=param,
-                                        error="Parameter has empty type"))
+                                        error="Empty Type - Parameter {} "
+                                              "({})".format(idx,
+                                                            factory_name)))
+
+    for idx, kpi in enumerate(mco.kpis):
+        if kpi.name == '':
+            errors.append(VerifierError(subject=kpi,
+                                        error="Empty Name - KPI {}".format(
+                                            idx)))
+        if kpi.objective == '':
+            errors.append(VerifierError(subject=kpi,
+                                        error="Empty Objective - "
+                                              "KPI {}".format(idx)))
+
     return errors
 
 
@@ -62,18 +77,19 @@ def _check_execution_layers(workflow):
 
         return errors
 
-    for layer in layers:
+    for idx, layer in enumerate(layers):
         if len(layer.data_sources) == 0:
             errors.append(VerifierError(subject=layer,
-                                        error="Layer has no data sources"))
+                                        error="Layer {} has no "
+                                              "data sources".format(idx)))
 
         for ds in layer.data_sources:
-            errors.extend(_check_data_source(ds))
+            errors.extend(_check_data_source(ds, idx))
 
     return errors
 
 
-def _check_data_source(data_source_model):
+def _check_data_source(data_source_model, layer_number):
     errors = []
 
     factory = data_source_model.factory
@@ -100,23 +116,31 @@ def _check_data_source(data_source_model):
     if len(input_slots) != len(data_source_model.input_slot_info):
         errors.append(VerifierError(
             subject=data_source_model,
-            error="Missing input slot name assignment"))
+            error="Missing input slot name assignment "
+                  "in layer {}".format(layer_number)))
 
     for idx, info in enumerate(data_source_model.input_slot_info):
-        if len(info.name.strip()) == 0:
+        if info.name == '':
             errors.append(VerifierError(
                 subject=data_source_model,
-                error="Undefined name for input parameter {}".format(idx)))
+                error="Undefined name for input "
+                      "parameter {} from {} in layer {}".format(idx,
+                                                                factory.name,
+                                                                layer_number)))
 
     if len(output_slots) != len(data_source_model.output_slot_info):
         errors.append(VerifierError(
             subject=data_source_model,
-            error="Missing output slot name assignment"))
+            error="Missing output slot name assignment "
+                  "in layer {}".format(layer_number)))
 
     for idx, info in enumerate(data_source_model.output_slot_info):
-        if len(info.name.strip()) == 0:
+        if info.name == '':
             errors.append(VerifierError(
                 subject=data_source_model,
-                error="Undefined name for output parameter {}".format(idx)))
+                error="Undefined name for output "
+                      "parameter {} from {} in layer {}".format(idx,
+                                                                factory.name,
+                                                                layer_number)))
 
     return errors

force_bdss/tests/test_core_mco_driver.py

@@ -233,6 +233,6 @@ class TestCoreMCODriver(unittest.TestCase):
                 ('force_bdss.core_mco_driver', 'ERROR',
                  'MCO has no defined parameters'),
                 ('force_bdss.core_mco_driver', 'ERROR',
-                 'Missing input slot name assignment'),
+                 'Missing input slot name assignment in layer 0'),
                 ('force_bdss.core_mco_driver', 'ERROR',
-                 'Missing output slot name assignment'))
+                 'Missing output slot name assignment in layer 0'))