test-coverage: 100% test coverage for ellar.pydantic package

Author: eadwinCode

ellar/pydantic/__init__.py

@@ -27,7 +27,6 @@
     evaluate_forwardref,
     get_definitions,
     get_missing_field_error,
-    get_model_config,
     get_schema_from_model_field,
     is_scalar_field,
     is_scalar_sequence_field,
@@ -51,7 +50,6 @@
     "as_pydantic_validator",
     "model_dump",
     "model_rebuild",
-    "get_model_config",
     "get_missing_field_error",
     "get_definitions",
     "get_schema_from_model_field",

ellar/pydantic/exceptions.py

@@ -51,3 +51,7 @@ def model_dump(self, **kw: t.Any) -> t.Dict[str, t.Any]:  # pragma: no cover
             d["ctx"] = ctx
 
         return d
+
+
+class InvalidModelFieldSetupException(Exception):
+    pass

ellar/pydantic/utils.py

@@ -2,7 +2,12 @@
 from collections import deque
 from dataclasses import is_dataclass
 
-from pydantic import BaseModel, PydanticSchemaGenerationError, create_model
+from pydantic import (
+    BaseModel,
+    PydanticSchemaGenerationError,
+    PydanticUndefinedAnnotation,
+    create_model,
+)
 from pydantic import ValidationError as ValidationError
 from pydantic._internal._typing_extra import eval_type_lenient
 from pydantic._internal._utils import lenient_issubclass
@@ -11,6 +16,7 @@
 from starlette.datastructures import UploadFile
 from typing_extensions import Literal, get_args, get_origin
 
+from .exceptions import InvalidModelFieldSetupException
 from .fields import ModelField
 from .types import Undefined, UnionType
 
@@ -44,10 +50,6 @@ def model_dump(
     return model.model_dump(mode=mode, **kwargs)
 
 
-def get_model_config(model: BaseModel) -> t.Any:
-    return model.model_config
-
-
 def get_schema_from_model_field(
     *,
     field: ModelField,
@@ -110,10 +112,6 @@ def is_scalar_sequence_field(field: ModelField) -> bool:
     return field_annotation_is_scalar_sequence(field.field_info.annotation)
 
 
-def copy_field_info(*, field_info: FieldInfo, annotation: t.Any) -> FieldInfo:
-    return type(field_info).from_annotation(annotation)
-
-
 def serialize_sequence_value(*, field: ModelField, value: t.Any) -> t.Sequence[t.Any]:
     origin_type = (
         t.get_origin(field.field_info.annotation) or field.field_info.annotation
@@ -250,7 +248,7 @@ def create_model_field(
 
     try:
         return model_field_class(**kwargs)  # type: ignore[arg-type]
-    except (RuntimeError, PydanticSchemaGenerationError) as e:
-        raise Exception(
+    except (PydanticUndefinedAnnotation, PydanticSchemaGenerationError) as e:
+        raise InvalidModelFieldSetupException(
             f"Invalid args for response field! Hint: check that {type_} is a valid pydantic field type"
         ) from e

tests/test_pydantic/__init__.py

@@ -1,7 +1,7 @@
 import pytest
 from ellar.common.responses.models import ResponseModelField
 from ellar.pydantic import ModelField, create_model_field
-from pydantic import PydanticUndefinedAnnotation
+from ellar.pydantic.exceptions import InvalidModelFieldSetupException
 
 
 def test_create_model_field_works():
@@ -17,7 +17,7 @@ def test_create_model_field_works():
 
 def test_create_model_field_fails():
     with pytest.raises(
-        PydanticUndefinedAnnotation,
+        InvalidModelFieldSetupException,
     ):
         create_model_field(
             name="response_model",

tests/test_helper/test_model_field.py renamed to tests/test_pydantic/test_model_field.py

@@ -0,0 +1,30 @@
+from typing import List, Union
+
+from ellar.pydantic import utils
+
+from ..schema import NoteSchemaDC
+
+
+def test_is_bytes_sequence_annotation_union():
+    # For coverage
+    assert utils.is_bytes_sequence_annotation(Union[List[str], List[bytes]])
+
+
+def test_field_annotation_is_scalar_sequence():
+    # For coverage
+    assert (
+        utils.field_annotation_is_scalar_sequence(Union[List[str], List[bytes]]) is True
+    )
+    assert (
+        utils.field_annotation_is_scalar_sequence(
+            Union[List[str], List[bytes], List[NoteSchemaDC]]
+        )
+        is False
+    )
+
+
+def test_is_bytes_annotation():
+    # For coverage
+    assert utils.is_bytes_annotation(Union[List[str], List[bytes]]) is False
+    assert utils.is_bytes_annotation(bytes) is True
+    assert utils.is_bytes_annotation(Union[bytes, str]) is True