Update test code coverage

Author: jedymatt

src/sqlalchemyseed/class_registry.py

@@ -27,6 +27,7 @@
 from inspect import isclass
 from sqlalchemy import inspect
 from . import errors
+from . import util
 
 
 def parse_class_path(class_path: str):
@@ -41,14 +42,10 @@ def parse_class_path(class_path: str):
     except AttributeError:
         raise errors.NotInModuleError(f"{class_name} is not found in module {module_name}.")
 
-    try:
-        if isclass(class_) and inspect(class_):
-            return class_
-
-        raise errors.NotClassError("'{}' is not a class".format(class_name))
-    except NoInspectionAvailable:
-        raise errors.UnsupportedClassError(
-            "'{}' is an unsupported class".format(class_name))
+    if util.is_supported_class(class_):
+        return class_
+    else:
+        raise errors.UnsupportedClassError("'{}' is an unsupported class".format(class_name))
 
 
 class ClassRegistry:

src/sqlalchemyseed/errors.py

@@ -27,18 +27,17 @@ class InvalidKeyError(Exception):
     """Raised when an invalid key is invoked"""
     pass
 
+
 class ParseError(Exception):
     """Raised when parsing string fails"""
     pass
 
-class NotClassError(Exception):
-    """Raised when a value is not a class"""
-    pass
 
 class UnsupportedClassError(Exception):
     """Raised when an unsupported class is invoked"""
     pass
 
+
 class NotInModuleError(Exception):
     """Raised when a value is not found in module"""
-    pass
+    pass

src/sqlalchemyseed/loader.py

@@ -26,11 +26,9 @@
 import json
 import sys
 
-from . import validator
-
 try:
     import yaml
-except ModuleNotFoundError: # pragma: no cover
+except ModuleNotFoundError:  # pragma: no cover
     pass
 
 
@@ -41,8 +39,6 @@ def load_entities_from_json(json_filepath):
     except FileNotFoundError as error:
         raise FileNotFoundError(error)
 
-    validator.SchemaValidator.validate(entities)
-
     return entities
 
 
@@ -59,8 +55,6 @@ def load_entities_from_yaml(yaml_filepath):
     except FileNotFoundError as error:
         raise FileNotFoundError(error)
 
-    validator.SchemaValidator.validate(entities)
-
     return entities
 
 
@@ -80,6 +74,4 @@ def load_entities_from_csv(csv_filepath: str, model) -> dict:
 
         entities = {'model': model_name, 'data': source_data}
 
-    validator.SchemaValidator.validate(entities)
-
     return entities

src/sqlalchemyseed/seeder.py

@@ -88,23 +88,16 @@ def is_relationship_attribute(self):
 
     @property
     def referenced_class(self):
-        # if self.is_column_attribute():
-        #     return
         if self.is_relationship_attribute():
             return self.class_attribute.mapper.class_
 
-        if self.is_column_attribute():
-            table_name = get_foreign_key_column(self.class_attribute).table.name
-            return next(
-                (
-                    mapper.class_
-                    for mapper in object_mapper(self.instance).registry.mappers
-                    if mapper.class_.__tablename__ == table_name
-                ),
-                errors.ClassNotFoundError(
-                    "A class with table name '{}' is not found in the mappers".format(table_name)
-                )
-            )
+        # if self.is_column_attribute():
+        table_name = get_foreign_key_column(self.class_attribute).table.name
+
+        return next(filter(
+            lambda mapper: mapper.class_.__tablename__ == table_name,
+            object_mapper(self.instance).registry.mappers
+        )).class_
 
 
 def get_foreign_key_column(attr, idx=0) -> schema.Column:
@@ -125,7 +118,7 @@ def set_parent_attr_value(instance, parent: Entity):
         else:
             parent.instance_attribute = instance
 
-    if parent.is_column_attribute():
+    else:  # if parent.is_column_attribute():
         parent.instance_attribute = instance
 
 
@@ -150,8 +143,7 @@ def get_model_class(self, entity, parent: Entity):
         return parent.referenced_class
 
     def seed(self, entities, add_to_session=True):
-        validator.SchemaValidator.validate(
-            entities, ref_prefix=self.ref_prefix, source_keys=[validator.Key.data()])
+        validator.validate(entities=entities, ref_prefix=self.ref_prefix)
 
         self._instances.clear()
         self._class_registry.clear()
@@ -238,8 +230,7 @@ def get_model_class(self, entity, parent: Entity):
         return parent.referenced_class
 
     def seed(self, entities):
-        validator.SchemaValidator.validate(
-            entities, ref_prefix=self.ref_prefix)
+        validator.hybrid_validate(entities=entities, ref_prefix=self.ref_prefix)
 
         self._instances.clear()
         self._class_registry.clear()
@@ -256,17 +247,17 @@ def _pre_seed(self, entity, parent=None):
     def _seed(self, entity, parent):
         class_ = self.get_model_class(entity, parent)
 
