Add tests of the sort argument

Author: CaselIT

graphene_sqlalchemy/tests/test_fields.py

@@ -0,0 +1,25 @@
+from ..fields import SQLAlchemyConnectionField
+from ..types import SQLAlchemyObjectType
+from ..utils import sort_argument_for_model
+from .models import Pet as PetModel, Editor
+
+
+class Pet(SQLAlchemyObjectType):
+    class Meta:
+        model = PetModel
+
+
+def test_sort_added_by_default():
+    arg = SQLAlchemyConnectionField(Pet)
+    assert 'sort' in arg.args
+    assert arg.args['sort'] == sort_argument_for_model(PetModel)
+
+
+def test_sort_can_be_removed():
+    arg = SQLAlchemyConnectionField(Pet, sort=None)
+    assert 'sort' not in arg.args
+
+
+def test_custom_sort():
+    arg = SQLAlchemyConnectionField(Pet, sort=sort_argument_for_model(Editor))
+    assert arg.args['sort'] == sort_argument_for_model(Editor)

graphene_sqlalchemy/tests/test_query.py

@@ -8,6 +8,7 @@
 from ..registry import reset_global_registry
 from ..fields import SQLAlchemyConnectionField
 from ..types import SQLAlchemyObjectType
+from ..utils import sort_argument_for_model, sort_enum_for_model
 from .models import Article, Base, Editor, Pet, Reporter
 
 db = create_engine('sqlite:///test_sqlalchemy.sqlite3')
@@ -365,3 +366,147 @@ class Mutation(graphene.ObjectType):
     result = schema.execute(query, context_value={'session': session})
     assert not result.errors
     assert result.data == expected
+
+
+def sort_setup(session):
+    pets = [
+        Pet(id=2, name='Lassie', pet_kind='dog'),
+        Pet(id=22, name='Alf', pet_kind='cat'),
+        Pet(id=3, name='Barf', pet_kind='dog')
+    ]
+    session.add_all(pets)
+    session.commit()
+
+
+def test_sort(session):
+    sort_setup(session)
+
+    class PetNode(SQLAlchemyObjectType):
+        class Meta:
+            model = Pet
+            interfaces = (Node, )
+
+    class Query(graphene.ObjectType):
+        defaultSort = SQLAlchemyConnectionField(PetNode)
+        nameSort = SQLAlchemyConnectionField(PetNode)
+        multipleSort = SQLAlchemyConnectionField(PetNode)
+        descSort = SQLAlchemyConnectionField(PetNode)
+        singleColumnSort = SQLAlchemyConnectionField(
+            PetNode, sort=graphene.Argument(sort_enum_for_model(Pet)))
+        noDefaultSort = SQLAlchemyConnectionField(
+            PetNode, sort=sort_argument_for_model(Pet, False))
+        noSort = SQLAlchemyConnectionField(PetNode, sort=None)
+
+    query = '''
+        query sortTest {
+            defaultSort{
+                edges{
+                    node{
+                        id
+                    }
+                }
+            }
+            nameSort(sort: name_asc){
+                edges{
+                    node{
+                        name
+                    }
+                }
+            }
+            multipleSort(sort: [pet_kind_asc, name_desc]){
+                edges{
+                    node{
+                        name
+                        petKind
+                    }
+                }
+            }
+            descSort(sort: [name_desc]){
+                edges{
+                    node{
+                        name
+                    }
+                }
+            }
+            singleColumnSort(sort: name_desc){
+                edges{
+                    node{
+                        name
+                    }
+                }
+            }
+            noDefaultSort(sort: name_asc){
+                edges{
+                    node{
+                        name
+                    }
+                }
+            }
+        }
+    '''
+
+    def makeNodes(nodeList):
+        nodes = [{'node': item} for item in nodeList]
+        return {'edges': nodes}
+
+    expected = {
+        'defaultSort': makeNodes([{'id': 'UGV0Tm9kZToy'}, {'id': 'UGV0Tm9kZToz'}, {'id': 'UGV0Tm9kZToyMg=='}]),
+        'nameSort': makeNodes([{'name': 'Alf'}, {'name': 'Barf'}, {'name': 'Lassie'}]),
+        'noDefaultSort': makeNodes([{'name': 'Alf'}, {'name': 'Barf'}, {'name': 'Lassie'}]),
+        'multipleSort': makeNodes([
+            {'name': 'Alf', 'petKind': 'cat'},
+            {'name': 'Lassie', 'petKind': 'dog'},
+            {'name': 'Barf', 'petKind': 'dog'}
+        ]),
+        'descSort': makeNodes([{'name': 'Lassie'}, {'name': 'Barf'}, {'name': 'Alf'}]),
+        'singleColumnSort': makeNodes([{'name': 'Lassie'}, {'name': 'Barf'}, {'name': 'Alf'}]),
+    }  # yapf: disable
+
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query, context_value={'session': session})
+    assert not result.errors
+    assert result.data == expected
+
+    queryError = '''
+        query sortTest {
+            singleColumnSort(sort: [pet_kind_asc, name_desc]){
+                edges{
+                    node{
+                        name
+                    }
+                }
+            }
+        }
+    '''
+    result = schema.execute(queryError, context_value={'session': session})
+    assert result.errors is not None
+
+    queryNoSort = '''
+        query sortTest {
+            noDefaultSort{
+                edges{
+                    node{
+                        name
+                    }
+                }
+            }
+            noSort{
+                edges{
+                    node{
+                        name
+                    }
+                }
+            }
+        }
+    '''
+
+    expectedNoSort = {
+        'noDefaultSort': makeNodes([{'name': 'Alf'}, {'name': 'Barf'}, {'name': 'Lassie'}]),
+        'noSort': makeNodes([{'name': 'Alf'}, {'name': 'Barf'}, {'name': 'Lassie'}]),
+    }  # yapf: disable
+
+    result = schema.execute(queryNoSort, context_value={'session': session})
+    assert not result.errors
+    for key, value in result.data.items():
+        assert set(node['node']['name'] for node in value['edges']) == set(
+            node['node']['name'] for node in expectedNoSort[key]['edges'])

