From d6dd67e388b58247dd4a03c29bf6e625d6e4e230 Mon Sep 17 00:00:00 2001 From: Ricardo Madriz Date: Mon, 20 Sep 2021 21:53:03 -0600 Subject: [PATCH] Graphene v3 (tests) (#317) Co-authored-by: Jonathan Ehwald Co-authored-by: Zbigniew Siciarz Co-authored-by: Cole Lin --- .github/workflows/tests.yml | 50 +++---- .gitignore | 3 + graphene_sqlalchemy/__init__.py | 2 +- graphene_sqlalchemy/batching.py | 49 +++++-- graphene_sqlalchemy/converter.py | 17 ++- graphene_sqlalchemy/enums.py | 3 +- graphene_sqlalchemy/fields.py | 66 +++++---- graphene_sqlalchemy/registry.py | 3 +- graphene_sqlalchemy/tests/conftest.py | 2 +- graphene_sqlalchemy/tests/test_batching.py | 138 ++++++------------ graphene_sqlalchemy/tests/test_benchmark.py | 10 +- graphene_sqlalchemy/tests/test_converter.py | 2 +- graphene_sqlalchemy/tests/test_query_enums.py | 4 +- graphene_sqlalchemy/tests/test_sort_enums.py | 2 +- graphene_sqlalchemy/tests/test_types.py | 8 +- graphene_sqlalchemy/tests/utils.py | 9 +- graphene_sqlalchemy/types.py | 8 +- graphene_sqlalchemy/utils.py | 6 + setup.cfg | 2 +- setup.py | 26 ++-- tox.ini | 6 +- 21 files changed, 196 insertions(+), 220 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 4adb26f6..a9a3bd5d 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -8,31 +8,31 @@ jobs: strategy: max-parallel: 10 matrix: - sql-alchemy: ["1.2", "1.3"] + sql-alchemy: ["1.2", "1.3", "1.4"] python-version: ["3.6", "3.7", "3.8", "3.9"] steps: - - uses: actions/checkout@v2 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install tox tox-gh-actions - - name: Test with tox - run: tox - env: - SQLALCHEMY: ${{ matrix.sql-alchemy }} - TOXENV: ${{ matrix.toxenv }} - - name: Upload coverage.xml - if: ${{ matrix.sql-alchemy == '1.3' && matrix.python-version == '3.9' }} - uses: actions/upload-artifact@v2 - with: - name: graphene-sqlalchemy-coverage - path: coverage.xml - if-no-files-found: error - - name: Upload coverage.xml to codecov - if: ${{ matrix.sql-alchemy == '1.3' && matrix.python-version == '3.9' }} - uses: codecov/codecov-action@v1 \ No newline at end of file + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install tox tox-gh-actions + - name: Test with tox + run: tox + env: + SQLALCHEMY: ${{ matrix.sql-alchemy }} + TOXENV: ${{ matrix.toxenv }} + - name: Upload coverage.xml + if: ${{ matrix.sql-alchemy == '1.4' && matrix.python-version == '3.9' }} + uses: actions/upload-artifact@v2 + with: + name: graphene-sqlalchemy-coverage + path: coverage.xml + if-no-files-found: error + - name: Upload coverage.xml to codecov + if: ${{ matrix.sql-alchemy == '1.4' && matrix.python-version == '3.9' }} + uses: codecov/codecov-action@v1 diff --git a/.gitignore b/.gitignore index a97b8c21..c4a735fe 100644 --- a/.gitignore +++ b/.gitignore @@ -69,3 +69,6 @@ target/ # Databases *.sqlite3 .vscode + +# mypy cache +.mypy_cache/ diff --git a/graphene_sqlalchemy/__init__.py b/graphene_sqlalchemy/__init__.py index 3945d506..060bd13b 100644 --- a/graphene_sqlalchemy/__init__.py +++ b/graphene_sqlalchemy/__init__.py @@ -2,7 +2,7 @@ from .fields import SQLAlchemyConnectionField from .utils import get_query, get_session -__version__ = "2.3.0" +__version__ = "3.0.0b1" __all__ = [ "__version__", diff --git a/graphene_sqlalchemy/batching.py b/graphene_sqlalchemy/batching.py index baf01deb..85cc8855 100644 --- a/graphene_sqlalchemy/batching.py +++ b/graphene_sqlalchemy/batching.py @@ -1,8 +1,10 @@ +import aiodataloader import sqlalchemy -from promise import dataloader, promise from sqlalchemy.orm import Session, strategies from sqlalchemy.orm.query import QueryContext +from .utils import is_sqlalchemy_version_less_than + def get_batch_resolver(relationship_prop): @@ -10,10 +12,10 @@ def get_batch_resolver(relationship_prop): # This is so SQL string generation is cached under-the-hood via `bakery` selectin_loader = strategies.SelectInLoader(relationship_prop, (('lazy', 'selectin'),)) - class RelationshipLoader(dataloader.DataLoader): + class RelationshipLoader(aiodataloader.DataLoader): cache = False - def batch_load_fn(self, parents): # pylint: disable=method-hidden + async def batch_load_fn(self, parents): """ Batch loads the relationships of all the parents as one SQL statement. @@ -52,21 +54,36 @@ def batch_load_fn(self, parents): # pylint: disable=method-hidden states = [(sqlalchemy.inspect(parent), True) for parent in parents] # For our purposes, the query_context will only used to get the session - query_context = QueryContext(session.query(parent_mapper.entity)) - - selectin_loader._load_for_path( - query_context, - parent_mapper._path_registry, - states, - None, - child_mapper, - ) - - return promise.Promise.resolve([getattr(parent, relationship_prop.key) for parent in parents]) + query_context = None + if is_sqlalchemy_version_less_than('1.4'): + query_context = QueryContext(session.query(parent_mapper.entity)) + else: + parent_mapper_query = session.query(parent_mapper.entity) + query_context = parent_mapper_query._compile_context() + + if is_sqlalchemy_version_less_than('1.4'): + selectin_loader._load_for_path( + query_context, + parent_mapper._path_registry, + states, + None, + child_mapper + ) + else: + selectin_loader._load_for_path( + query_context, + parent_mapper._path_registry, + states, + None, + child_mapper, + None + ) + + return [getattr(parent, relationship_prop.key) for parent in parents] loader = RelationshipLoader() - def resolve(root, info, **args): - return loader.load(root) + async def resolve(root, info, **args): + return await loader.load(root) return resolve diff --git a/graphene_sqlalchemy/converter.py b/graphene_sqlalchemy/converter.py index f4b805e2..1720e3d8 100644 --- a/graphene_sqlalchemy/converter.py +++ b/graphene_sqlalchemy/converter.py @@ -1,6 +1,5 @@ -from enum import EnumMeta +from functools import singledispatch -from singledispatch import singledispatch from sqlalchemy import types from sqlalchemy.dialects import postgresql from sqlalchemy.orm import interfaces, strategies @@ -21,6 +20,11 @@ except ImportError: ChoiceType = JSONType = ScalarListType = TSVectorType = object +try: + from sqlalchemy_utils.types.choice import EnumTypeImpl +except ImportError: + EnumTypeImpl = object + is_selectin_available = getattr(strategies, 'SelectInLoader', None) @@ -110,9 +114,9 @@ def _convert_o2m_or_m2m_relationship(relationship_prop, obj_type, batching, conn def convert_sqlalchemy_hybrid_method(hybrid_prop, resolver, **field_kwargs): - if 'type' not in field_kwargs: + if 'type_' not in field_kwargs: # TODO The default type should be dependent on the type of the property propety. - field_kwargs['type'] = String + field_kwargs['type_'] = String return Field( resolver=resolver, @@ -156,7 +160,8 @@ def inner(fn): def convert_sqlalchemy_column(column_prop, registry, resolver, **field_kwargs): column = column_prop.columns[0] - field_kwargs.setdefault('type', convert_sqlalchemy_type(getattr(column, "type", None), column, registry)) + + field_kwargs.setdefault('type_', convert_sqlalchemy_type(getattr(column, "type", None), column, registry)) field_kwargs.setdefault('required', not is_column_nullable(column)) field_kwargs.setdefault('description', get_column_doc(column)) @@ -221,7 +226,7 @@ def convert_enum_to_enum(type, column, registry=None): @convert_sqlalchemy_type.register(ChoiceType) def convert_choice_to_enum(type, column, registry=None): name = "{}_{}".format(column.table.name, column.name).upper() - if isinstance(type.choices, EnumMeta): + if isinstance(type.type_impl, EnumTypeImpl): # type.choices may be Enum/IntEnum, in ChoiceType both presented as EnumMeta # do not use from_enum here because we can have more than one enum column in table return Enum(name, list((v.name, v.value) for v in type.choices)) diff --git a/graphene_sqlalchemy/enums.py b/graphene_sqlalchemy/enums.py index 0adea107..f100be19 100644 --- a/graphene_sqlalchemy/enums.py +++ b/graphene_sqlalchemy/enums.py @@ -1,4 +1,3 @@ -import six from sqlalchemy.orm import ColumnProperty from sqlalchemy.types import Enum as SQLAlchemyEnumType @@ -63,7 +62,7 @@ def enum_for_field(obj_type, field_name): if not isinstance(obj_type, type) or not issubclass(obj_type, SQLAlchemyObjectType): raise TypeError( "Expected SQLAlchemyObjectType, but got: {!r}".format(obj_type)) - if not field_name or not isinstance(field_name, six.string_types): + if not field_name or not isinstance(field_name, str): raise TypeError( "Expected a field name, but got: {!r}".format(field_name)) registry = obj_type._meta.registry diff --git a/graphene_sqlalchemy/fields.py b/graphene_sqlalchemy/fields.py index 780fcbf0..a22a3ae7 100644 --- a/graphene_sqlalchemy/fields.py +++ b/graphene_sqlalchemy/fields.py @@ -1,17 +1,18 @@ +import enum import warnings from functools import partial -import six from promise import Promise, is_thenable from sqlalchemy.orm.query import Query from graphene import NonNull from graphene.relay import Connection, ConnectionField -from graphene.relay.connection import PageInfo -from graphql_relay.connection.arrayconnection import connection_from_list_slice +from graphene.relay.connection import connection_adapter, page_info_adapter +from graphql_relay.connection.arrayconnection import \ + connection_from_array_slice from .batching import get_batch_resolver -from .utils import get_query +from .utils import EnumValue, get_query class UnsortedSQLAlchemyConnectionField(ConnectionField): @@ -19,10 +20,10 @@ class UnsortedSQLAlchemyConnectionField(ConnectionField): def type(self): from .types import SQLAlchemyObjectType - _type = super(ConnectionField, self).type - nullable_type = get_nullable_type(_type) + type_ = super(ConnectionField, self).type + nullable_type = get_nullable_type(type_) if issubclass(nullable_type, Connection): - return _type + return type_ assert issubclass(nullable_type, SQLAlchemyObjectType), ( "SQLALchemyConnectionField only accepts SQLAlchemyObjectType types, not {}" ).format(nullable_type.__name__) @@ -31,7 +32,7 @@ def type(self): ), "The type {} doesn't have a connection".format( nullable_type.__name__ ) - assert _type == nullable_type, ( + assert type_ == nullable_type, ( "Passing a SQLAlchemyObjectType instance is deprecated. " "Pass the connection type instead accessible via SQLAlchemyObjectType.connection" ) @@ -53,15 +54,19 @@ def resolve_connection(cls, connection_type, model, info, args, resolved): _len = resolved.count() else: _len = len(resolved) - connection = connection_from_list_slice( - resolved, - args, + + def adjusted_connection_adapter(edges, pageInfo): + return connection_adapter(connection_type, edges, pageInfo) + + connection = connection_from_array_slice( + array_slice=resolved, + args=args, slice_start=0, - list_length=_len, - list_slice_length=_len, - connection_type=connection_type, - pageinfo_type=PageInfo, + array_length=_len, + array_slice_length=_len, + connection_type=adjusted_connection_adapter, edge_type=connection_type.Edge, + page_info_type=page_info_adapter, ) connection.iterable = resolved connection.length = _len @@ -77,7 +82,7 @@ def connection_resolver(cls, resolver, connection_type, model, root, info, **arg return on_resolve(resolved) - def get_resolver(self, parent_resolver): + def wrap_resolve(self, parent_resolver): return partial( self.connection_resolver, parent_resolver, @@ -88,8 +93,8 @@ def get_resolver(self, parent_resolver): # TODO Rename this to SortableSQLAlchemyConnectionField class SQLAlchemyConnectionField(UnsortedSQLAlchemyConnectionField): - def __init__(self, type, *args, **kwargs): - nullable_type = get_nullable_type(type) + def __init__(self, type_, *args, **kwargs): + nullable_type = get_nullable_type(type_) if "sort" not in kwargs and issubclass(nullable_type, Connection): # Let super class raise if type is not a Connection try: @@ -103,16 +108,25 @@ def __init__(self, type, *args, **kwargs): ) elif "sort" in kwargs and kwargs["sort"] is None: del kwargs["sort"] - super(SQLAlchemyConnectionField, self).__init__(type, *args, **kwargs) + super(SQLAlchemyConnectionField, self).__init__(type_, *args, **kwargs) @classmethod def get_query(cls, model, info, sort=None, **args): query = get_query(model, info.context) if sort is not None: - if isinstance(sort, six.string_types): - query = query.order_by(sort.value) - else: - query = query.order_by(*(col.value for col in sort)) + if not isinstance(sort, list): + sort = [sort] + sort_args = [] + # ensure consistent handling of graphene Enums, enum values and + # plain strings + for item in sort: + if isinstance(item, enum.Enum): + sort_args.append(item.value.value) + elif isinstance(item, EnumValue): + sort_args.append(item.value) + else: + sort_args.append(item) + query = query.order_by(*sort_args) return query @@ -123,7 +137,7 @@ class BatchSQLAlchemyConnectionField(UnsortedSQLAlchemyConnectionField): Use at your own risk. """ - def get_resolver(self, parent_resolver): + def wrap_resolve(self, parent_resolver): return partial( self.connection_resolver, self.resolver, @@ -148,13 +162,13 @@ def default_connection_field_factory(relationship, registry, **field_kwargs): __connectionFactory = UnsortedSQLAlchemyConnectionField -def createConnectionField(_type, **field_kwargs): +def createConnectionField(type_, **field_kwargs): warnings.warn( 'createConnectionField is deprecated and will be removed in the next ' 'major version. Use SQLAlchemyObjectType.Meta.connection_field_factory instead.', DeprecationWarning, ) - return __connectionFactory(_type, **field_kwargs) + return __connectionFactory(type_, **field_kwargs) def registerConnectionFieldFactory(factoryMethod): diff --git a/graphene_sqlalchemy/registry.py b/graphene_sqlalchemy/registry.py index c20bc2ca..acfa744b 100644 --- a/graphene_sqlalchemy/registry.py +++ b/graphene_sqlalchemy/registry.py @@ -1,6 +1,5 @@ from collections import defaultdict -import six from sqlalchemy.types import Enum as SQLAlchemyEnumType from graphene import Enum @@ -43,7 +42,7 @@ def register_orm_field(self, obj_type, field_name, orm_field): raise TypeError( "Expected SQLAlchemyObjectType, but got: {!r}".format(obj_type) ) - if not field_name or not isinstance(field_name, six.string_types): + if not field_name or not isinstance(field_name, str): raise TypeError("Expected a field name, but got: {!r}".format(field_name)) self._registry_orm_fields[obj_type][field_name] = orm_field diff --git a/graphene_sqlalchemy/tests/conftest.py b/graphene_sqlalchemy/tests/conftest.py index 98515051..34ba9d8a 100644 --- a/graphene_sqlalchemy/tests/conftest.py +++ b/graphene_sqlalchemy/tests/conftest.py @@ -22,7 +22,7 @@ def convert_composite_class(composite, registry): return graphene.Field(graphene.Int) -@pytest.yield_fixture(scope="function") +@pytest.fixture(scope="function") def session_factory(): engine = create_engine(test_db_url) Base.metadata.create_all(engine) diff --git a/graphene_sqlalchemy/tests/test_batching.py b/graphene_sqlalchemy/tests/test_batching.py index fc646a3c..1896900b 100644 --- a/graphene_sqlalchemy/tests/test_batching.py +++ b/graphene_sqlalchemy/tests/test_batching.py @@ -1,3 +1,4 @@ +import ast import contextlib import logging @@ -9,8 +10,9 @@ from ..fields import (BatchSQLAlchemyConnectionField, default_connection_field_factory) from ..types import ORMField, SQLAlchemyObjectType +from ..utils import is_sqlalchemy_version_less_than from .models import Article, HairKind, Pet, Reporter -from .utils import is_sqlalchemy_version_less_than, to_std_dicts +from .utils import remove_cache_miss_stat, to_std_dicts class MockLoggingHandler(logging.Handler): @@ -75,7 +77,8 @@ def resolve_reporters(self, info): pytest.skip('SQL batching only works for SQLAlchemy 1.2+', allow_module_level=True) -def test_many_to_one(session_factory): +@pytest.mark.asyncio +async def test_many_to_one(session_factory): session = session_factory() reporter_1 = Reporter( @@ -103,7 +106,7 @@ def test_many_to_one(session_factory): with mock_sqlalchemy_logging_handler() as sqlalchemy_logging_handler: # Starts new session to fully reset the engine / connection logging level session = session_factory() - result = schema.execute(""" + result = await schema.execute_async(""" query { articles { headline @@ -125,26 +128,12 @@ def test_many_to_one(session_factory): assert len(sql_statements) == 1 return - assert messages == [ - 'BEGIN (implicit)', - - 'SELECT articles.id AS articles_id, ' - 'articles.headline AS articles_headline, ' - 'articles.pub_date AS articles_pub_date, ' - 'articles.reporter_id AS articles_reporter_id \n' - 'FROM articles', - '()', - - 'SELECT reporters.id AS reporters_id, ' - '(SELECT CAST(count(reporters.id) AS INTEGER) AS anon_2 \nFROM reporters) AS anon_1, ' - 'reporters.first_name AS reporters_first_name, ' - 'reporters.last_name AS reporters_last_name, ' - 'reporters.email AS reporters_email, ' - 'reporters.favorite_pet_kind AS reporters_favorite_pet_kind \n' - 'FROM reporters \n' - 'WHERE reporters.id IN (?, ?)', - '(1, 2)', - ] + if not is_sqlalchemy_version_less_than('1.4'): + messages[2] = remove_cache_miss_stat(messages[2]) + messages[4] = remove_cache_miss_stat(messages[4]) + + assert ast.literal_eval(messages[2]) == () + assert sorted(ast.literal_eval(messages[4])) == [1, 2] assert not result.errors result = to_std_dicts(result.data) @@ -166,7 +155,8 @@ def test_many_to_one(session_factory): } -def test_one_to_one(session_factory): +@pytest.mark.asyncio +async def test_one_to_one(session_factory): session = session_factory() reporter_1 = Reporter( @@ -194,7 +184,7 @@ def test_one_to_one(session_factory): with mock_sqlalchemy_logging_handler() as sqlalchemy_logging_handler: # Starts new session to fully reset the engine / connection logging level session = session_factory() - result = schema.execute(""" + result = await schema.execute_async(""" query { reporters { firstName @@ -216,26 +206,12 @@ def test_one_to_one(session_factory): assert len(sql_statements) == 1 return - assert messages == [ - 'BEGIN (implicit)', - - 'SELECT (SELECT CAST(count(reporters.id) AS INTEGER) AS anon_2 \nFROM reporters) AS anon_1, ' - 'reporters.id AS reporters_id, ' - 'reporters.first_name AS reporters_first_name, ' - 'reporters.last_name AS reporters_last_name, ' - 'reporters.email AS reporters_email, ' - 'reporters.favorite_pet_kind AS reporters_favorite_pet_kind \n' - 'FROM reporters', - '()', - - 'SELECT articles.reporter_id AS articles_reporter_id, ' - 'articles.id AS articles_id, ' - 'articles.headline AS articles_headline, ' - 'articles.pub_date AS articles_pub_date \n' - 'FROM articles \n' - 'WHERE articles.reporter_id IN (?, ?)', - '(1, 2)' - ] + if not is_sqlalchemy_version_less_than('1.4'): + messages[2] = remove_cache_miss_stat(messages[2]) + messages[4] = remove_cache_miss_stat(messages[4]) + + assert ast.literal_eval(messages[2]) == () + assert sorted(ast.literal_eval(messages[4])) == [1, 2] assert not result.errors result = to_std_dicts(result.data) @@ -257,7 +233,8 @@ def test_one_to_one(session_factory): } -def test_one_to_many(session_factory): +@pytest.mark.asyncio +async def test_one_to_many(session_factory): session = session_factory() reporter_1 = Reporter( @@ -293,7 +270,7 @@ def test_one_to_many(session_factory): with mock_sqlalchemy_logging_handler() as sqlalchemy_logging_handler: # Starts new session to fully reset the engine / connection logging level session = session_factory() - result = schema.execute(""" + result = await schema.execute_async(""" query { reporters { firstName @@ -319,26 +296,12 @@ def test_one_to_many(session_factory): assert len(sql_statements) == 1 return - assert messages == [ - 'BEGIN (implicit)', - - 'SELECT (SELECT CAST(count(reporters.id) AS INTEGER) AS anon_2 \nFROM reporters) AS anon_1, ' - 'reporters.id AS reporters_id, ' - 'reporters.first_name AS reporters_first_name, ' - 'reporters.last_name AS reporters_last_name, ' - 'reporters.email AS reporters_email, ' - 'reporters.favorite_pet_kind AS reporters_favorite_pet_kind \n' - 'FROM reporters', - '()', - - 'SELECT articles.reporter_id AS articles_reporter_id, ' - 'articles.id AS articles_id, ' - 'articles.headline AS articles_headline, ' - 'articles.pub_date AS articles_pub_date \n' - 'FROM articles \n' - 'WHERE articles.reporter_id IN (?, ?)', - '(1, 2)' - ] + if not is_sqlalchemy_version_less_than('1.4'): + messages[2] = remove_cache_miss_stat(messages[2]) + messages[4] = remove_cache_miss_stat(messages[4]) + + assert ast.literal_eval(messages[2]) == () + assert sorted(ast.literal_eval(messages[4])) == [1, 2] assert not result.errors result = to_std_dicts(result.data) @@ -382,7 +345,8 @@ def test_one_to_many(session_factory): } -def test_many_to_many(session_factory): +@pytest.mark.asyncio +async def test_many_to_many(session_factory): session = session_factory() reporter_1 = Reporter( @@ -420,7 +384,7 @@ def test_many_to_many(session_factory): with mock_sqlalchemy_logging_handler() as sqlalchemy_logging_handler: # Starts new session to fully reset the engine / connection logging level session = session_factory() - result = schema.execute(""" + result = await schema.execute_async(""" query { reporters { firstName @@ -446,31 +410,12 @@ def test_many_to_many(session_factory): assert len(sql_statements) == 1 return - assert messages == [ - 'BEGIN (implicit)', - - 'SELECT (SELECT CAST(count(reporters.id) AS INTEGER) AS anon_2 \nFROM reporters) AS anon_1, ' - 'reporters.id AS reporters_id, ' - 'reporters.first_name AS reporters_first_name, ' - 'reporters.last_name AS reporters_last_name, ' - 'reporters.email AS reporters_email, ' - 'reporters.favorite_pet_kind AS reporters_favorite_pet_kind \n' - 'FROM reporters', - '()', - - 'SELECT reporters_1.id AS reporters_1_id, ' - 'pets.id AS pets_id, ' - 'pets.name AS pets_name, ' - 'pets.pet_kind AS pets_pet_kind, ' - 'pets.hair_kind AS pets_hair_kind, ' - 'pets.reporter_id AS pets_reporter_id \n' - 'FROM reporters AS reporters_1 ' - 'JOIN association AS association_1 ON reporters_1.id = association_1.reporter_id ' - 'JOIN pets ON pets.id = association_1.pet_id \n' - 'WHERE reporters_1.id IN (?, ?) ' - 'ORDER BY pets.id', - '(1, 2)' - ] + if not is_sqlalchemy_version_less_than('1.4'): + messages[2] = remove_cache_miss_stat(messages[2]) + messages[4] = remove_cache_miss_stat(messages[4]) + + assert ast.literal_eval(messages[2]) == () + assert sorted(ast.literal_eval(messages[4])) == [1, 2] assert not result.errors result = to_std_dicts(result.data) @@ -586,7 +531,8 @@ def resolve_reporters(self, info): assert len(select_statements) == 2 -def test_connection_factory_field_overrides_batching_is_false(session_factory): +@pytest.mark.asyncio +async def test_connection_factory_field_overrides_batching_is_false(session_factory): session = session_factory() reporter_1 = Reporter(first_name='Reporter_1') session.add(reporter_1) @@ -620,7 +566,7 @@ def resolve_reporters(self, info): with mock_sqlalchemy_logging_handler() as sqlalchemy_logging_handler: # Starts new session to fully reset the engine / connection logging level session = session_factory() - schema.execute(""" + await schema.execute_async(""" query { reporters { articles { diff --git a/graphene_sqlalchemy/tests/test_benchmark.py b/graphene_sqlalchemy/tests/test_benchmark.py index 1e5ee4f1..11e9d0e0 100644 --- a/graphene_sqlalchemy/tests/test_benchmark.py +++ b/graphene_sqlalchemy/tests/test_benchmark.py @@ -1,13 +1,11 @@ import pytest -from graphql.backend import GraphQLCachedBackend, GraphQLCoreBackend import graphene from graphene import relay -from ..fields import BatchSQLAlchemyConnectionField from ..types import SQLAlchemyObjectType +from ..utils import is_sqlalchemy_version_less_than from .models import Article, HairKind, Pet, Reporter -from .utils import is_sqlalchemy_version_less_than if is_sqlalchemy_version_less_than('1.2'): pytest.skip('SQL batching only works for SQLAlchemy 1.2+', allow_module_level=True) @@ -18,19 +16,16 @@ class ReporterType(SQLAlchemyObjectType): class Meta: model = Reporter interfaces = (relay.Node,) - connection_field_factory = BatchSQLAlchemyConnectionField.from_relationship class ArticleType(SQLAlchemyObjectType): class Meta: model = Article interfaces = (relay.Node,) - connection_field_factory = BatchSQLAlchemyConnectionField.from_relationship class PetType(SQLAlchemyObjectType): class Meta: model = Pet interfaces = (relay.Node,) - connection_field_factory = BatchSQLAlchemyConnectionField.from_relationship class Query(graphene.ObjectType): articles = graphene.Field(graphene.List(ArticleType)) @@ -47,15 +42,12 @@ def resolve_reporters(self, info): def benchmark_query(session_factory, benchmark, query): schema = get_schema() - cached_backend = GraphQLCachedBackend(GraphQLCoreBackend()) - cached_backend.document_from_string(schema, query) # Prime cache @benchmark def execute_query(): result = schema.execute( query, context_value={"session": session_factory()}, - backend=cached_backend, ) assert not result.errors diff --git a/graphene_sqlalchemy/tests/test_converter.py b/graphene_sqlalchemy/tests/test_converter.py index f0fc1802..3196d003 100644 --- a/graphene_sqlalchemy/tests/test_converter.py +++ b/graphene_sqlalchemy/tests/test_converter.py @@ -51,7 +51,7 @@ def test_should_unknown_sqlalchemy_field_raise_exception(): 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)()) + get_field(getattr(types, 'LargeBinary', types.BINARY)()) def test_should_date_convert_string(): diff --git a/graphene_sqlalchemy/tests/test_query_enums.py b/graphene_sqlalchemy/tests/test_query_enums.py index ec585d57..5166c45f 100644 --- a/graphene_sqlalchemy/tests/test_query_enums.py +++ b/graphene_sqlalchemy/tests/test_query_enums.py @@ -32,7 +32,7 @@ def resolve_reporters(self, _info): def resolve_pets(self, _info, kind): query = session.query(Pet) if kind: - query = query.filter_by(pet_kind=kind) + query = query.filter_by(pet_kind=kind.value) return query query = """ @@ -131,7 +131,7 @@ class Query(graphene.ObjectType): def resolve_pet(self, info, kind=None): query = session.query(Pet) if kind: - query = query.filter(Pet.pet_kind == kind) + query = query.filter(Pet.pet_kind == kind.value) return query.first() query = """ diff --git a/graphene_sqlalchemy/tests/test_sort_enums.py b/graphene_sqlalchemy/tests/test_sort_enums.py index d6f6965d..6291d4f8 100644 --- a/graphene_sqlalchemy/tests/test_sort_enums.py +++ b/graphene_sqlalchemy/tests/test_sort_enums.py @@ -354,7 +354,7 @@ def makeNodes(nodeList): """ result = schema.execute(queryError, context_value={"session": session}) assert result.errors is not None - assert '"sort" has invalid value' in result.errors[0].message + assert 'cannot represent non-enum value' in result.errors[0].message queryNoSort = """ query sortTest { diff --git a/graphene_sqlalchemy/tests/test_types.py b/graphene_sqlalchemy/tests/test_types.py index bf563b6e..32f01509 100644 --- a/graphene_sqlalchemy/tests/test_types.py +++ b/graphene_sqlalchemy/tests/test_types.py @@ -1,6 +1,6 @@ -import mock +from unittest import mock + import pytest -import six # noqa F401 from graphene import (Dynamic, Field, GlobalID, Int, List, Node, NonNull, ObjectType, Schema, String) @@ -136,10 +136,10 @@ class Meta: # columns email = ORMField(deprecation_reason='Overridden') - email_v2 = ORMField(model_attr='email', type=Int) + email_v2 = ORMField(model_attr='email', type_=Int) # column_property - column_prop = ORMField(type=String) + column_prop = ORMField(type_=String) # composite composite_prop = ORMField() diff --git a/graphene_sqlalchemy/tests/utils.py b/graphene_sqlalchemy/tests/utils.py index 428757c3..c90ee476 100644 --- a/graphene_sqlalchemy/tests/utils.py +++ b/graphene_sqlalchemy/tests/utils.py @@ -1,4 +1,4 @@ -import pkg_resources +import re def to_std_dicts(value): @@ -11,6 +11,7 @@ def to_std_dicts(value): return value -def is_sqlalchemy_version_less_than(version_string): - """Check the installed SQLAlchemy version""" - return pkg_resources.get_distribution('SQLAlchemy').parsed_version < pkg_resources.parse_version(version_string) +def remove_cache_miss_stat(message): + """Remove the stat from the echoed query message when the cache is missed for sqlalchemy version >= 1.4""" + # https://github.com/sqlalchemy/sqlalchemy/blob/990eb3d8813369d3b8a7776ae85fb33627443d30/lib/sqlalchemy/engine/default.py#L1177 + return re.sub(r"\[generated in \d+.?\d*s\]\s", "", message) diff --git a/graphene_sqlalchemy/types.py b/graphene_sqlalchemy/types.py index ff22cded..72f06c06 100644 --- a/graphene_sqlalchemy/types.py +++ b/graphene_sqlalchemy/types.py @@ -27,7 +27,7 @@ class ORMField(OrderedType): def __init__( self, model_attr=None, - type=None, + type_=None, required=None, description=None, deprecation_reason=None, @@ -49,7 +49,7 @@ class MyType(SQLAlchemyObjectType): class Meta: model = MyModel - id = ORMField(type=graphene.Int) + id = ORMField(type_=graphene.Int) name = ORMField(required=True) -> MyType.id will be of type Int (vs ID). @@ -58,7 +58,7 @@ class Meta: :param str model_attr: Name of the SQLAlchemy model attribute used to resolve this field. Default to the name of the attribute referencing the ORMField. - :param type: + :param type_: Default to the type mapping in converter.py. :param str description: Default to the `doc` attribute of the SQLAlchemy column property. @@ -77,7 +77,7 @@ class Meta: # The is only useful for documentation and auto-completion common_kwargs = { 'model_attr': model_attr, - 'type': type, + 'type_': type_, 'required': required, 'description': description, 'deprecation_reason': deprecation_reason, diff --git a/graphene_sqlalchemy/utils.py b/graphene_sqlalchemy/utils.py index 7139eefc..b30c0eb4 100644 --- a/graphene_sqlalchemy/utils.py +++ b/graphene_sqlalchemy/utils.py @@ -1,6 +1,7 @@ import re import warnings +import pkg_resources from sqlalchemy.exc import ArgumentError from sqlalchemy.orm import class_mapper, object_mapper from sqlalchemy.orm.exc import UnmappedClassError, UnmappedInstanceError @@ -140,3 +141,8 @@ def sort_argument_for_model(cls, has_default=True): enum.default = None return Argument(List(enum), default_value=enum.default) + + +def is_sqlalchemy_version_less_than(version_string): + """Check the installed SQLAlchemy version""" + return pkg_resources.get_distribution('SQLAlchemy').parsed_version < pkg_resources.parse_version(version_string) diff --git a/setup.cfg b/setup.cfg index 4e8e5029..f36334d8 100644 --- a/setup.cfg +++ b/setup.cfg @@ -9,7 +9,7 @@ max-line-length = 120 no_lines_before=FIRSTPARTY known_graphene=graphene,graphql_relay,flask_graphql,graphql_server,sphinx_graphene_theme known_first_party=graphene_sqlalchemy -known_third_party=app,database,flask,graphql,mock,models,nameko,pkg_resources,promise,pytest,schema,setuptools,singledispatch,six,sqlalchemy,sqlalchemy_utils +known_third_party=aiodataloader,app,database,flask,models,nameko,pkg_resources,promise,pytest,schema,setuptools,sqlalchemy,sqlalchemy_utils sections=FUTURE,STDLIB,THIRDPARTY,GRAPHENE,FIRSTPARTY,LOCALFOLDER skip_glob=examples/nameko_sqlalchemy diff --git a/setup.py b/setup.py index e20a1750..da49f1d4 100644 --- a/setup.py +++ b/setup.py @@ -13,24 +13,18 @@ requirements = [ # To keep things simple, we only support newer versions of Graphene - "graphene>=2.1.3,<3", + "graphene>=3.0.0b7", "promise>=2.3", - # Tests fail with 1.0.19 - "SQLAlchemy>=1.2,<2", - "six>=1.10.0,<2", - "singledispatch>=3.4.0.3,<4", + "SQLAlchemy>=1.1,<2", + "aiodataloader>=0.2.0,<1.0", ] -try: - import enum -except ImportError: # Python < 2.7 and Python 3.3 - requirements.append("enum34 >= 1.1.6") tests_require = [ - "pytest==4.3.1", - "mock==2.0.0", - "pytest-cov==2.6.1", - "sqlalchemy_utils==0.33.9", - "pytest-benchmark==3.2.1", + "pytest>=6.2.0,<7.0", + "pytest-asyncio>=0.15.1", + "pytest-cov>=2.11.0,<3.0", + "sqlalchemy_utils>=0.37.0,<1.0", + "pytest-benchmark>=3.4.0,<4.0", ] setup( @@ -46,12 +40,10 @@ "Development Status :: 3 - Alpha", "Intended Audience :: Developers", "Topic :: Software Development :: Libraries", - "Programming Language :: Python :: 2", - "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", "Programming Language :: Python :: Implementation :: PyPy", ], keywords="api graphql protocol rest relay graphene", diff --git a/tox.ini b/tox.ini index 69d84f92..a2843f05 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,5 @@ [tox] -envlist = pre-commit,py{27,35,36,37,38,39}-sql{12,13},flake8 +envlist = pre-commit,py{36,37,38,39}-sql{11,12,13,14} skipsdist = true minversion = 3.7.0 @@ -16,6 +16,7 @@ python = SQLALCHEMY = 1.2: sql12 1.3: sql13 + 1.4: sql14 [testenv] passenv = GITHUB_* @@ -23,6 +24,7 @@ deps = .[test] sql12: sqlalchemy>=1.2,<1.3 sql13: sqlalchemy>=1.3,<1.4 + sql14: sqlalchemy>=1.4,<1.5 commands = pytest graphene_sqlalchemy --cov=graphene_sqlalchemy --cov-report=term --cov-report=xml {posargs} @@ -37,4 +39,4 @@ commands = basepython = python3.9 deps = -e.[dev] commands = - flake8 --exclude setup.py,docs,examples,tests,.tox --max-line-length 120 \ No newline at end of file + flake8 --exclude setup.py,docs,examples,tests,.tox --max-line-length 120