Update test cases, validator, instances, and commented out not yet used lines

Author: jedymatt

sqlalchemyseed/_future/seeder.py

@@ -152,33 +152,32 @@ def _setup_instance(self, class_, kwargs: dict, parent: Entity):
     #     if key is validator.Key.filter() and self.session is not None:
     #         return self.session.query(class_).filter_by(**filtered_kwargs).one()
 
-
-class HybridSeeder:
-    __model_key = validator.Key.model()
-    __source_keys = [validator.Key.data(), validator.Key.filter()]
-
-    def __init__(self, session: sqlalchemy.orm.Session, ref_prefix):
-        self.session = session
-        self._class_registry = class_registry.ClassRegistry()
-        self._instances = []
-        self.ref_prefix = ref_prefix
-
-    @property
-    def instances(self):
-        return tuple(self._instances)
-
-    def seed(self, entities):
-        validator.SchemaValidator.validate(
-            entities, ref_prefix=self.ref_prefix)
-
-        self._pre_seed(entities)
-
-    def _pre_seed(self, entity, parent=None):
-        if isinstance(entity, dict):
-            self._seed(entity, parent)
-        else:  # is list
-            for item in entity:
-                self._pre_seed(item, parent)
-
-    def _seed(self, entity, parent):
-        pass
+# class HybridSeeder:
+#     __model_key = validator.Key.model()
+#     __source_keys = [validator.Key.data(), validator.Key.filter()]
+#
+#     def __init__(self, session: sqlalchemy.orm.Session, ref_prefix):
+#         self.session = session
+#         self._class_registry = class_registry.ClassRegistry()
+#         self._instances = []
+#         self.ref_prefix = ref_prefix
+#
+#     @property
+#     def instances(self):
+#         return tuple(self._instances)
+#
+#     def seed(self, entities):
+#         validator.SchemaValidator.validate(
+#             entities, ref_prefix=self.ref_prefix)
+#
+#         self._pre_seed(entities)
+#
+#     def _pre_seed(self, entity, parent=None):
+#         if isinstance(entity, dict):
+#             self._seed(entity, parent)
+#         else:  # is list
+#             for item in entity:
+#                 self._pre_seed(item, parent)
+#
+#     def _seed(self, entity, parent):
+#         pass

sqlalchemyseed/seeder.py

