Improve test coverage

Signed-off-by: Erik Wrede <[email protected]>

Author: erikwrede

graphene_sqlalchemy/converter.py

@@ -307,6 +307,12 @@ def convert_sqlalchemy_hybrid_property_type(arg: Any):
     if existing_graphql_type:
         return existing_graphql_type
 
+    if isinstance(arg, type(graphene.ObjectType)):
+        return arg
+
+    if isinstance(arg, type(graphene.Scalar)):
+        return arg
+
     # No valid type found, warn and fall back to graphene.String
     warnings.warn(
         (f"I don't know how to generate a GraphQL type out of a \"{arg}\" type."
@@ -407,7 +413,7 @@ def convert_sqlalchemy_hybrid_property_union(arg):
         return graphene_types[0]
 
     # Now check if every type is instance of an ObjectType
-    if not all(isinstance(graphene_type, graphene.ObjectType) for graphene_type in graphene_types):
+    if not all(isinstance(graphene_type, type(graphene.ObjectType)) for graphene_type in graphene_types):
         raise ValueError("Cannot convert hybrid_property Union to graphene.Union: the Union contains scalars. "
                          "Please add the corresponding hybrid_property to the excluded fields in the ObjectType, "
                          "or use an ORMField to override this behaviour.")

graphene_sqlalchemy/registry.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import List
+from typing import List, Type
 
 from sqlalchemy.types import Enum as SQLAlchemyEnumType
 
@@ -89,22 +89,22 @@ def register_sort_enum(self, obj_type, sort_enum: Enum):
     def get_sort_enum_for_object_type(self, obj_type: graphene.ObjectType):
         return self._registry_sort_enums.get(obj_type)
 
-    def register_union_type(self, union: graphene.Union, obj_types: List[graphene.ObjectType]):
+    def register_union_type(self, union: graphene.Union, obj_types: List[Type[graphene.ObjectType]]):
         if not isinstance(union, graphene.Union):
             raise TypeError(
                 "Expected graphene.Union, but got: {!r}".format(union)
             )
 
         for obj_type in obj_types:
-            if not isinstance(obj_type, graphene.ObjectType):
+            if not isinstance(obj_type, type(graphene.ObjectType)):
                 raise TypeError(
                     "Expected Graphene ObjectType, but got: {!r}".format(obj_type)
                 )
 
-        self._registry_enums[tuple(sorted(obj_types))] = union
+        self._registry_unions[frozenset(obj_types)] = union
 
-    def get_union_for_object_types(self, obj_types: List[graphene.ObjectType]):
-        self._registry_unions.get(tuple(sorted(obj_types)))
+    def get_union_for_object_types(self, obj_types : List[Type[graphene.ObjectType]]):
+        return self._registry_unions.get(frozenset(obj_types))
 
 
 registry = None

graphene_sqlalchemy/tests/test_converter.py

@@ -15,7 +15,6 @@
 import graphene
 from graphene.types.structures import Structure
 
-
 from ..converter import (convert_sqlalchemy_column,
                          convert_sqlalchemy_composite,
                          convert_sqlalchemy_hybrid_method,
@@ -94,11 +93,63 @@ def prop_method() -> int | None:
 
 
 @pytest.mark.skipif(sys.version_info < (3, 10), reason="|-Style Unions are unsupported in python < 3.10")
-def test_should_unknown_sqlalchemy_field_raise_exception_310():
-    re_err = "Don't know how to convert the SQLAlchemy field"
-    with pytest.raises(Exception, match=re_err):
-        # support legacy Binary type and subsequent LargeBinary
-        get_field(getattr(types, 'LargeBinary', types.BINARY)())
+def test_should_union_work_310():
+    reg = Registry()
+
+    class PetType(SQLAlchemyObjectType):
+        class Meta:
+            model = Pet
+            registry = reg
+
+    class ShoppingCartType(SQLAlchemyObjectType):
+        class Meta:
+            model = ShoppingCartItem
+            registry = reg
+
+    @hybrid_property
+    def prop_method() -> Union[PetType, ShoppingCartType]:
+        return None
+
+    @hybrid_property
+    def prop_method_2() -> Union[ShoppingCartType, PetType]:
+        return None
+
+    field_type_1 = get_hybrid_property_type(prop_method).type
+    field_type_2 = get_hybrid_property_type(prop_method_2).type
+
+    assert isinstance(field_type_1, graphene.Union)
+    assert field_type_1 is field_type_2
+
+    # TODO verify types of the union
+
+
+@pytest.mark.skipif(sys.version_info < (3, 10), reason="|-Style Unions are unsupported in python < 3.10")
+def test_should_union_work_310():
+    reg = Registry()
+
+    class PetType(SQLAlchemyObjectType):
+        class Meta:
+            model = Pet
+            registry = reg
+
+    class ShoppingCartType(SQLAlchemyObjectType):
+        class Meta:
+            model = ShoppingCartItem
+            registry = reg
+
+    @hybrid_property
+    def prop_method() -> PetType | ShoppingCartType:
+        return None
+
+    @hybrid_property
+    def prop_method_2() -> ShoppingCartType | PetType:
+        return None
+
+    field_type_1 = get_hybrid_property_type(prop_method).type
+    field_type_2 = get_hybrid_property_type(prop_method_2).type
+
+    assert isinstance(field_type_1, graphene.Union)
+    assert field_type_1 is field_type_2
 
 
 def test_should_datetime_convert_datetime():
@@ -129,6 +180,30 @@ def test_should_unicodetext_convert_string():
     assert get_field(types.UnicodeText()).type == graphene.String
 
 
+def test_should_tsvector_convert_string():
+    assert get_field(sqa_utils.TSVectorType()).type == graphene.String
+
+
+def test_should_email_convert_string():
+    assert get_field(sqa_utils.EmailType()).type == graphene.String
+
+
+def test_should_URL_convert_string():
+    assert get_field(sqa_utils.URLType()).type == graphene.String
+
+
+def test_should_IPaddress_convert_string():
+    assert get_field(sqa_utils.IPAddressType()).type == graphene.String
+
+
+def test_should_inet_convert_string():
+    assert get_field(postgresql.INET()).type == graphene.String
+
+
+def test_should_cidr_convert_string():
+    assert get_field(postgresql.CIDR()).type == graphene.String
+
+
 def test_should_enum_convert_enum():
     field = get_field(types.Enum(enum.Enum("TwoNumbers", ("one", "two"))))
     field_type = field.type()

graphene_sqlalchemy/tests/test_registry.py

@@ -2,11 +2,12 @@
 from sqlalchemy.types import Enum as SQLAlchemyEnum
 
 from graphene import Enum as GrapheneEnum
+import graphene
 
 from ..registry import Registry
 from ..types import SQLAlchemyObjectType
 from ..utils import EnumValue
-from .models import Pet
+from .models import Pet, Reporter
 
 
 def test_register_object_type():
@@ -126,3 +127,56 @@ class Meta:
     re_err = r"Expected Graphene Enum, but got: .*PetType.*"
     with pytest.raises(TypeError, match=re_err):
         reg.register_sort_enum(PetType, PetType)
+
+
+def test_register_union():
+    reg = Registry()
+
+    class PetType(SQLAlchemyObjectType):
+        class Meta:
+            model = Pet
+            registry = reg
+
+    class ReporterType(SQLAlchemyObjectType):
+        class Meta:
+            model = Reporter
+
+    union_types = [PetType, ReporterType]
+    union = graphene.Union('ReporterPet', tuple(union_types))
+
+    reg.register_union_type(union, union_types)
+
+    assert reg.get_union_for_object_types(union_types) == union
+    # Order should no matter
+    assert reg.get_union_for_object_types([ReporterType, PetType]) == union
+
+
+def test_register_union_scalar():
+    reg = Registry()
+
+    union_types = [graphene.String, graphene.Int]
+    union = graphene.Union('StringInt', tuple(union_types))
+
+    re_err = r"Expected Graphene ObjectType, but got: .*String.*"
+    with pytest.raises(TypeError, match=re_err):
+        reg.register_union_type(union, union_types)
+
+
+def test_register_union_incorrect_types():
+    reg = Registry()
+
+    class PetType(SQLAlchemyObjectType):
+        class Meta:
+            model = Pet
+            registry = reg
+
+    class ReporterType(SQLAlchemyObjectType):
+        class Meta:
+            model = Reporter
+
+    union_types = [PetType, ReporterType]
+    union = PetType
+
+    re_err = r"Expected graphene.Union, but got: .*PetType.*"
+    with pytest.raises(TypeError, match=re_err):
+        reg.register_union_type(union, union_types)