Add more tests

Author: GavinZZ

samtranslator/validator/resource_validator.py

@@ -4,37 +4,44 @@
 from pydantic import BaseModel
 
 
-class ResourceModel:
+class Model:
     """
     Wrapper class around a SAM schema BaseModel to with a new functional "get" method
     """
 
     def __init__(self, model: BaseModel) -> None:
         self.model = model
 
-    def get(self, attr: str, default_value: Any = None) -> Any:
-        attr_value = self.model.__dict__.get(attr, default_value)
+    def _process_attr_value(self, attr_value: Any) -> Any:
         if isinstance(attr_value, BaseModel):
             if "__root__" in attr_value.__dict__:
                 return attr_value.__dict__["__root__"]
-            return ResourceModel(attr_value)
+            return Model(attr_value)
         return attr_value
 
-    def __getitem__(self, attr: str) -> Any:
-        attr_value = self.model.__dict__[attr]
-        if isinstance(attr_value, BaseModel):
-            if "__root__" in attr_value.__dict__:
-                return attr_value.__dict__["__root__"]
-            return ResourceModel(attr_value)
-        return attr_value
+    def _get_item(self, attr_value: Any) -> Any:
+        if isinstance(attr_value, list):
+            return [self._process_attr_value(attr) for attr in attr_value]
+        return self._process_attr_value(attr_value)
+
+    def get(self, attr_key: str, default_value: Any = None) -> Any:
+        """Return the value for key if key is in Model properties else default."""
+        attr_value = self.model.__dict__.get(attr_key, default_value)
+        return self._get_item(attr_value)
+
+    def __getitem__(self, attr_key: str) -> Any:
+        """Return the value for key if key is in Model properties else raise KeyError exception."""
+        attr_value = self.model.__dict__[attr_key]
+        return self._get_item(attr_value)
 
 
-def to_resource_model(resource_properties: Dict[Any, Any], cls: Type[BaseModel]) -> ResourceModel:
+# Note: For compabitliy issue, we should ONLY use this with new abstraction/resources.
+def to_model(resource_properties: Dict[Any, Any], cls: Type[BaseModel]) -> Model:
     """
     Given properties of a SAM resource return a typed object from the definitions of SAM schema model
 
     param:
         resource_properties: properties from input template
         cls: SAM schema models
     """
-    return ResourceModel(cls(**resource_properties))
+    return Model(cls(**resource_properties))

tests/validator/test_resource_validator.py

@@ -1,16 +1,46 @@
 import os.path
+from typing import Dict, List
 from unittest import TestCase
 
+from pydantic import BaseModel
 from pydantic.error_wrappers import ValidationError
-from samtranslator.validator.resource_validator import to_resource_model
+from samtranslator.validator.resource_validator import to_model
 from samtranslator.yaml_helper import yaml_parse
 from schema_source.aws_serverless_connector import Properties as ConnectorProperties
 
 BASE_PATH = os.path.dirname(__file__)
 CONNECTOR_INPUT_FOLDER = os.path.join(BASE_PATH, "input", "connector")
 
 
-class TestResourceModel(TestCase):
+class Random(BaseModel):
+    value: int
+
+
+class Tag(BaseModel):
+    A: str
+    B: int
+
+
+class Content(BaseModel):
+    Tags: Tag
+
+
+class Contents(BaseModel):
+    Content: Content
+
+
+class Properties(BaseModel):
+    Key: Dict[str, Random]
+    Hello: List[str]
+    Random: Random
+
+
+class ValidatiorBaseModel(BaseModel):
+    Properties: Properties
+    Contents: List[Contents]
+
+
+class TestModel(TestCase):
     def setUp(self) -> None:
         self.connector_template = {
             "Source": {
@@ -21,8 +51,17 @@ def setUp(self) -> None:
             "Permissions": ["Read"],
         }
 
-    def test_resource_model_get(self):
-        connector_model = to_resource_model(
+        self.model_template = {
+            "Properties": {"Key": {"A": {"value": 10}}, "Hello": ["1", "2", "3"], "Random": {"value": 5}},
+            "Contents": [
+                {"Content": {"Tags": {"A": "hello", "B": 5}}},
+                {"Content": {"Tags": {"A": "wow", "B": 10}}},
+                {"Content": {"Tags": {"A": "no", "B": -5}}},
+            ],
+        }
+
+    def test_connector_model_get_operation(self):
+        connector_model = to_model(
             self.connector_template,
             ConnectorProperties,
         )
@@ -38,9 +77,24 @@ def test_resource_model_get(self):
         self.assertEqual(connector_model["Destination"]["Id"], "MyTable")
         self.assertEqual(connector_model["Permissions"], ["Read"])
 
+    def test_model_get_operation(self):
+        model = to_model(self.model_template, ValidatiorBaseModel)
+        self.assertEqual(model["Properties"]["Key"], {"A": {"value": 10}})
+        self.assertEqual(model["Properties"]["Key"]["A"], {"value": 10})
+        self.assertEqual(model["Properties"]["Hello"], ["1", "2", "3"])
+        self.assertEqual(model.get("Properties").get("Random")["value"], 5)
+        self.assertEqual(model.get("DoNotExist"), None)
+
+        self.assertEqual(len(model["Contents"]), 3)
+        self.assertEqual(model["Contents"][0]["Content"]["Tags"]["A"], "hello")
+        self.assertEqual(model["Contents"][0]["Content"]["Tags"]["B"], 5)
+        self.assertEqual(model["Contents"][1]["Content"]["Tags"]["A"], "wow")
+        self.assertEqual(model["Contents"][0]["Content"]["Tags"].get("C"), None)
+        self.assertEqual(model["Contents"][2]["Content"]["Tags"]["B"], -5)
 
-class TestResourceValidatorFailure(TestCase):
-    def test_to_resource_model_error_connector_template(self):
+
+class TestModelValidatorFailure(TestCase):
+    def test_to_model_error_connector_template(self):
         manifest = yaml_parse(open(os.path.join(CONNECTOR_INPUT_FOLDER, "error_connector.yaml")))
         for _, resource in manifest["Resources"].items():
             properties = resource["Properties"]
@@ -49,4 +103,16 @@ def test_to_resource_model_error_connector_template(self):
                 ValidationError,
                 "[1-9] validation error for Properties(.|\n)+(Source|Destination|Permissions)(.|\n)*(field required)|(unexpected value)|(str type expected)|(value is not a valid list).+",
             ):
-                to_resource_model(properties, ConnectorProperties)
+                to_model(properties, ConnectorProperties)
+
+    def test_to_model_test_base_model(self):
+        invalid_model_template = {
+            "Properties": {"Key": "123", "Hello": 5, "Random": {}},
+            "Contents": [{"Content": {"Tags": {"A": "hello", "B": 5}}}, {"Content": {"Tags": {"A": "wow"}}}],
+        }
+
+        with self.assertRaisesRegex(
+            ValidationError,
+            "[1-9] validation error for TestBaseModel(.|\n)+(Contents)(.|\n)*(field required)|(unexpected value)|(str type expected)|(value is not a valid list).+",
+        ):
+            to_model(invalid_model_template, ValidatiorBaseModel)