-        source_key: validator.Key = next(
-            (sk for sk in self.__source_keys if sk in entity),
-            None
+        source_key = next(
+            filter(lambda sk: sk in entity, self.__source_keys)
         )
 
         source_data = entity[source_key]
 
         # source_data is list
         if isinstance(source_data, list):
             for kwargs in source_data:
-                instance = self._setup_instance(class_, kwargs, source_key, parent)
+                instance = self._setup_instance(
+                    class_, kwargs, source_key, parent)
                 self._seed_children(instance, kwargs)
             return
 
@@ -295,11 +286,13 @@ def _setup_instance(self, class_, kwargs: dict, key, parent):
 
     def _setup_data_instance(self, class_, filtered_kwargs, parent: Entity):
         if parent is not None and parent.is_column_attribute():
-            raise errors.InvalidKeyError("'data' key is invalid for a column attribute.")
+            raise errors.InvalidKeyError(
+                "'data' key is invalid for a column attribute.")
 
         instance = class_(**filtered_kwargs)
-        self.session.add(instance)
+
         if parent is None:
+            self.session.add(instance)
             self._instances.append(instance)
 
         return instance

src/sqlalchemyseed/util.py

@@ -1,3 +1,8 @@
+from inspect import isclass
+
+from sqlalchemy import inspect
+
+
 def iter_ref_kwargs(kwargs: dict, ref_prefix: str):
     """Iterate kwargs with name prefix or references"""
     for attr_name, value in kwargs.items():
@@ -11,3 +16,7 @@ def iter_non_ref_kwargs(kwargs: dict, ref_prefix: str):
     for attr_name, value in kwargs.items():
         if not attr_name.startswith(ref_prefix):
             yield attr_name, value
+
+
+def is_supported_class(class_):
+    return True if isclass(class_) and inspect(class_, raiseerr=False) else False

src/sqlalchemyseed/validator.py

@@ -22,6 +22,7 @@
 SOFTWARE.
 """
 
+import abc
 from . import errors, util
 
 
@@ -83,17 +84,20 @@ def check_source_key(entity: dict, source_keys: list) -> Key:
 
     # check if current keys has at least, data or filter key
     if source_key is None:
-        raise errors.MissingKeyError(f"Missing {', '.join(map(str, source_keys))} key(s).")
+        raise errors.MissingKeyError(
+            f"Missing {', '.join(map(str, source_keys))} key(s).")
 
     return source_key
 
 
 def check_source_data(source_data, source_key: Key):
     if not isinstance(source_data, dict) and not isinstance(source_data, list):
-        raise errors.InvalidTypeError(f"Invalid type_, {str(source_key)} should be either 'dict' or 'list'.")
+        raise errors.InvalidTypeError(
+            f"Invalid type_, {str(source_key)} should be either 'dict' or 'list'.")
 
     if isinstance(source_data, list) and len(source_data) == 0:
-        raise errors.EmptyDataError("Empty list, 'data' or 'filter' list should not be empty.")
+        raise errors.EmptyDataError(
+            "Empty list, 'data' or 'filter' list should not be empty.")
 
 
 def check_data_type(item, source_key: Key):
@@ -102,37 +106,38 @@ def check_data_type(item, source_key: Key):
             f"Invalid type_, '{source_key.name}' should be '{source_key.type_}'")
 
 
-class SchemaValidator:
-    _source_keys = None
-    _ref_prefix = None
+class SchemaValidator(abc.ABC):
+
+    def __init__(self, source_keys, ref_prefix):
+        self._source_keys = source_keys
+        self._ref_prefix = ref_prefix
 
     @classmethod
-    def validate(cls, entities, ref_prefix='!', source_keys=None):
-        if source_keys is None:
-            cls._source_keys = [Key.data(), Key.filter()]
-        cls._ref_prefix = ref_prefix
+    def validate(cls, entities, source_keys, ref_prefix='!'):
+        self = cls(source_keys, ref_prefix)
+        self._source_keys = source_keys
+        self._ref_prefix = ref_prefix
 
-        cls._pre_validate(entities, entity_is_parent=True)
+        self._pre_validate(entities, entity_is_parent=True)
 
-    @classmethod
-    def _pre_validate(cls, entities: dict, entity_is_parent=True):
+    def _pre_validate(self, entities: dict, entity_is_parent=True):
         if not isinstance(entities, dict) and not isinstance(entities, list):
-            raise errors.InvalidTypeError("Invalid type, should be list or dict")
+            raise errors.InvalidTypeError(
+                "Invalid type, should be list or dict")
         if len(entities) == 0:
             return
         if isinstance(entities, dict):
-            return cls._validate(entities, entity_is_parent)
+            return self._validate(entities, entity_is_parent)
         # iterate list
         for entity in entities:
-            cls._pre_validate(entity, entity_is_parent)
+            self._pre_validate(entity, entity_is_parent)
 
-    @classmethod
-    def _validate(cls, entity: dict, entity_is_parent=True):
+    def _validate(self, entity: dict, entity_is_parent=True):
         check_max_length(entity)
         check_model_key(entity, entity_is_parent)
 
         # get source key, either data or filter key
-        source_key = check_source_key(entity, cls._source_keys)
+        source_key = check_source_key(entity, self._source_keys)
         source_data = entity[source_key]
 
         check_source_data(source_data, source_key)
@@ -141,13 +146,23 @@ def _validate(cls, entity: dict, entity_is_parent=True):
             for item in source_data:
                 check_data_type(item, source_key)
                 # check if item is a relationship attribute
-                cls.check_attributes(item)
+                self.check_attributes(item)
         else:
             # source_data is dict
             # check if item is a relationship attribute
-            cls.check_attributes(source_data)
+            self.check_attributes(source_data)
 
-    @classmethod
-    def check_attributes(cls, source_data: dict):
-        for _, value in util.iter_ref_kwargs(source_data, cls._ref_prefix):
-            cls._pre_validate(value, entity_is_parent=False)
+    def check_attributes(self, source_data: dict):
+        for _, value in util.iter_ref_kwargs(source_data, self._ref_prefix):
+            self._pre_validate(value, entity_is_parent=False)
+
+
+def validate(entities, ref_prefix='!'):
+    SchemaValidator.validate(
+        entities, ref_prefix=ref_prefix, source_keys=[Key.data()])
+
+
+def hybrid_validate(entities, ref_prefix='!'):
+    SchemaValidator.validate(entities,
+                             ref_prefix=ref_prefix,
+                             source_keys=[Key.data(), Key.filter()])