localstack-core 4.3.1.dev6__py3-none-any.whl → 4.3.1.dev28__py3-none-any.whl

localstack/services/cloudformation/engine/v2/change_set_model.py

@@ -7,6 +7,7 @@ from typing import Any, Final, Generator, Optional, Union, cast
 
 from typing_extensions import TypeVar
 
+from localstack.aws.api.cloudformation import ChangeAction
 from localstack.utils.strings import camel_to_snake_case
 
 T = TypeVar("T")
@@ -66,6 +67,15 @@ class ChangeType(enum.Enum):
     def __str__(self):
         return self.value
 
+    def to_action(self) -> ChangeAction | None:
+        match self:
+            case self.CREATED:
+                return ChangeAction.Add
+            case self.MODIFIED:
+                return ChangeAction.Modify
+            case self.REMOVED:
+                return ChangeAction.Remove
+
     def for_child(self, child_change_type: ChangeType) -> ChangeType:
         if child_change_type == self:
             return self
@@ -117,6 +127,7 @@ class NodeTemplate(ChangeSetNode):
     parameters: Final[NodeParameters]
     conditions: Final[NodeConditions]
     resources: Final[NodeResources]
+    outputs: Final[NodeOutputs]
 
     def __init__(
         self,
@@ -126,12 +137,14 @@ class NodeTemplate(ChangeSetNode):
         parameters: NodeParameters,
         conditions: NodeConditions,
         resources: NodeResources,
+        outputs: NodeOutputs,
     ):
         super().__init__(scope=scope, change_type=change_type)
         self.mappings = mappings
         self.parameters = parameters
         self.conditions = conditions
         self.resources = resources
+        self.outputs = outputs
 
 
 class NodeDivergence(ChangeSetNode):
@@ -189,6 +202,36 @@ class NodeMappings(ChangeSetNode):
         self.mappings = mappings
 
 
+class NodeOutput(ChangeSetNode):
+    name: Final[str]
+    value: Final[ChangeSetEntity]
+    export: Final[Optional[ChangeSetEntity]]
+    condition_reference: Final[Optional[TerminalValue]]
+
+    def __init__(
+        self,
+        scope: Scope,
+        change_type: ChangeType,
+        name: str,
+        value: ChangeSetEntity,
+        export: Optional[ChangeSetEntity],
+        conditional_reference: Optional[TerminalValue],
+    ):
+        super().__init__(scope=scope, change_type=change_type)
+        self.name = name
+        self.value = value
+        self.export = export
+        self.condition_reference = conditional_reference
+
+
+class NodeOutputs(ChangeSetNode):
+    outputs: Final[list[NodeOutput]]
+
+    def __init__(self, scope: Scope, change_type: ChangeType, outputs: list[NodeOutput]):
+        super().__init__(scope=scope, change_type=change_type)
+        self.outputs = outputs
+
+
 class NodeCondition(ChangeSetNode):
     name: Final[str]
     body: Final[ChangeSetEntity]
@@ -218,7 +261,7 @@ class NodeResources(ChangeSetNode):
 class NodeResource(ChangeSetNode):
     name: Final[str]
     type_: Final[ChangeSetTerminal]
