tests pass

test pass

Author: Julien Nakache

.gitignore

@@ -45,6 +45,7 @@ htmlcov/
 nosetests.xml
 coverage.xml
 *,cover
+.pytest_cache/
 
 # Translations
 *.mo

graphene_sqlalchemy/converter.py

@@ -7,7 +7,7 @@
                       String)
 from graphene.types.json import JSONString
 
-from .fields import createConnectionField
+from .fields import create_connection_field
 
 try:
     from sqlalchemy_utils import ChoiceType, JSONType, ScalarListType, TSVectorType
@@ -35,7 +35,7 @@ def dynamic_type():
             return Field(_type)
         elif direction in (interfaces.ONETOMANY, interfaces.MANYTOMANY):
             if _type._meta.connection:
-                return createConnectionField(_type._meta.connection)
+                return create_connection_field(relationship, registry)
             return Field(List(_type))
 
     return Dynamic(dynamic_type)

graphene_sqlalchemy/fields.py

@@ -1,3 +1,4 @@
+import logging
 from functools import partial
 
 from promise import Promise, is_thenable
@@ -10,6 +11,9 @@
 from .utils import get_query, sort_argument_for_model
 
 
+log = logging.getLogger()
+
+
 class UnsortedSQLAlchemyConnectionField(ConnectionField):
     @property
     def type(self):
@@ -95,18 +99,46 @@ def __init__(self, type, *args, **kwargs):
         super(SQLAlchemyConnectionField, self).__init__(type, *args, **kwargs)
 
 
-__connectionFactory = UnsortedSQLAlchemyConnectionField
+def default_connection_field_factory(relationship, registry):
+    model = relationship.mapper.entity
+    _type = registry.get_type_for_model(model)
+    return UnsortedSQLAlchemyConnectionField(_type._meta.connection)
+
+
+__connection_field_factory =  default_connection_field_factory
 
+def create_connection_field(relationship, registry):
+    return __connection_field_factory(relationship, registry)
 
-def createConnectionField(_type):
-    return __connectionFactory(_type)
+def register_connection_field_factory(connection_factory):
+    global __connection_field_factory
+    __connection_field_factory = connection_factory
 
+def unregister_connection_field_factory():
+    global __connection_field_factory
+    __connection_field_factory = default_connection_field_factory
+
+
+# TODO Remove in next major version
 
 def registerConnectionFieldFactory(factoryMethod):
-    global __connectionFactory
-    __connectionFactory = factoryMethod
+    log.warn(
+        'registerConnectionFieldFactory is deprecated and will be removed in the next '
+        'major version. Use register_connection_field_factory instead.'
+     )
+
+    def old_factory_method_wrapper(relationship, registry):
+        model = relationship.mapper.entity
+        _type = registry.get_type_for_model(model)
+        return factoryMethod(_type)
+
+    register_connection_field_factory(old_factory_method_wrapper) 
 
 
 def unregisterConnectionFieldFactory():
-    global __connectionFactory
-    __connectionFactory = UnsortedSQLAlchemyConnectionField
+    log.warn(
+        'registerConnectionFieldFactory is deprecated and will be removed in the next '
+        'major version. Use unregister_connection_field_factory instead.'
+     )
+     
+    unregister_connection_field_factory()

graphene_sqlalchemy/tests/test_connectionfactory.py

@@ -1,42 +1,69 @@
-import graphene
-from graphene_sqlalchemy.fields import (SQLAlchemyConnectionField,
-                                        registerConnectionFieldFactory,
-                                        unregisterConnectionFieldFactory)
-
-
-def test_register():
-    class LXConnectionField(SQLAlchemyConnectionField):
-        @classmethod
-        def _applyQueryArgs(cls, model, q, args):
-            return q
-
-        @classmethod
-        def connection_resolver(
-            cls, resolver, connection, model, root, args, context, info
-        ):
-            def LXResolver(root, args, context, info):
-                iterable = resolver(root, args, context, info)
-                if iterable is None:
-                    iterable = cls.get_query(model, context, info, args)
-
-                # We accept always a query here. All LX-queries can be filtered and sorted
-                iterable = cls._applyQueryArgs(model, iterable, args)
-                return iterable
-
-            return SQLAlchemyConnectionField.connection_resolver(
-                LXResolver, connection, model, root, args, context, info
-            )
-
-    def createLXConnectionField(table):
-        class LXConnection(graphene.relay.Connection):
-            class Meta:
-                node = table
-
-        return LXConnectionField(
-            LXConnection,
-            filter=table.filter(),
-            order_by=graphene.List(of_type=table.order_by),
-        )
-
-    registerConnectionFieldFactory(createLXConnectionField)
+from graphene_sqlalchemy.fields import (
+    SQLAlchemyConnectionField,
+    register_connection_field_factory,
+    unregister_connection_field_factory,
+    registerConnectionFieldFactory,
+    unregisterConnectionFieldFactory,
+)
+from graphene_sqlalchemy.types import SQLAlchemyObjectType
+from graphene_sqlalchemy.tests.models import Article, Reporter
+from graphene_sqlalchemy.registry import Registry
+from graphene import Connection, Node
+
+
+def define_types():
+    _registry = Registry()
+
+    class ReporterType(SQLAlchemyObjectType):
+        class Meta:
+            model = Reporter
+            registry = _registry
+            interfaces = (Node,)
+
+
+    class ArticleType(SQLAlchemyObjectType):
+        class Meta:
+            model = Article
+            registry = _registry
+            interfaces = (Node,)
+
+    return {
+        'ReporterType': ReporterType,
+        'ArticleType': ArticleType,
+    }
+
+
+def test_register_connection_field_factory():
+    def connection_field_factory(relationship, registry):
+        model = relationship.mapper.entity
+        _type = registry.get_type_for_model(model)
+        return SQLAlchemyConnectionField(_type._meta.connection)
+
+    register_connection_field_factory(connection_field_factory)
+
+    types = define_types()
+
+    assert isinstance(types['ReporterType']._meta.fields['articles'].type(), SQLAlchemyConnectionField)
+
+
+def test_unregister_connection_field_factory():
+    register_connection_field_factory(lambda: None)
+    unregister_connection_field_factory()
+
+    types = define_types()
+
+    assert not isinstance(types['ReporterType']._meta.fields['articles'].type(), SQLAlchemyConnectionField)
+
+
+def test_deprecated_registerConnectionFieldFactory():
+    registerConnectionFieldFactory(SQLAlchemyConnectionField)
+    types = define_types()
+    assert isinstance(types['ReporterType']._meta.fields['articles'].type(), SQLAlchemyConnectionField)
+
+
+def test_deprecated_unregisterConnectionFieldFactory():
+    registerConnectionFieldFactory(SQLAlchemyConnectionField)
     unregisterConnectionFieldFactory()
+    types = define_types()
+
+    assert not isinstance(types['ReporterType']._meta.fields['articles'].type(), SQLAlchemyConnectionField)

setup.py

@@ -56,6 +56,7 @@
     ],
     keywords="api graphql protocol rest relay graphene",
     packages=find_packages(exclude=["tests"]),
+<<<<<<< HEAD
     install_requires=requirements,
     extras_require={
         "dev": [
@@ -66,4 +67,13 @@
         "test": tests_require,
     },
     tests_require=tests_require,
+=======
+    install_requires=[
+        "six>=1.10.0",
+        "graphene>=2.1.3",
+        "SQLAlchemy",
+        "singledispatch>=3.4.0.3",
+    ],
+    tests_require=["pytest>=2.7.2", "mock", "sqlalchemy_utils", "enum34"],
+>>>>>>> tests pass
 )