Added test for controller_response and generic patch

Author: eadwinCode

tests/test_controller_response.py

@@ -0,0 +1,78 @@
+import uuid
+
+import pytest
+from pydantic import BaseModel
+
+from ninja_extra.controllers.response import (
+    ControllerResponse,
+    ControllerResponseMeta,
+    Detail,
+    Id,
+    Ok,
+)
+
+
+class ASchema(BaseModel):
+    age: int
+
+
+def test_controller_response_raise_type_error_for_base_model():
+    with pytest.raises(TypeError):
+        ControllerResponse()
+
+
+def test_ok_normal_response_model():
+    ok_any = Ok("this is normal response")
+    assert ok_any.convert_to_schema().dict() == {"detail": "this is normal response"}
+    assert ok_any.status_code == 200
+    assert type(Ok) == ControllerResponseMeta
+
+
+def test_ok_generic_response_model():
+    ok_a_schema = Ok[ASchema]
+    ok_a_schema_instance = ok_a_schema(dict(age=34))
+    assert "ASchema" in ok_a_schema_instance.get_schema().__name__
+    assert ok_a_schema_instance.convert_to_schema().dict() == {"detail": {"age": 34}}
+    assert ok_a_schema_instance.status_code == 200
+    assert ok_a_schema == Ok[ASchema]
+    dsd = type(ok_a_schema)
+    assert type(ok_a_schema) == ControllerResponseMeta
+
+
+def test_id_normal_response_model():
+    id_any = Id(852)
+    assert id_any.convert_to_schema().dict() == {"id": 852}
+    assert id_any.status_code == 201
+    assert type(Id) == ControllerResponseMeta
+
+
+def test_id_generic_response_model():
+    id_uuid = Id[uuid.UUID]
+    uuid_value = uuid.uuid4()
+    id_uuid_instance = id_uuid(uuid_value)
+    assert "UUID" in id_uuid_instance.get_schema().__name__
+    assert id_uuid_instance.convert_to_schema().dict() == {"id": uuid_value}
+    assert id_uuid_instance.status_code == 201
+    assert id_uuid == Id[uuid.UUID]
+    assert type(id_uuid) == ControllerResponseMeta
+
+
+def test_details_normal_response_response_model():
+    detail_any = Detail("this is normal response", 500)
+    assert detail_any.convert_to_schema().dict() == {
+        "detail": "this is normal response"
+    }
+    assert detail_any.status_code == 500
+    assert type(Detail) == ControllerResponseMeta
+
+
+def test_details_generic_response_response_model():
+    details_a_schema = Detail[ASchema]
+    detail_a_schema_instance = details_a_schema(dict(age=34), 400)
+    assert "ASchema" in detail_a_schema_instance.get_schema().__name__
+    assert detail_a_schema_instance.convert_to_schema().dict() == {
+        "detail": {"age": 34}
+    }
+    assert detail_a_schema_instance.status_code == 400
+    assert details_a_schema == Detail[ASchema]
+    assert type(details_a_schema) == ControllerResponseMeta

tests/test_generic_patch.py

@@ -0,0 +1,70 @@
+import sys
+
+import pytest
+
+from ninja_extra.generic import GenericType
+from ninja_extra.schemas.response import (
+    DetailSchema,
+    IdSchema,
+    NinjaPaginationResponseSchema,
+    OkSchema,
+    PaginatedResponseSchema,
+)
+
+
+class A(object):
+    wrap_generic: str
+
+
+class AGenericPatch(GenericType, generic_base_name="A"):
+    def get_generic_type(self, wrap_type):
+        class _A(A):
+            wrap_generic: wrap_type
+
+        return _A
+
+
+def test_generic_patch_works():
+    B = AGenericPatch[int]
+    assert str(B.__name__) == "A[int]"
+    assert B.__annotations__["wrap_generic"] == int
+    assert hasattr(B, "__generic_model__")
+    assert B.__generic_model__ == AGenericPatch
+    assert B == AGenericPatch[int]
+
+
+@pytest.mark.skipif(sys.version_info < (3, 7), reason="requires python < 3.7")
+@pytest.mark.parametrize(
+    "generic_patch, generic_name",
+    [
+        (IdSchema, "IdSchema"),
+        (OkSchema, "OkSchema"),
+        (PaginatedResponseSchema, "PaginatedResponseSchema"),
+        (NinjaPaginationResponseSchema, "NinjaPaginationResponseSchema"),
+        (DetailSchema, "DetailSchema"),
+    ],
+)
+def test_response_schemas_generic_patch(generic_patch, generic_name):
+    new_generic_object = generic_patch[int]
+    assert str(new_generic_object.__name__) == f"{generic_name}[int]"
+    assert hasattr(new_generic_object, "__generic_model__")
+    assert new_generic_object.__generic_model__ == generic_patch
+    assert new_generic_object == generic_patch[int]
+
+
+@pytest.mark.skipif(sys.version_info >= (3, 7), reason="requires python >= 3.7")
+@pytest.mark.parametrize(
+    "generic_schema",
+    [
+        IdSchema,
+        OkSchema,
+        PaginatedResponseSchema,
+        NinjaPaginationResponseSchema,
+        DetailSchema,
+    ],
+)
+def test_response_schemas_generic_patch(generic_schema):
+    new_generic_object = generic_schema[int]
+    assert hasattr(new_generic_object, "__generic_model__")
+    assert new_generic_object.__generic_model__ == generic_schema
+    assert new_generic_object == generic_schema[int]