improve model validation

- add isset to check "real" attribute and not descriptor
- verify only id is set in shortform
- verify either resource or resourceId value is set, not both.

blueprint improve-validation
related-bug: #1242830

Change-Id: Ie9e3f26c5d30cd36e6013a1f0b77c8fe466cb3f7

1 files changed, 80 insertions, 10 deletions

diff --git a/pycadf/tests/test_cadf_spec.py b/pycadf/tests/test_cadf_spec.py
index 23bee22..0635cdd 100644
--- a/pycadf/tests/test_cadf_spec.py
+++ b/pycadf/tests/test_cadf_spec.py
@@ -38,6 +38,7 @@ class TestCADFSpec(testtools.TestCase):
         endp = endpoint.Endpoint(url='http://192.168.0.1',
                                  name='endpoint name',
                                  port='8080')
+        self.assertEqual(endp.is_valid(), True)
         dict_endp = endp.as_dict()
         for key in endpoint.ENDPOINT_KEYNAMES:
             self.assertIn(key, dict_endp)
@@ -47,6 +48,7 @@ class TestCADFSpec(testtools.TestCase):
                       address='192.168.0.1',
                       agent='client',
                       platform='AIX')
+        self.assertEqual(h.is_valid(), True)
         dict_host = h.as_dict()
         for key in host.HOST_KEYNAMES:
             self.assertIn(key, dict_host)
@@ -54,6 +56,7 @@ class TestCADFSpec(testtools.TestCase):
     def test_credential(self):
         cred = credential.Credential(type='auth token',
                                      token=identifier.generate_uuid())
+        self.assertEqual(cred.is_valid(), True)
         dict_cred = cred.as_dict()
         for key in credential.CRED_KEYNAMES:
             self.assertIn(key, dict_cred)
@@ -67,6 +70,7 @@ class TestCADFSpec(testtools.TestCase):
                                       city='toronto',
                                       state='ontario',
                                       regionICANN='ca')
+        self.assertEqual(geo.is_valid(), True)
 
         dict_geo = geo.as_dict()
         for key in geolocation.GEO_KEYNAMES:
@@ -76,6 +80,7 @@ class TestCADFSpec(testtools.TestCase):
         metric_val = metric.Metric(metricId=identifier.generate_uuid(),
                                    unit='b',
                                    name='bytes')
+        self.assertEqual(metric_val.is_valid(), True)
 
         dict_metric_val = metric_val.as_dict()
         for key in metric.METRIC_KEYNAMES:
@@ -87,16 +92,30 @@ class TestCADFSpec(testtools.TestCase):
             metric=metric.Metric(),
             metricId=identifier.generate_uuid(),
             calculatedBy=resource.Resource(typeURI='storage'))
+        self.assertEqual(measure_val.is_valid(), False)
 
         dict_measure_val = measure_val.as_dict()
         for key in measurement.MEASUREMENT_KEYNAMES:
             self.assertIn(key, dict_measure_val)
 
+        measure_val = measurement.Measurement(
+            result='100',
+            metric=metric.Metric(),
+            calculatedBy=resource.Resource(typeURI='storage'))
+        self.assertEqual(measure_val.is_valid(), True)
+
+        measure_val = measurement.Measurement(
+            result='100',
+            metricId=identifier.generate_uuid(),
+            calculatedBy=resource.Resource(typeURI='storage'))
+        self.assertEqual(measure_val.is_valid(), True)
+
     def test_reason(self):
         reason_val = reason.Reason(reasonType='HTTP',
                                    reasonCode='200',
                                    policyType='poltype',
                                    policyId=identifier.generate_uuid())
+        self.assertEqual(reason_val.is_valid(), True)
 
         dict_reason_val = reason_val.as_dict()
         for key in reason.REASON_KEYNAMES:
@@ -108,15 +127,29 @@ class TestCADFSpec(testtools.TestCase):
             reporter=resource.Resource(typeURI='storage'),
             reporterId=identifier.generate_uuid(),
             reporterTime=timestamp.get_utc_now())
+        self.assertEqual(step.is_valid(), False)
 
         dict_step = step.as_dict()
         for key in reporterstep.REPORTERSTEP_KEYNAMES:
             self.assertIn(key, dict_step)
 
+        step = reporterstep.Reporterstep(
+            role='modifier',
+            reporter=resource.Resource(typeURI='storage'),
+            reporterTime=timestamp.get_utc_now())
+        self.assertEqual(step.is_valid(), True)
+
+        step = reporterstep.Reporterstep(
+            role='modifier',
+            reporterId=identifier.generate_uuid(),
+            reporterTime=timestamp.get_utc_now())
+        self.assertEqual(step.is_valid(), True)
+
     def test_attachment(self):
         attach = attachment.Attachment(typeURI='attachURI',
                                        content='content',
                                        name='attachment_name')
+        self.assertEqual(attach.is_valid(), True)
 
         dict_attach = attach.as_dict()
         for key in attachment.ATTACHMENT_KEYNAMES:
