This includes all the changes from the msd_features branch. I just

Bryan Worrell · Bryan Worrell · commit 72e53e1fd5e9 · 2015-03-28T13:54:41.000-04:00
set this up because the branch was out of date and the merge was
going to be pretty painful.
* Added unit tests for the add_related_observable() and
  add_related_indicator() methods.
diff --git a/docs/api/coa/coa.rst b/docs/api/coa/coa.rst
@@ -9,7 +9,7 @@ Classes
 -------
 
 .. autoclass:: CourseOfAction
-	:show-inheritance:
+    :show-inheritance:
 	:members:
 
 .. autoclass:: RelatedCOAs
diff --git a/stix/incident/__init__.py b/stix/incident/__init__.py
@@ -220,6 +220,86 @@ def coa_taken(self, value):
     def add_coa_taken(self, value):
         self.coa_taken.append(value)
 
+    @property
+    def related_indicators(self):
+        return self._related_indicators
+
+    @related_indicators.setter
+    def related_indicators(self, value):
+        self._set_var(RelatedIndicators, related_indicators=value)
+
+    def add_related_indicator(self, value):
+        """Adds an Related Indicator to the ``related_indicators`` list
+        property of this :class:`Incident`.
+
+        The `indicator` parameter must be an instance of
+        :class:`.RelatedIndicator` or :class:`Indicator`.
+
+        If the `indicator` parameter is ``None``, no item wil be added to the
+        ``related_indicators`` list property.
+
+        Calling this method is the same as calling ``append()`` on the
+        ``related_indicators`` property.
+
+        See Also:
+            The :class:`RelatedIndicators` documentation.
+
+        Note:
+            If the `indicator` parameter is not an instance of
+            :class:`.RelatedIndicator` an attempt will be
+            made to convert it to one.
+
+        Args:
+            indicator: An instance of :class:`Indicator` or
+                :class:`.RelatedIndicator`.
+
+        Raises:
+            ValueError: If the `indicator` parameter cannot be converted into
+                an instance of :class:`.RelatedIndicator`
+
+        """
+        self.related_indicators.append(value)
+
+    @property
+    def related_observables(self):
+        return self._related_observables
+
+    @related_observables.setter
+    def related_observables(self, value):
+        self._set_var(RelatedObservables, related_observables=value)
+
+    def add_related_observable(self, value):
+        """Adds a Related Observable to the ``related_observables`` list
+        property of this :class:`Incident`.
+
+        The `observable` parameter must be an instance of
+        :class:`.RelatedObservable` or :class:`Observable`.
+
+        If the `observable` parameter is ``None``, no item will be added to the
+        ``related_observables`` list property.
+
+        Calling this method is the same as calling ``append()`` on the
+        ``related_observables`` property.
+
+        See Also:
+            The :class:`RelatedObservables` documentation.
+
+        Note:
+            If the `observable` parameter is not an instance of
+            :class:`.RelatedObservable` an attempt will be
+            made to convert it to one.
+
+        Args:
+            observable: An instance of :class:`Observable` or
+                :class:`.RelatedObservable`.
+
+        Raises:
+            ValueError: If the `value` parameter cannot be converted into
+                an instance of :class:`.RelatedObservable`
+
+        """
+        self.related_observables.append(value)
+
     def to_obj(self, return_obj=None, ns_info=None):
         if not return_obj:
             return_obj = self._binding_class()
diff --git a/stix/incident/time.py b/stix/incident/time.py
@@ -11,16 +11,21 @@ class Time(stix.Entity):
     _binding_class = _binding.TimeType
     _namespace = "http://stix.mitre.org/Incident-1"
 
-    def __init__(self):
-        self.first_malicious_action = None
-        self.initial_compromise = None
-        self.first_data_exfiltration = None
-        self.incident_discovery = None
-        self.incident_opened = None
-        self.containment_achieved = None
-        self.restoration_achieved = None
-        self.incident_reported = None
-        self.incident_closed = None
+    def __init__(self, first_malicious_action=None, initial_compromise=None,
+                 first_data_exfiltration=None, incident_discovery=None,
+                 incident_opened=None, containment_achieved=None,
+                 restoration_achieved=None, incident_reported=None,
+                 incident_closed=None):
+
+        self.first_malicious_action = first_malicious_action
+        self.initial_compromise = initial_compromise
+        self.first_data_exfiltration = first_data_exfiltration
+        self.incident_discovery = incident_discovery
+        self.incident_opened = incident_opened
+        self.containment_achieved = containment_achieved
+        self.restoration_achieved = restoration_achieved
+        self.incident_reported = incident_reported
+        self.incident_closed = incident_closed
 
     @property
     def first_malicious_action(self):
diff --git a/stix/test/incident_test.py b/stix/test/incident_test.py
@@ -465,6 +465,49 @@ def test_description_output(self):
         xml = s.getvalue()
         self.assertTrue("A Description" in xml, "Description not exported")
 
+    def test_add_related_observable(self):
+        from cybox.core import Observable
+        from stix.common.related import RelatedObservable
+
+        i = self.klass()
+
+        self.assertEqual(0, len(i.related_observables))
+        i.add_related_observable(Observable())
+        self.assertEqual(1, len(i.related_observables))
+
+
+        related = RelatedObservable(Observable())
+        i.add_related_observable(related)
+        self.assertEqual(2, len(i.related_observables))
+
+        # Test that this fails
+        self.assertRaises(
+            ValueError,
+            i.add_related_observable,
+            "THIS SHOULD FAIL"
+        )
+
+    def test_add_related_indicator(self):
+        from stix.indicator import Indicator
+        from stix.common.related import RelatedIndicator
+
+        i = self.klass()
+
+        self.assertEqual(0, len(i.related_indicators))
+        i.add_related_indicator(Indicator())
+        self.assertEqual(1, len(i.related_indicators))
+
+        related = RelatedIndicator(Indicator())
+        i.add_related_indicator(related)
+        self.assertEqual(2, len(i.related_indicators))
+
+        # Test that this fails
+        self.assertRaises(
+            ValueError,
+            i.add_related_indicator,
+            "THIS SHOULD FAIL"
+        )
+
 
 
 if __name__ == "__main__":