-    condition_reference: Final[TerminalValue]
+    condition_reference: Final[Optional[TerminalValue]]
     properties: Final[NodeProperties]
 
     def __init__(
@@ -325,6 +368,9 @@ MappingsKey: Final[str] = "Mappings"
 ResourcesKey: Final[str] = "Resources"
 PropertiesKey: Final[str] = "Properties"
 ParametersKey: Final[str] = "Parameters"
+ValueKey: Final[str] = "Value"
+ExportKey: Final[str] = "Export"
+OutputsKey: Final[str] = "Outputs"
 # TODO: expand intrinsic functions set.
 RefKey: Final[str] = "Ref"
 FnIf: Final[str] = "Fn::If"
@@ -567,17 +613,9 @@ class ChangeSetModel:
             binding_scope, (before_value, after_value) = self._safe_access_in(
                 scope, binding_name, before_object, after_object
             )
-            if self._is_intrinsic_function_name(function_name=binding_name):
-                value = self._visit_intrinsic_function(
-                    scope=binding_scope,
-                    intrinsic_function=binding_name,
-                    before_arguments=before_value,
-                    after_arguments=after_value,
-                )
-            else:
-                value = self._visit_value(
-                    scope=binding_scope, before_value=before_value, after_value=after_value
-                )
+            value = self._visit_value(
+                scope=binding_scope, before_value=before_value, after_value=after_value
+            )
             bindings[binding_name] = value
             change_type = change_type.for_child(value.change_type)
         node_object = NodeObject(scope=scope, change_type=change_type, bindings=bindings)
@@ -601,8 +639,11 @@ class ChangeSetModel:
         value = self._visited_scopes.get(scope)
         if isinstance(value, ChangeSetEntity):
             return value
+
+        before_type_name = self._type_name_of(before_value)
+        after_type_name = self._type_name_of(after_value)
         unset = object()
-        if type(before_value) is type(after_value):
+        if before_type_name == after_type_name:
             dominant_value = before_value
         elif self._is_created(before=before_value, after=after_value):
             dominant_value = after_value
@@ -611,6 +652,7 @@ class ChangeSetModel:
         else:
             dominant_value = unset
         if dominant_value is not unset:
+            dominant_type_name = self._type_name_of(dominant_value)
             if self._is_terminal(value=dominant_value):
                 value = self._visit_terminal_value(
                     scope=scope, before_value=before_value, after_value=after_value
@@ -623,6 +665,16 @@ class ChangeSetModel:
                 value = self._visit_array(
                     scope=scope, before_array=before_value, after_array=after_value
                 )
+            elif self._is_intrinsic_function_name(dominant_type_name):
+                intrinsic_function_scope, (before_arguments, after_arguments) = (
+                    self._safe_access_in(scope, dominant_type_name, before_value, after_value)
+                )
+                value = self._visit_intrinsic_function(
+                    scope=scope,
+                    intrinsic_function=dominant_type_name,
+                    before_arguments=before_arguments,
+                    after_arguments=after_arguments,
+                )
             else:
                 raise RuntimeError(f"Unsupported type {type(dominant_value)}")
         # Case: type divergence.
@@ -644,24 +696,24 @@ class ChangeSetModel:
         if isinstance(node_property, NodeProperty):
             return node_property
 
+        value = self._visit_value(
+            scope=scope, before_value=before_property, after_value=after_property
+        )
         if self._is_created(before=before_property, after=after_property):
             node_property = NodeProperty(
                 scope=scope,
                 change_type=ChangeType.CREATED,
                 name=property_name,
-                value=TerminalValueCreated(scope=scope, value=after_property),
+                value=value,
             )
         elif self._is_removed(before=before_property, after=after_property):
             node_property = NodeProperty(
                 scope=scope,
                 change_type=ChangeType.REMOVED,
                 name=property_name,
-                value=TerminalValueRemoved(scope=scope, value=before_property),
+                value=value,
             )
         else:
-            value = self._visit_value(
-                scope=scope, before_value=before_property, after_value=after_property
-            )
             node_property = NodeProperty(
                 scope=scope, change_type=value.change_type, name=property_name, value=value
             )
@@ -715,14 +767,17 @@ class ChangeSetModel:
             change_type = ChangeType.UNCHANGED
 
         # TODO: investigate behaviour with type changes, for now this is filler code.
-        _, type_str = self._safe_access_in(scope, TypeKey, before_resource)
+        _, type_str = self._safe_access_in(scope, TypeKey, after_resource)
 
+        condition_reference = None
         scope_condition, (before_condition, after_condition) = self._safe_access_in(
             scope, ConditionKey, before_resource, after_resource
         )
-        condition_reference = self._visit_terminal_value(
-            scope_condition, before_condition, after_condition
-        )
+        # TODO: condition references should be resolved for the condition's change_type?
+        if before_condition or after_condition:
+            condition_reference = self._visit_terminal_value(
+                scope_condition, before_condition, after_condition
+            )
 
         scope_properties, (before_properties, after_properties) = self._safe_access_in(
             scope, PropertiesKey, before_resource, after_resource
@@ -887,18 +942,9 @@ class ChangeSetModel:
         node_condition = self._visited_scopes.get(scope)
         if isinstance(node_condition, NodeCondition):
             return node_condition
-
-        # TODO: is schema validation/check necessary or can we trust the input at this point?
-        function_names: list[str] = self._safe_keys_of(before_condition, after_condition)
-        if len(function_names) == 1:
-            body = self._visit_object(
-                scope=scope, before_object=before_condition, after_object=after_condition
-            )
-        else:
-            body = self._visit_divergence(
-                scope=scope, before_value=before_condition, after_value=after_condition
-            )
-
+        body = self._visit_value(
+            scope=scope, before_value=before_condition, after_value=after_condition
+        )
         node_condition = NodeCondition(
             scope=scope, change_type=body.change_type, name=condition_name, body=body
         )
@@ -932,6 +978,64 @@ class ChangeSetModel:
         self._visited_scopes[scope] = node_conditions
         return node_conditions
 
+    def _visit_output(
+        self, scope: Scope, name: str, before_output: Maybe[dict], after_output: Maybe[dict]
+    ) -> NodeOutput:
+        change_type = ChangeType.UNCHANGED
+        scope_value, (before_value, after_value) = self._safe_access_in(
+            scope, ValueKey, before_output, after_output
+        )
+        value = self._visit_value(scope_value, before_value, after_value)
+        change_type = change_type.for_child(value.change_type)
+
+        export: Optional[ChangeSetEntity] = None
+        scope_export, (before_export, after_export) = self._safe_access_in(
+            scope, ExportKey, before_output, after_output
+        )
+        if before_export or after_export:
+            export = self._visit_value(scope_export, before_export, after_export)
+            change_type = change_type.for_child(export.change_type)
+
+        # TODO: condition references should be resolved for the condition's change_type?
+        condition_reference: Optional[TerminalValue] = None
+        scope_condition, (before_condition, after_condition) = self._safe_access_in(
+            scope, ConditionKey, before_output, after_output
+        )
+        if before_condition or after_condition:
+            condition_reference = self._visit_terminal_value(
+                scope_condition, before_condition, after_condition
+            )
+            change_type = change_type.for_child(condition_reference.change_type)
+
+        return NodeOutput(
+            scope=scope,
+            change_type=change_type,
+            name=name,
+            value=value,
+            export=export,
+            conditional_reference=condition_reference,
+        )
+
+    def _visit_outputs(
+        self, scope: Scope, before_outputs: Maybe[dict], after_outputs: Maybe[dict]
+    ) -> NodeOutputs:
+        change_type = ChangeType.UNCHANGED
+        outputs: list[NodeOutput] = list()
+        output_names: list[str] = self._safe_keys_of(before_outputs, after_outputs)
+        for output_name in output_names:
+            scope_output, (before_output, after_output) = self._safe_access_in(
+                scope, output_name, before_outputs, after_outputs
+            )
+            output = self._visit_output(
+                scope=scope_output,
+                name=output_name,
+                before_output=before_output,
+                after_output=after_output,
+            )
+            outputs.append(output)
+            change_type = change_type.for_child(output.change_type)
+        return NodeOutputs(scope=scope, change_type=change_type, outputs=outputs)
+
     def _model(self, before_template: Maybe[dict], after_template: Maybe[dict]) -> NodeTemplate:
         root_scope = Scope()
         # TODO: visit other child types
@@ -970,6 +1074,13 @@ class ChangeSetModel:
             after_resources=after_resources,
         )
 
+        outputs_scope, (before_outputs, after_outputs) = self._safe_access_in(
+            root_scope, OutputsKey, before_template, after_template
+        )
+        outputs = self._visit_outputs(
+            scope=outputs_scope, before_outputs=before_outputs, after_outputs=after_outputs
+        )
+
         # TODO: compute the change_type of the template properly.
         return NodeTemplate(
             scope=root_scope,
@@ -978,6 +1089,7 @@ class ChangeSetModel:
             parameters=parameters,
             conditions=conditions,
             resources=resources,
+            outputs=outputs,
         )
 
     def _retrieve_condition_if_exists(self, condition_name: str) -> Optional[NodeCondition]:
@@ -1090,13 +1202,30 @@ class ChangeSetModel:
                 break
         return parent_change_type
 
+    @staticmethod
+    def _name_if_intrinsic_function(value: Maybe[Any]) -> Optional[str]:
+        if isinstance(value, dict):
+            keys = ChangeSetModel._safe_keys_of(value)
+            if len(keys) == 1:
+                key_name = keys[0]
+                if ChangeSetModel._is_intrinsic_function_name(key_name):
+                    return key_name
+        return None
+
+    @staticmethod
+    def _type_name_of(value: Maybe[Any]) -> str:
+        maybe_intrinsic_function_name = ChangeSetModel._name_if_intrinsic_function(value)
+        if maybe_intrinsic_function_name is not None:
+            return maybe_intrinsic_function_name
+        return type(value).__name__
+
     @staticmethod
     def _is_terminal(value: Any) -> bool:
         return type(value) in {int, float, bool, str, None, NothingType}
 
     @staticmethod
     def _is_object(value: Any) -> bool:
-        return isinstance(value, dict)
+        return isinstance(value, dict) and ChangeSetModel._name_if_intrinsic_function(value) is None
 
     @staticmethod
     def _is_array(value: Any) -> bool:

localstack/services/cloudformation/engine/v2/change_set_model_describer.py

@@ -7,12 +7,16 @@ import localstack.aws.api.cloudformation as cfn_api
 from localstack.services.cloudformation.engine.v2.change_set_model import (
     ChangeSetEntity,
     ChangeType,
+    ConditionKey,
+    ExportKey,
     NodeArray,
     NodeCondition,
     NodeDivergence,
     NodeIntrinsicFunction,
     NodeMapping,
     NodeObject,
+    NodeOutput,
+    NodeOutputs,
     NodeParameter,
     NodeProperties,
     NodeProperty,
@@ -26,6 +30,7 @@ from localstack.services.cloudformation.engine.v2.change_set_model import (
     TerminalValueModified,
     TerminalValueRemoved,
     TerminalValueUnchanged,
+    ValueKey,
 )
 from localstack.services.cloudformation.engine.v2.change_set_model_visitor import (
     ChangeSetModelVisitor,
@@ -47,14 +52,20 @@ class ChangeSetModelDescriber(ChangeSetModelVisitor):
     _node_template: Final[NodeTemplate]
     _changes: Final[cfn_api.Changes]
     _describe_unit_cache: dict[Scope, DescribeUnit]
+    _include_property_values: Final[cfn_api.IncludePropertyValues | None]
 
-    def __init__(self, node_template: NodeTemplate):
+    def __init__(
+        self,
+        node_template: NodeTemplate,
+        include_property_values: cfn_api.IncludePropertyValues | None = None,
+    ):
         self._node_template = node_template
         self._changes = list()
         self._describe_unit_cache = dict()
-        self.visit(self._node_template)
+        self._include_property_values = include_property_values
 
     def get_changes(self) -> cfn_api.Changes:
+        self.visit(self._node_template)
         return self._changes
 
     @staticmethod
@@ -112,12 +123,13 @@ class ChangeSetModelDescriber(ChangeSetModelVisitor):
             return parameter_unit
 
         # TODO: check for KNOWN AFTER APPLY values for logical ids coming from intrinsic functions as arguments.
-        #   node_resource = self._get_node_resource_for(
-        #       resource_name=logica_id, node_template=self._node_template
-        #   )
-        limitation_str = "Cannot yet compute Ref values for Resources"
-        resource_unit = DescribeUnit(before_context=limitation_str, after_context=limitation_str)
-        return resource_unit
+        node_resource = self._get_node_resource_for(
+            resource_name=logica_id, node_template=self._node_template
+        )
+        resource_unit = self.visit(node_resource)
+        before_context = resource_unit.before_context
+        after_context = resource_unit.after_context
+        return DescribeUnit(before_context=before_context, after_context=after_context)
 
     def _resolve_mapping(self, map_name: str, top_level_key: str, second_level_key) -> DescribeUnit:
         # TODO: add support for nested intrinsic functions, and KNOWN AFTER APPLY logical ids.
@@ -210,29 +222,37 @@ class ChangeSetModelDescriber(ChangeSetModelVisitor):
         arguments_unit = self.visit(node_intrinsic_function.arguments)
         # TODO: validate the return value according to the spec.
         before_argument_list = arguments_unit.before_context
-        before_logical_name_of_resource = before_argument_list[0]
-        before_attribute_name = before_argument_list[1]
-        before_node_resource = self._get_node_resource_for(
-            resource_name=before_logical_name_of_resource, node_template=self._node_template
-        )
-        node_property: TerminalValue = self._get_node_property_for(
-            property_name=before_attribute_name, node_resource=before_node_resource
-        )
+        after_argument_list = arguments_unit.after_context
+
+        before_context = None
+        if before_argument_list:
+            before_logical_name_of_resource = before_argument_list[0]
+            before_attribute_name = before_argument_list[1]
+            before_node_resource = self._get_node_resource_for(
+                resource_name=before_logical_name_of_resource, node_template=self._node_template
+            )
+            before_node_property = self._get_node_property_for(
+                property_name=before_attribute_name, node_resource=before_node_resource
+            )
+            before_property_unit = self.visit(before_node_property)
+            before_context = before_property_unit.before_context
 
-        before_context = node_property.value.value
-        if node_property.change_type != ChangeType.UNCHANGED:
+        after_context = None
+        if after_argument_list:
             after_context = CHANGESET_KNOWN_AFTER_APPLY
-        else:
-            after_context = node_property.value.value
+            # TODO: the following is the logic to resolve the attribute in the `after` template
+            #  this should be moved to the new base class and then be masked in this describer.
+            # after_logical_name_of_resource = after_argument_list[0]
+            # after_attribute_name = after_argument_list[1]
+            # after_node_resource = self._get_node_resource_for(
+            #     resource_name=after_logical_name_of_resource, node_template=self._node_template
+            # )
+            # after_node_property = self._get_node_property_for(
+            #     property_name=after_attribute_name, node_resource=after_node_resource
+            # )
+            # after_property_unit = self.visit(after_node_property)
+            # after_context = after_property_unit.after_context
 
-        match node_intrinsic_function.change_type:
-            case ChangeType.MODIFIED:
-                return DescribeUnit(before_context=before_context, after_context=after_context)
-            case ChangeType.CREATED:
-                return DescribeUnit(after_context=after_context)
-            case ChangeType.REMOVED:
-                return DescribeUnit(before_context=before_context)
-        # Unchanged
         return DescribeUnit(before_context=before_context, after_context=after_context)
 
     def visit_node_intrinsic_function_fn_equals(
@@ -342,12 +362,16 @@ class ChangeSetModelDescriber(ChangeSetModelVisitor):
 
         # TODO: add tests with created and deleted parameters and verify this logic holds.
         before_logical_id = arguments_unit.before_context
-        before_unit = self._resolve_reference(logica_id=before_logical_id)
-        before_context = before_unit.before_context
+        before_context = None
+        if before_logical_id is not None:
+            before_unit = self._resolve_reference(logica_id=before_logical_id)
+            before_context = before_unit.before_context
 
         after_logical_id = arguments_unit.after_context
-        after_unit = self._resolve_reference(logica_id=after_logical_id)
-        after_context = after_unit.after_context
+        after_context = None
+        if after_logical_id is not None:
+            after_unit = self._resolve_reference(logica_id=after_logical_id)
+            after_context = after_unit.after_context
 
         return DescribeUnit(before_context=before_context, after_context=after_context)
 
@@ -406,21 +430,71 @@ class ChangeSetModelDescriber(ChangeSetModelVisitor):
         )
         return DescribeUnit(before_context=before_context, after_context=after_context)
 
+    def visit_node_output(self, node_output: NodeOutput) -> DescribeUnit:
+        # This logic is not required for Describe operations,
+        # and should be ported a new base for this class type.
+        change_type = node_output.change_type
+        value_unit = self.visit(node_output.value)
+
+        condition_unit = None
+        if node_output.condition_reference is not None:
+            condition_unit = self._resolve_resource_condition_reference(
+                node_output.condition_reference
+            )
+            condition_before = condition_unit.before_context
+            condition_after = condition_unit.after_context
+            if not condition_before and condition_after:
+                change_type = ChangeType.CREATED
+            elif condition_before and not condition_after:
+                change_type = ChangeType.REMOVED
+
+        export_unit = None
+        if node_output.export is not None:
+            export_unit = self.visit(node_output.export)
+
+        before_context = None
+        after_context = None
+        if change_type != ChangeType.REMOVED:
+            after_context = {"Name": node_output.name, ValueKey: value_unit.after_context}
+            if export_unit:
+                after_context[ExportKey] = export_unit.after_context
+            if condition_unit:
+                after_context[ConditionKey] = condition_unit.after_context
+        if change_type != ChangeType.CREATED:
+            before_context = {"Name": node_output.name, ValueKey: value_unit.before_context}
+            if export_unit:
+                before_context[ExportKey] = export_unit.before_context
+            if condition_unit:
+                before_context[ConditionKey] = condition_unit.before_context
+        return DescribeUnit(before_context=before_context, after_context=after_context)
+
+    def visit_node_outputs(self, node_outputs: NodeOutputs) -> DescribeUnit:
+        # This logic is not required for Describe operations,
+        # and should be ported a new base for this class type.
+        before_context = list()
+        after_context = list()
+        for node_output in node_outputs.outputs:
+            output_unit = self.visit(node_output)
+            output_before = output_unit.before_context
+            output_after = output_unit.after_context
+            if output_before:
+                before_context.append(output_before)
+            if output_after:
+                after_context.append(output_after)
+        return DescribeUnit(before_context=before_context, after_context=after_context)
+
     def visit_node_resource(self, node_resource: NodeResource) -> DescribeUnit:
-        condition_unit = self._resolve_resource_condition_reference(
-            node_resource.condition_reference
-        )
-        condition_before = condition_unit.before_context
-        condition_after = condition_unit.after_context
-        if not condition_before and condition_after:
-            change_type = ChangeType.CREATED
-        elif condition_before and not condition_after:
-            change_type = ChangeType.REMOVED
-        else:
-            change_type = node_resource.change_type
-        if change_type == ChangeType.UNCHANGED:
-            # TODO
-            return None
+        change_type = node_resource.change_type
+        if node_resource.condition_reference is not None:
+            condition_unit = self._resolve_resource_condition_reference(
+                node_resource.condition_reference
+            )
+            condition_before = condition_unit.before_context
+            condition_after = condition_unit.after_context
+            if not condition_before and condition_after:
+                change_type = ChangeType.CREATED
+            elif condition_before and not condition_after:
+                change_type = ChangeType.REMOVED
 
         resource_change = cfn_api.ResourceChange()
         resource_change["LogicalResourceId"] = node_resource.name
@@ -432,28 +506,28 @@ class ChangeSetModelDescriber(ChangeSetModelVisitor):
         )
 
         properties_describe_unit = self.visit(node_resource.properties)
-        match change_type:
-            case ChangeType.MODIFIED:
-                resource_change["Action"] = cfn_api.ChangeAction.Modify
-                resource_change["BeforeContext"] = properties_describe_unit.before_context
-                resource_change["AfterContext"] = properties_describe_unit.after_context
-            case ChangeType.CREATED:
-                resource_change["Action"] = cfn_api.ChangeAction.Add
-                resource_change["AfterContext"] = properties_describe_unit.after_context
-            case ChangeType.REMOVED:
-                resource_change["Action"] = cfn_api.ChangeAction.Remove
-                resource_change["BeforeContext"] = properties_describe_unit.before_context
-
-        self._changes.append(
-            cfn_api.Change(Type=cfn_api.ChangeType.Resource, ResourceChange=resource_change)
-        )
 
-        # TODO
-        return None
+        if change_type != ChangeType.UNCHANGED:
+            match change_type:
+                case ChangeType.MODIFIED:
+                    resource_change["Action"] = cfn_api.ChangeAction.Modify
+                    resource_change["BeforeContext"] = properties_describe_unit.before_context
+                    resource_change["AfterContext"] = properties_describe_unit.after_context
+                case ChangeType.CREATED:
+                    resource_change["Action"] = cfn_api.ChangeAction.Add
+                    resource_change["AfterContext"] = properties_describe_unit.after_context
+                case ChangeType.REMOVED:
+                    resource_change["Action"] = cfn_api.ChangeAction.Remove
+                    resource_change["BeforeContext"] = properties_describe_unit.before_context
+            self._changes.append(
+                cfn_api.Change(Type=cfn_api.ChangeType.Resource, ResourceChange=resource_change)
+            )
 
-    # def visit_node_resources(self, node_resources: NodeResources) -> DescribeUnit:
-    #     for node_resource in node_resources.resources:
-    #         if node_resource.change_type != ChangeType.UNCHANGED:
-    #             self.visit_node_resource(node_resource=node_resource)
-    #     # TODO
-    #     return None
+        before_context = None
+        after_context = None
+        # TODO: reconsider what is the describe unit return value for a resource type.
+        if change_type != ChangeType.CREATED:
+            before_context = node_resource.name
+        if change_type != ChangeType.REMOVED:
+            after_context = node_resource.name
+        return DescribeUnit(before_context=before_context, after_context=after_context)