@@ -137,10 +170,21 @@ class TestCADFSpec(testtools.TestCase):
                                                  content='content',
                                                  name='attachment_name'))
         res.add_address(endpoint.Endpoint(url='http://192.168.0.1'))
+
+        self.assertEqual(res.is_valid(), True)
         dict_res = res.as_dict()
         for key in resource.RESOURCE_KEYNAMES:
             self.assertIn(key, dict_res)
 
+    def test_resource_shortform(self):
+        res = resource.Resource(id='target')
+        self.assertEqual(res.is_valid(), True)
+
+        res.add_attachment(attachment.Attachment(typeURI='attachURI',
+                                                 content='content',
+                                                 name='attachment_name'))
+        self.assertEqual(res.is_valid(), False)
+
     def test_event(self):
         ev = event.Event(eventType='activity',
                          id=identifier.generate_uuid(),
@@ -151,11 +195,14 @@ class TestCADFSpec(testtools.TestCase):
                          target=resource.Resource(typeURI='storage'),
                          targetId=identifier.generate_uuid(),
                          observer=resource.Resource(id='target'),
+                         observerId=identifier.generate_uuid(),
                          outcome='success',
                          reason=reason.Reason(reasonType='HTTP',
                                               reasonCode='200'),
                          severity='high')
-        ev.add_measurement(measurement.Measurement(result='100'))
+        ev.add_measurement(
+            measurement.Measurement(result='100',
+                                    metricId=identifier.generate_uuid())),
         ev.add_tag(tag.generate_name_value_tag('name', 'val'))
         ev.add_attachment(attachment.Attachment(typeURI='attachURI',
                                                 content='content',
@@ -166,50 +213,73 @@ class TestCADFSpec(testtools.TestCase):
             reporter=resource.Resource(typeURI='service/security')))
         ev.add_reporterstep(reporterstep.Reporterstep(
             reporterId=identifier.generate_uuid()))
+        self.assertEqual(ev.is_valid(), False)
 
         dict_ev = ev.as_dict()
         for key in event.EVENT_KEYNAMES:
             self.assertIn(key, dict_ev)
 
-    def test_event_unique(self):
         ev = event.Event(eventType='activity',
+                         id=identifier.generate_uuid(),
+                         eventTime=timestamp.get_utc_now(),
                          initiator=resource.Resource(typeURI='storage'),
-                         initiatorId=identifier.generate_uuid(),
                          action='read',
                          target=resource.Resource(typeURI='storage'),
+                         observer=resource.Resource(id='target'),
+                         outcome='success')
+        self.assertEqual(ev.is_valid(), True)
+
+        ev = event.Event(eventType='activity',
+                         id=identifier.generate_uuid(),
+                         eventTime=timestamp.get_utc_now(),
+                         initiatorId=identifier.generate_uuid(),
+                         action='read',
                          targetId=identifier.generate_uuid(),
+                         observerId=identifier.generate_uuid(),
+                         outcome='success')
+        self.assertEqual(ev.is_valid(), True)
+
+        ev = event.Event(eventType='activity',
+                         id=identifier.generate_uuid(),
+                         eventTime=timestamp.get_utc_now(),
+                         initiator=resource.Resource(typeURI='storage'),
+                         action='read',
+                         targetId=identifier.generate_uuid(),
+                         observer=resource.Resource(id='target'),
+                         outcome='success')
+        self.assertEqual(ev.is_valid(), True)
+
+    def test_event_unique(self):
+        ev = event.Event(eventType='activity',
+                         initiator=resource.Resource(typeURI='storage'),
+                         action='read',
+                         target=resource.Resource(typeURI='storage'),
                          observer=resource.Resource(id='target'),
                          outcome='success')
         time.sleep(1)
         ev2 = event.Event(eventType='activity',
                           initiator=resource.Resource(typeURI='storage'),
-                          initiatorId=identifier.generate_uuid(),
                           action='read',
                           target=resource.Resource(typeURI='storage'),
-                          targetId=identifier.generate_uuid(),
                           observer=resource.Resource(id='target'),
                           outcome='success')
         self.assertNotEqual(ev.id, ev2.id)
         self.assertNotEqual(ev.eventTime, ev2.eventTime)
 
-    def test_event_resource_shortform(self):
+    def test_event_resource_shortform_not_self(self):
         self.assertRaises(ValueError,
                           lambda: event.Event(
                               eventType='activity',
                               initiator=resource.Resource(typeURI='storage'),
-                              initiatorId=identifier.generate_uuid(),
                               action='read',
                               target=resource.Resource(id='target'),
-                              targetId=identifier.generate_uuid(),
                               observer=resource.Resource(id='target'),
                               outcome='success'))
         self.assertRaises(ValueError,
                           lambda: event.Event(
                               eventType='activity',
                               initiator=resource.Resource(id='initiator'),
-                              initiatorId=identifier.generate_uuid(),
                               action='read',
                               target=resource.Resource(typeURI='storage'),
-                              targetId=identifier.generate_uuid(),
                               observer=resource.Resource(id='target'),
                               outcome='success'))