Added type checks to cards.py

Author: sQu4rks

webexteamssdk/cards/card.py

@@ -23,6 +23,9 @@
 """
 
 from .abstract_components import Serializable
+from .actions import OpenUrl, ShowCard, Submit
+
+from .utils import check_type
 
 class AdaptiveCard(Serializable):
     """AdaptiveCard class that represents a adaptive card python object.
@@ -34,7 +37,6 @@ class AdaptiveCard(Serializable):
     def __init__(self, body=None,
                        actions=None,
                        selectAction=None,
-                       style=None,
                        fallbackText=None,
                        lang=None):
         """Creates a new adaptive card object.
@@ -52,20 +54,25 @@ def __init__(self, body=None,
                 used for localization of date/time functions
 
         """
-        super().__init__(serializable_properties=[
-                            'body', 'actions', 'selectAction', 'style'
-                         ],
-                         simple_properties=[
-                            'version', 'fallbackText', 'lang', 'schema', 'type'
-                         ])
+        # Check types
+        check_type(actions, (ShowCard, Submit, OpenUrl), True, True)
+        check_type(selectAction, (Submit, OpenUrl), False, True)
+        check_type(fallbackText, str, False, True)
+        check_type(lang, str, False, True)
 
         # Set properties
         self.type = "AdaptiveCard"
         self.version = "1.1" # This is the version currently supported in Teams
         self.body = body
         self.actions = actions
         self.selectAction = selectAction
-        self.style = style
         self.fallbackText = fallbackText
         self.lang = lang
         self.schema = "http://adaptivecards.io/schemas/adaptive-card.json"
+
+        super().__init__(serializable_properties=[
+                            'body', 'actions', 'selectAction'
+                         ],
+                         simple_properties=[
+                            'version', 'fallbackText', 'lang', 'schema', 'type'
+                         ])

webexteamssdk/cards/utils.py

@@ -25,3 +25,67 @@
 def set_if_not_none(property_name, property, export):
     if property is not None:
         export[property_name] = property.to_dict()
+
+def check_type(obj, acceptable_types, is_list=False, may_be_none=False):
+    """Object is an instance of one of the acceptable types or None.
+
+    Args:
+        obj: The object to be inspected.
+        acceptable_types: A type or tuple of acceptable types.
+        is_list(bool): Whether or not we expect a list of objects of acceptable
+            type
+        may_be_none(bool): Whether or not the object may be None.
+
+    Raises:
+        TypeError: If the object is None and may_be_none=False, or if the
+            object is not an instance of one of the acceptable types.
+
+    """
+    error_message = None
+    if not isinstance(acceptable_types, tuple):
+        acceptable_types = (acceptable_types,)
+
+    if may_be_none and obj is None:
+        pass
+    elif is_list:
+        # Check that all objects in that list are of the required type
+        if not isinstance(obj, list):
+            error_message = (
+                "We were expecting to receive a list of one of the following "
+                "types: {types}{none}; but instead we received {o} which is a "
+                "{o_type}.".format(
+                    types=", ".join([repr(t.__name__) for t in acceptable_types]),
+                    none="or 'None'" if may_be_none else "",
+                    o=obj,
+                    o_type=repr(type(obj).__name__)
+                )
+            )
+        else:
+            for o in obj:
+                if not isinstance(o, acceptable_types):
+                    error_message = (
+                        "We were expecting to receive an instance of one of the following "
+                        "types: {types}{none}; but instead we received {o} which is a "
+                        "{o_type}.".format(
+                            types=", ".join([repr(t.__name__) for t in acceptable_types]),
+                            none="or 'None'" if may_be_none else "",
+                            o=o,
+                            o_type=repr(type(o).__name__)
+                        )
+                    )
+    elif isinstance(obj, acceptable_types):
+        pass
+    else:
+        # Object is something else.
+        error_message = (
+            "We were expecting to receive an instance of one of the following "
+            "types: {types}{none}; but instead we received {o} which is a "
+            "{o_type}.".format(
+                types=", ".join([repr(t.__name__) for t in acceptable_types]),
+                none="or 'None'" if may_be_none else "",
+                o=obj,
+                o_type=repr(type(obj).__name__)
+            )
+        )
+    if error_message is not None:
+        raise TypeError(error_message)