graphene_sqlalchemy/tests/test_utils.py

@@ -1,6 +1,8 @@
-from graphene import ObjectType, Schema, String
+from graphene import Enum, List, ObjectType, Schema, String
+import sqlalchemy as sa
 
-from ..utils import get_session
+from ..utils import get_session, sort_enum_for_model, sort_argument_for_model
+from .models import Pet, Editor
 
 
 def test_get_session():
@@ -22,3 +24,52 @@ def resolve_x(self, info):
     result = schema.execute(query, context_value={'session': session})
     assert not result.errors
     assert result.data['x'] == session
+
+
+def test_sort_enum_for_model():
+    enum = sort_enum_for_model(Pet)
+    assert isinstance(enum, type(Enum))
+    assert str(enum) == 'PetSortEnum'
+    for col in sa.inspect(Pet).columns:
+        assert hasattr(enum, col.name + '_asc')
+        assert hasattr(enum, col.name + '_desc')
+
+
+def test_sort_enum_for_model_custom_naming():
+    enum = sort_enum_for_model(Pet, 'Foo',
+                               lambda n, d: n.upper() + ('A' if d else 'D'))
+    assert str(enum) == 'Foo'
+    for col in sa.inspect(Pet).columns:
+        assert hasattr(enum, col.name.upper() + 'A')
+        assert hasattr(enum, col.name.upper() + 'D')
+
+
+def test_enum_cache():
+    assert sort_enum_for_model(Editor) is sort_enum_for_model(Editor)
+
+
+def test_sort_argument_for_model():
+    arg = sort_argument_for_model(Pet)
+
+    assert isinstance(arg.type, List)
+    assert arg.default_value == [Pet.id.name + '_asc']
+    assert arg.type.of_type == sort_enum_for_model(Pet)
+
+
+def test_sort_argument_for_model_no_default():
+    arg = sort_argument_for_model(Pet, False)
+
+    assert arg.default_value is None
+
+
+def test_sort_argument_for_model_multiple_pk():
+    Base = sa.ext.declarative.declarative_base()
+
+    class MultiplePK(Base):
+        foo = sa.Column(sa.Integer, primary_key=True)
+        bar = sa.Column(sa.Integer, primary_key=True)
+        __tablename__ = 'MultiplePK'
+
+    arg = sort_argument_for_model(MultiplePK)
+    assert set(arg.default_value) == set((MultiplePK.foo.name + '_asc',
+                                          MultiplePK.bar.name + '_asc'))