@@ -160,7 +160,7 @@ def instantiate_obj(self,
         filtered_kwargs = {
             k: v
             for k, v in kwargs.items() if not k.startswith("!")
-            and not isinstance(getattr(class_, k), RelationshipProperty)
+                                          and not isinstance(getattr(class_, k), RelationshipProperty)
         }
 
         if key_is_data is True:
@@ -201,7 +201,7 @@ def instantiate_obj(self,
         filtered_kwargs = {
             k: v
             for k, v in kwargs.items() if not k.startswith("!")
-            and not isinstance(getattr(class_, k), RelationshipProperty)
+                                          and not isinstance(getattr(class_, k), RelationshipProperty)
         }
 
         if key_is_data is True:
@@ -236,7 +236,3 @@ def _query_instance_id(self, class_, filtered_kwargs, foreign_key):
         result = (self.session.query(getattr(
             class_, column_name)).filter_by(**filtered_kwargs).one())
         return getattr(result, column_name)
-
-
-if __name__ == "__main__":
-    pass

sqlalchemyseed/validator.py

@@ -99,11 +99,11 @@ def check_source_data(source_data, source_key: Key):
         raise errors.EmptyDataError("Empty list, 'data' or 'filter' list should not be empty.")
 
 
-def iter_reference_relationships(kwargs: dict, ref_prefix):
-    for attr_name, value in kwargs.items():
-        if attr_name.startswith(ref_prefix):
-            # removed prefix
-            yield attr_name[len(ref_prefix):], value
+# def iter_reference_relationships(kwargs: dict, ref_prefix):
+#     for attr_name, value in kwargs.items():
+#         if attr_name.startswith(ref_prefix):
+#             # removed prefix
+#             yield attr_name[len(ref_prefix):], value
 
 
 class SchemaValidator:
@@ -123,9 +123,9 @@ def _pre_validate(cls, entities: dict, is_parent=True, ref_prefix='!'):
             return
         if isinstance(entities, dict):
             return cls._validate(entities, is_parent, ref_prefix)
-        elif isinstance(entities, list):
-            for entity in entities:
-                cls._pre_validate(entity, is_parent, ref_prefix)
+        # iterate list
+        for entity in entities:
+            cls._pre_validate(entity, is_parent, ref_prefix)
 
     @classmethod
     def _validate(cls, entity: dict, entity_is_parent=True, ref_prefix='!'):
@@ -139,10 +139,9 @@ def _validate(cls, entity: dict, entity_is_parent=True, ref_prefix='!'):
         check_source_data(source_data, source_key)
 
         if isinstance(source_data, list):
-
             for item in source_data:
                 if not source_key.is_valid_type(item):
-                    raise TypeError(
+                    raise errors.InvalidDataTypeError(
                         f"Invalid type, '{source_key.label}' should be '{source_key.type}'")
 
                 # check if item is a relationship attribute
@@ -156,8 +155,3 @@ def _scan_attributes(cls, source_data: dict, ref_prefix):
         for key, value in source_data.items():
             if str(key).startswith(ref_prefix):
                 cls._pre_validate(value, is_parent=False, ref_prefix=ref_prefix)
-
-
-if __name__ == '__main__':
-    instance = [[]]
-    SchemaValidator.validate(instance)

tests/instances.py

@@ -5,6 +5,25 @@
     }
 }
 
+PARENT_INVALID = 'str is not valid type for parent'
+
+PARENT_EMPTY = []
+
+PARENT_EMPTY_DATA_LIST_INVALID = {
+    'model': 'tests.models.Company',
+    'data': []
+}
+
+PARENT_MISSING_MODEL_INVALID = {
+    'data': {
+
+    }
+}
+
+PARENT_INVALID_MODEL_INVALID = {
+    'model': 9_999
+}
+
 PARENT_WITH_EXTRA_LENGTH_INVALID = {
     'model': 'tests.models.Company',
     'data': {
@@ -34,6 +53,19 @@
     ]
 }
 
+PARENT_WITH_DATA_AND_INVALID_DATA_INVALID = {
+    'model': 'tests.models.Company',
+    'data': [
+        {},
+        9_999_999
+    ]
+}
+
+PARENT_WITH_INVALID_DATA_INVALID = {
+    'model': 'tests.models.Company',
+    'data': 'str is an invalid type of \'data\''
+}
+
 PARENTS = [
     {
         'model': 'tests.models.Company',

tests/test_validator.py

@@ -1,7 +1,7 @@
 import unittest
 
 from sqlalchemyseed import errors
-from sqlalchemyseed.validator import SchemaValidator
+from sqlalchemyseed.validator import SchemaValidator, Key
 from tests import instances as ins
 
 
@@ -10,6 +10,25 @@ class TestSchemaValidator(unittest.TestCase):
     def test_parent(self):
         self.assertIsNone(SchemaValidator.validate(ins.PARENT))
 
+    def test_parent_invalid(self):
+        self.assertRaises(errors.InvalidDataTypeError,
+                          lambda: SchemaValidator.validate(ins.PARENT_INVALID))
+
+    def test_parent_empty(self):
+        self.assertIsNone(SchemaValidator.validate(ins.PARENT_EMPTY))
+
+    def test_parent_empty_data_list_invalid(self):
+        self.assertRaises(errors.EmptyDataError,
+                          lambda: SchemaValidator.validate(ins.PARENT_EMPTY_DATA_LIST_INVALID))
+
+    def test_parent_missing_model_invalid(self):
+        self.assertRaises(errors.MissingRequiredKeyError,
+                          lambda: SchemaValidator.validate(ins.PARENT_MISSING_MODEL_INVALID))
+
+    def test_parent_invalid_model_invalid(self):
+        self.assertRaises(errors.InvalidDataTypeError,
+                          lambda: SchemaValidator.validate(ins.PARENT_INVALID_MODEL_INVALID))
+
     def test_parent_with_extra_length_invalid(self):
         self.assertRaises(errors.MaxLengthExceededError,
                           lambda: SchemaValidator.validate(ins.PARENT_WITH_EXTRA_LENGTH_INVALID))
@@ -24,6 +43,14 @@ def test_parent_without_data_invalid(self):
         self.assertRaises(errors.MissingRequiredKeyError,
                           lambda: SchemaValidator.validate(ins.PARENT_WITHOUT_DATA_INVALID))
 
+    def test_parent_with_data_and_invalid_data_invalid(self):
+        self.assertRaises(errors.InvalidDataTypeError,
+                          lambda: SchemaValidator.validate(ins.PARENT_WITH_DATA_AND_INVALID_DATA_INVALID))
+
+    def test_parent_with_invalid_data_invalid(self):
+        self.assertRaises(errors.InvalidDataTypeError,
+                          lambda: SchemaValidator.validate(ins.PARENT_WITH_INVALID_DATA_INVALID))
+
     def test_parent_to_child(self):
         self.assertIsNone(SchemaValidator.validate(ins.PARENT_TO_CHILD))
 
@@ -38,3 +65,17 @@ def test_parent_to_children_with_multi_data(self):
 
     def test_parent_to_children_with_multi_data_without_model(self):
         self.assertIsNone(SchemaValidator.validate(ins.PARENT_TO_CHILDREN_WITH_MULTI_DATA_WITHOUT_MODEL))
+
+
+class TestKey(unittest.TestCase):
+    def test_key_equal_key(self):
+        self.assertEqual(Key.model(), Key(label='model', type_=str))
+
+    def test_key_not_equal(self):
+        self.assertNotEqual(Key.model(), Key.data())
+
+    def test_key_equal_string(self):
+        self.assertEqual(Key.model(), 'model')
+
+    def test_key_not_equal_other_instance(self):
+        self.assertNotEqual(Key.model(), object())