mirror of
https://github.com/graphql-python/graphene-django.git
synced 2025-04-20 00:52:04 +03:00
Compare commits
No commits in common. "main" and "v3.1.5" have entirely different histories.
7
.github/workflows/deploy.yml
vendored
7
.github/workflows/deploy.yml
vendored
|
|
@ -6,13 +6,8 @@ on:
|
|||
- 'v*'
|
||||
|
||||
jobs:
|
||||
lint:
|
||||
uses: ./.github/workflows/lint.yml
|
||||
tests:
|
||||
uses: ./.github/workflows/tests.yml
|
||||
release:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
needs: [lint, tests]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
|
|
|
|||
1
.github/workflows/lint.yml
vendored
1
.github/workflows/lint.yml
vendored
|
|
@ -4,7 +4,6 @@ on:
|
|||
push:
|
||||
branches: ["main"]
|
||||
pull_request:
|
||||
workflow_call:
|
||||
|
||||
jobs:
|
||||
build:
|
||||
|
|
|
|||
21
.github/workflows/tests.yml
vendored
21
.github/workflows/tests.yml
vendored
|
|
@ -4,7 +4,6 @@ on:
|
|||
push:
|
||||
branches: ["main"]
|
||||
pull_request:
|
||||
workflow_call:
|
||||
|
||||
jobs:
|
||||
build:
|
||||
|
|
@ -12,21 +11,13 @@ jobs:
|
|||
strategy:
|
||||
max-parallel: 4
|
||||
matrix:
|
||||
django: ["3.2", "4.2", "5.0", "5.1"]
|
||||
python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
|
||||
exclude:
|
||||
- django: "3.2"
|
||||
django: ["3.2", "4.1", "4.2"]
|
||||
python-version: ["3.8", "3.9", "3.10"]
|
||||
include:
|
||||
- django: "4.1"
|
||||
python-version: "3.11"
|
||||
- django: "4.2"
|
||||
python-version: "3.11"
|
||||
- django: "3.2"
|
||||
python-version: "3.12"
|
||||
- django: "5.0"
|
||||
python-version: "3.8"
|
||||
- django: "5.0"
|
||||
python-version: "3.9"
|
||||
- django: "5.1"
|
||||
python-version: "3.8"
|
||||
- django: "5.1"
|
||||
python-version: "3.9"
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- name: Set up Python ${{ matrix.python-version }}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@ default_language_version:
|
|||
python: python3.11
|
||||
repos:
|
||||
- repo: https://github.com/pre-commit/pre-commit-hooks
|
||||
rev: v4.5.0
|
||||
rev: v4.4.0
|
||||
hooks:
|
||||
- id: check-merge-conflict
|
||||
- id: check-json
|
||||
|
|
@ -15,9 +15,12 @@ repos:
|
|||
- --autofix
|
||||
- id: trailing-whitespace
|
||||
exclude: README.md
|
||||
- repo: https://github.com/psf/black
|
||||
rev: 23.7.0
|
||||
hooks:
|
||||
- id: black
|
||||
- repo: https://github.com/astral-sh/ruff-pre-commit
|
||||
rev: v0.1.2
|
||||
rev: v0.0.283
|
||||
hooks:
|
||||
- id: ruff
|
||||
args: [--fix, --exit-non-zero-on-fix, --show-fixes]
|
||||
- id: ruff-format
|
||||
|
|
|
|||
|
|
@ -1,18 +0,0 @@
|
|||
# .readthedocs.yaml
|
||||
# Read the Docs configuration file
|
||||
# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
|
||||
|
||||
version: 2
|
||||
build:
|
||||
os: ubuntu-22.04
|
||||
tools:
|
||||
python: "3.12"
|
||||
|
||||
# Build documentation in the "docs/" directory with Sphinx
|
||||
sphinx:
|
||||
configuration: docs/conf.py
|
||||
|
||||
# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
|
||||
python:
|
||||
install:
|
||||
- requirements: docs/requirements.txt
|
||||
|
|
@ -13,7 +13,6 @@ ignore = [
|
|||
"B017", # pytest.raises(Exception) should be considered evil
|
||||
"B028", # warnings.warn called without an explicit stacklevel keyword argument
|
||||
"B904", # check for raise statements in exception handlers that lack a from clause
|
||||
"W191", # https://docs.astral.sh/ruff/formatter/#conflicting-lint-rules
|
||||
]
|
||||
|
||||
exclude = [
|
||||
|
|
@ -25,8 +24,10 @@ target-version = "py38"
|
|||
[per-file-ignores]
|
||||
# Ignore unused imports (F401) in these files
|
||||
"__init__.py" = ["F401"]
|
||||
"graphene_django/compat.py" = ["F401"]
|
||||
|
||||
[isort]
|
||||
known-first-party = ["graphene", "graphene-django"]
|
||||
known-local-folder = ["cookbook"]
|
||||
force-wrap-aliases = true
|
||||
combine-as-imports = true
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ make tests
|
|||
|
||||
## Opening Pull Requests
|
||||
|
||||
Please fork the project and open a pull request against the `main` branch.
|
||||
Please fork the project and open a pull request against the master branch.
|
||||
|
||||
This will trigger a series of test and lint checks.
|
||||
|
||||
|
|
|
|||
2
Makefile
2
Makefile
|
|
@ -14,7 +14,7 @@ tests:
|
|||
|
||||
.PHONY: format ## Format code
|
||||
format:
|
||||
ruff format graphene_django examples setup.py
|
||||
black graphene_django examples setup.py
|
||||
|
||||
.PHONY: lint ## Lint code
|
||||
lint:
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ Graphene-Django is an open-source library that provides seamless integration bet
|
|||
|
||||
To install Graphene-Django, run the following command:
|
||||
|
||||
```sh
|
||||
```
|
||||
pip install graphene-django
|
||||
```
|
||||
|
||||
|
|
@ -114,11 +114,11 @@ class MyModelAPITestCase(GraphQLTestCase):
|
|||
|
||||
## Contributing
|
||||
|
||||
Contributions to Graphene-Django are always welcome! To get started, check the repository's [issue tracker](https://github.com/graphql-python/graphene-django/issues) and [contribution guidelines](https://github.com/graphql-python/graphene-django/blob/main/CONTRIBUTING.md).
|
||||
Contributions to Graphene-Django are always welcome! To get started, check the repository's [issue tracker](https://github.com/graphql-python/graphene-django/issues) and [contribution guidelines](https://github.com/graphql-python/graphene-django/blob/master/CONTRIBUTING.md).
|
||||
|
||||
## License
|
||||
|
||||
Graphene-Django is released under the [MIT License](https://github.com/graphql-python/graphene-django/blob/main/LICENSE).
|
||||
Graphene-Django is released under the [MIT License](https://github.com/graphql-python/graphene-django/blob/master/LICENSE).
|
||||
|
||||
## Resources
|
||||
|
||||
|
|
|
|||
|
|
@ -33,6 +33,5 @@ For more advanced use, check out the Relay tutorial.
|
|||
authorization
|
||||
debug
|
||||
introspection
|
||||
validation
|
||||
testing
|
||||
settings
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ Graphene-Django can be customised using settings. This page explains each settin
|
|||
Usage
|
||||
-----
|
||||
|
||||
Add settings to your Django project by creating a Dictionary with name ``GRAPHENE`` in the project's ``settings.py``:
|
||||
Add settings to your Django project by creating a Dictonary with name ``GRAPHENE`` in the project's ``settings.py``:
|
||||
|
||||
.. code:: python
|
||||
|
||||
|
|
@ -142,15 +142,6 @@ Default: ``False``
|
|||
# ]
|
||||
|
||||
|
||||
``DJANGO_CHOICE_FIELD_ENUM_CONVERT``
|
||||
--------------------------------------
|
||||
|
||||
When set to ``True`` Django choice fields are automatically converted into Enum types.
|
||||
|
||||
Can be disabled globally by setting it to ``False``.
|
||||
|
||||
Default: ``True``
|
||||
|
||||
``DJANGO_CHOICE_FIELD_ENUM_V2_NAMING``
|
||||
--------------------------------------
|
||||
|
||||
|
|
@ -206,6 +197,9 @@ Set to ``False`` if you want to disable GraphiQL headers editor tab for some rea
|
|||
|
||||
This setting is passed to ``headerEditorEnabled`` GraphiQL options, for details refer to GraphiQLDocs_.
|
||||
|
||||
.. _GraphiQLDocs: https://github.com/graphql/graphiql/tree/main/packages/graphiql#options
|
||||
|
||||
|
||||
Default: ``True``
|
||||
|
||||
.. code:: python
|
||||
|
|
@ -236,6 +230,8 @@ Set to ``True`` if you want to persist GraphiQL headers after refreshing the pag
|
|||
|
||||
This setting is passed to ``shouldPersistHeaders`` GraphiQL options, for details refer to GraphiQLDocs_.
|
||||
|
||||
.. _GraphiQLDocs: https://github.com/graphql/graphiql/tree/main/packages/graphiql#options
|
||||
|
||||
|
||||
Default: ``False``
|
||||
|
||||
|
|
@ -244,48 +240,3 @@ Default: ``False``
|
|||
GRAPHENE = {
|
||||
'GRAPHIQL_SHOULD_PERSIST_HEADERS': False,
|
||||
}
|
||||
|
||||
|
||||
``GRAPHIQL_INPUT_VALUE_DEPRECATION``
|
||||
------------------------------------
|
||||
|
||||
Set to ``True`` if you want GraphiQL to show any deprecated fields on input object types' docs.
|
||||
|
||||
For example, having this schema:
|
||||
|
||||
.. code:: python
|
||||
|
||||
class MyMutationInputType(graphene.InputObjectType):
|
||||
old_field = graphene.String(deprecation_reason="You should now use 'newField' instead.")
|
||||
new_field = graphene.String()
|
||||
|
||||
class MyMutation(graphene.Mutation):
|
||||
class Arguments:
|
||||
input = types.MyMutationInputType()
|
||||
|
||||
GraphiQL will add a ``Show Deprecated Fields`` button to toggle information display on ``oldField`` and its deprecation
|
||||
reason. Otherwise, you would get neither a button nor any information at all on ``oldField``.
|
||||
|
||||
This setting is passed to ``inputValueDeprecation`` GraphiQL options, for details refer to GraphiQLDocs_.
|
||||
|
||||
Default: ``False``
|
||||
|
||||
.. code:: python
|
||||
|
||||
GRAPHENE = {
|
||||
'GRAPHIQL_INPUT_VALUE_DEPRECATION': False,
|
||||
}
|
||||
|
||||
|
||||
.. _GraphiQLDocs: https://graphiql-test.netlify.app/typedoc/modules/graphiql_react#graphiqlprovider-2
|
||||
|
||||
|
||||
``MAX_VALIDATION_ERRORS``
|
||||
------------------------------------
|
||||
|
||||
In case ``validation_rules`` are provided to ``GraphQLView``, if this is set to a non-negative ``int`` value,
|
||||
``graphql.validation.validate`` will stop validation after this number of errors has been reached.
|
||||
If not set or set to ``None``, the maximum number of errors will follow ``graphql.validation.validate`` default
|
||||
*i.e.* 100.
|
||||
|
||||
Default: ``None``
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ Load some test data
|
|||
|
||||
Now is a good time to load up some test data. The easiest option will be
|
||||
to `download the
|
||||
ingredients.json <https://raw.githubusercontent.com/graphql-python/graphene-django/main/examples/cookbook/cookbook/ingredients/fixtures/ingredients.json>`__
|
||||
ingredients.json <https://raw.githubusercontent.com/graphql-python/graphene-django/master/examples/cookbook/cookbook/ingredients/fixtures/ingredients.json>`__
|
||||
fixture and place it in
|
||||
``cookbook/ingredients/fixtures/ingredients.json``. You can then run the
|
||||
following:
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ Graphene has a number of additional features that are designed to make
|
|||
working with Django *really simple*.
|
||||
|
||||
Note: The code in this quickstart is pulled from the `cookbook example
|
||||
app <https://github.com/graphql-python/graphene-django/tree/main/examples/cookbook>`__.
|
||||
app <https://github.com/graphql-python/graphene-django/tree/master/examples/cookbook>`__.
|
||||
|
||||
A good idea is to check the following things first:
|
||||
|
||||
|
|
@ -87,7 +87,7 @@ Load some test data
|
|||
|
||||
Now is a good time to load up some test data. The easiest option will be
|
||||
to `download the
|
||||
ingredients.json <https://raw.githubusercontent.com/graphql-python/graphene-django/main/examples/cookbook/cookbook/ingredients/fixtures/ingredients.json>`__
|
||||
ingredients.json <https://raw.githubusercontent.com/graphql-python/graphene-django/master/examples/cookbook/cookbook/ingredients/fixtures/ingredients.json>`__
|
||||
fixture and place it in
|
||||
``cookbook/ingredients/fixtures/ingredients.json``. You can then run the
|
||||
following:
|
||||
|
|
|
|||
|
|
@ -1,29 +0,0 @@
|
|||
Query Validation
|
||||
================
|
||||
|
||||
Graphene-Django supports query validation by allowing passing a list of validation rules (subclasses of `ValidationRule <https://github.com/graphql-python/graphql-core/blob/v3.2.3/src/graphql/validation/rules/__init__.py>`_ from graphql-core) to the ``validation_rules`` option in ``GraphQLView``.
|
||||
|
||||
.. code:: python
|
||||
|
||||
from django.urls import path
|
||||
from graphene.validation import DisableIntrospection
|
||||
from graphene_django.views import GraphQLView
|
||||
|
||||
urlpatterns = [
|
||||
path("graphql", GraphQLView.as_view(validation_rules=(DisableIntrospection,))),
|
||||
]
|
||||
|
||||
or
|
||||
|
||||
.. code:: python
|
||||
|
||||
from django.urls import path
|
||||
from graphene.validation import DisableIntrospection
|
||||
from graphene_django.views import GraphQLView
|
||||
|
||||
class View(GraphQLView):
|
||||
validation_rules = (DisableIntrospection,)
|
||||
|
||||
urlpatterns = [
|
||||
path("graphql", View.as_view()),
|
||||
]
|
||||
|
|
@ -231,7 +231,7 @@
|
|||
"fields": {
|
||||
"category": 3,
|
||||
"name": "Newt",
|
||||
"notes": "Braised and Confused"
|
||||
"notes": "Braised and Confuesd"
|
||||
},
|
||||
"model": "ingredients.ingredient",
|
||||
"pk": 5
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
graphene>=2.1,<3
|
||||
graphene-django>=2.1,<3
|
||||
graphql-core>=2.1,<3
|
||||
django==3.2.25
|
||||
django==3.1.14
|
||||
django-filter>=2
|
||||
|
|
|
|||
|
|
@ -28,5 +28,3 @@ TEMPLATES = [
|
|||
GRAPHENE = {"SCHEMA": "graphene_django.tests.schema_view.schema"}
|
||||
|
||||
ROOT_URLCONF = "graphene_django.tests.urls"
|
||||
|
||||
USE_TZ = True
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ def initialize():
|
|||
|
||||
# Yeah, technically it's Corellian. But it flew in the service of the rebels,
|
||||
# so for the purposes of this demo it's a rebel ship.
|
||||
falcon = Ship(id="4", name="Millennium Falcon", faction=rebels)
|
||||
falcon = Ship(id="4", name="Millenium Falcon", faction=rebels)
|
||||
falcon.save()
|
||||
|
||||
homeOne = Ship(id="5", name="Home One", faction=rebels)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
import graphene
|
||||
from graphene import Schema, relay
|
||||
from graphene import Schema, relay, resolve_only_args
|
||||
from graphene_django import DjangoConnectionField, DjangoObjectType
|
||||
|
||||
from .data import create_ship, get_empire, get_faction, get_rebels, get_ship, get_ships
|
||||
|
|
@ -62,13 +62,16 @@ class Query(graphene.ObjectType):
|
|||
node = relay.Node.Field()
|
||||
ships = DjangoConnectionField(Ship, description="All the ships.")
|
||||
|
||||
def resolve_ships(self, info):
|
||||
@resolve_only_args
|
||||
def resolve_ships(self):
|
||||
return get_ships()
|
||||
|
||||
def resolve_rebels(self, info):
|
||||
@resolve_only_args
|
||||
def resolve_rebels(self):
|
||||
return get_rebels()
|
||||
|
||||
def resolve_empire(self, info):
|
||||
@resolve_only_args
|
||||
def resolve_empire(self):
|
||||
return get_empire()
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ def test_mutations():
|
|||
{"node": {"id": "U2hpcDox", "name": "X-Wing"}},
|
||||
{"node": {"id": "U2hpcDoy", "name": "Y-Wing"}},
|
||||
{"node": {"id": "U2hpcDoz", "name": "A-Wing"}},
|
||||
{"node": {"id": "U2hpcDo0", "name": "Millennium Falcon"}},
|
||||
{"node": {"id": "U2hpcDo0", "name": "Millenium Falcon"}},
|
||||
{"node": {"id": "U2hpcDo1", "name": "Home One"}},
|
||||
{"node": {"id": "U2hpcDo5", "name": "Peter"}},
|
||||
]
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@ from .fields import DjangoConnectionField, DjangoListField
|
|||
from .types import DjangoObjectType
|
||||
from .utils import bypass_get_queryset
|
||||
|
||||
__version__ = "3.2.3"
|
||||
__version__ = "3.1.5"
|
||||
|
||||
__all__ = [
|
||||
"__version__",
|
||||
|
|
|
|||
|
|
@ -1,11 +1,7 @@
|
|||
import sys
|
||||
from collections.abc import Callable
|
||||
from pathlib import PurePath
|
||||
|
||||
# For backwards compatibility, we import JSONField to have it available for import via
|
||||
# this compat module (https://github.com/graphql-python/graphene-django/issues/1428).
|
||||
# Django's JSONField is available in Django 3.2+ (the minimum version we support)
|
||||
from django.db.models import Choices, JSONField
|
||||
from django.db.models import JSONField
|
||||
|
||||
|
||||
class MissingType:
|
||||
|
|
@ -23,43 +19,4 @@ try:
|
|||
RangeField,
|
||||
)
|
||||
except ImportError:
|
||||
IntegerRangeField, HStoreField, RangeField = (MissingType,) * 3
|
||||
|
||||
# For unit tests we fake ArrayField using JSONFields
|
||||
if any(
|
||||
PurePath(sys.argv[0]).match(p)
|
||||
for p in [
|
||||
"**/pytest",
|
||||
"**/py.test",
|
||||
"**/pytest/__main__.py",
|
||||
]
|
||||
):
|
||||
|
||||
class ArrayField(JSONField):
|
||||
def __init__(self, *args, **kwargs):
|
||||
if len(args) > 0:
|
||||
self.base_field = args[0]
|
||||
super().__init__(**kwargs)
|
||||
|
||||
else:
|
||||
ArrayField = MissingType
|
||||
|
||||
|
||||
try:
|
||||
from django.utils.choices import normalize_choices
|
||||
except ImportError:
|
||||
|
||||
def normalize_choices(choices):
|
||||
if isinstance(choices, type) and issubclass(choices, Choices):
|
||||
choices = choices.choices
|
||||
|
||||
if isinstance(choices, Callable):
|
||||
choices = choices()
|
||||
|
||||
# In restframework==3.15.0, choices are not passed
|
||||
# as OrderedDict anymore, so it's safer to check
|
||||
# for a dict
|
||||
if isinstance(choices, dict):
|
||||
choices = choices.items()
|
||||
|
||||
return choices
|
||||
IntegerRangeField, ArrayField, HStoreField, RangeField = (MissingType,) * 4
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
import inspect
|
||||
from collections import OrderedDict
|
||||
from functools import partial, singledispatch, wraps
|
||||
|
||||
from django.db import models
|
||||
|
|
@ -36,7 +37,7 @@ except ImportError:
|
|||
from graphql import assert_valid_name as assert_name
|
||||
from graphql.pyutils import register_description
|
||||
|
||||
from .compat import ArrayField, HStoreField, RangeField, normalize_choices
|
||||
from .compat import ArrayField, HStoreField, RangeField
|
||||
from .fields import DjangoConnectionField, DjangoListField
|
||||
from .settings import graphene_settings
|
||||
from .utils.str_converters import to_const
|
||||
|
|
@ -60,24 +61,6 @@ class BlankValueField(Field):
|
|||
return blank_field_wrapper(resolver)
|
||||
|
||||
|
||||
class EnumValueField(BlankValueField):
|
||||
def wrap_resolve(self, parent_resolver):
|
||||
resolver = super().wrap_resolve(parent_resolver)
|
||||
|
||||
# create custom resolver
|
||||
def enum_field_wrapper(func):
|
||||
@wraps(func)
|
||||
def wrapped_resolver(*args, **kwargs):
|
||||
return_value = func(*args, **kwargs)
|
||||
if isinstance(return_value, models.Choices):
|
||||
return_value = return_value.value
|
||||
return return_value
|
||||
|
||||
return wrapped_resolver
|
||||
|
||||
return enum_field_wrapper(resolver)
|
||||
|
||||
|
||||
def convert_choice_name(name):
|
||||
name = to_const(force_str(name))
|
||||
try:
|
||||
|
|
@ -89,7 +72,8 @@ def convert_choice_name(name):
|
|||
|
||||
def get_choices(choices):
|
||||
converted_names = []
|
||||
choices = normalize_choices(choices)
|
||||
if isinstance(choices, OrderedDict):
|
||||
choices = choices.items()
|
||||
for value, help_text in choices:
|
||||
if isinstance(help_text, (tuple, list)):
|
||||
yield from get_choices(help_text)
|
||||
|
|
@ -149,24 +133,20 @@ def convert_choice_field_to_enum(field, name=None):
|
|||
|
||||
|
||||
def convert_django_field_with_choices(
|
||||
field, registry=None, convert_choices_to_enum=None
|
||||
field, registry=None, convert_choices_to_enum=True
|
||||
):
|
||||
if registry is not None:
|
||||
converted = registry.get_converted_field(field)
|
||||
if converted:
|
||||
return converted
|
||||
choices = getattr(field, "choices", None)
|
||||
if convert_choices_to_enum is None:
|
||||
convert_choices_to_enum = bool(
|
||||
graphene_settings.DJANGO_CHOICE_FIELD_ENUM_CONVERT
|
||||
)
|
||||
if choices and convert_choices_to_enum:
|
||||
EnumCls = convert_choice_field_to_enum(field)
|
||||
required = not (field.blank or field.null)
|
||||
|
||||
converted = EnumCls(
|
||||
description=get_django_field_description(field), required=required
|
||||
).mount_as(EnumValueField)
|
||||
).mount_as(BlankValueField)
|
||||
else:
|
||||
converted = convert_django_field(field, registry)
|
||||
if registry is not None:
|
||||
|
|
@ -199,13 +179,19 @@ def convert_field_to_string(field, registry=None):
|
|||
)
|
||||
|
||||
|
||||
@convert_django_field.register(models.AutoField)
|
||||
@convert_django_field.register(models.BigAutoField)
|
||||
@convert_django_field.register(models.SmallAutoField)
|
||||
@convert_django_field.register(models.AutoField)
|
||||
def convert_field_to_id(field, registry=None):
|
||||
return ID(description=get_django_field_description(field), required=not field.null)
|
||||
|
||||
|
||||
if hasattr(models, "SmallAutoField"):
|
||||
|
||||
@convert_django_field.register(models.SmallAutoField)
|
||||
def convert_field_small_to_id(field, registry=None):
|
||||
return convert_field_to_id(field, registry)
|
||||
|
||||
|
||||
@convert_django_field.register(models.UUIDField)
|
||||
def convert_field_to_uuid(field, registry=None):
|
||||
return UUID(
|
||||
|
|
|
|||
|
|
@ -20,20 +20,17 @@ from .utils import maybe_queryset
|
|||
|
||||
class DjangoListField(Field):
|
||||
def __init__(self, _type, *args, **kwargs):
|
||||
from .types import DjangoObjectType
|
||||
|
||||
if isinstance(_type, NonNull):
|
||||
_type = _type.of_type
|
||||
|
||||
# Django would never return a Set of None vvvvvvv
|
||||
super().__init__(List(NonNull(_type)), *args, **kwargs)
|
||||
|
||||
@property
|
||||
def type(self):
|
||||
from .types import DjangoObjectType
|
||||
|
||||
assert issubclass(
|
||||
self._underlying_type, DjangoObjectType
|
||||
), "DjangoListField only accepts DjangoObjectType types as underlying type"
|
||||
return super().type
|
||||
), "DjangoListField only accepts DjangoObjectType types"
|
||||
|
||||
@property
|
||||
def _underlying_type(self):
|
||||
|
|
@ -197,7 +194,7 @@ class DjangoConnectionField(ConnectionField):
|
|||
enforce_first_or_last,
|
||||
root,
|
||||
info,
|
||||
**args,
|
||||
**args
|
||||
):
|
||||
first = args.get("first")
|
||||
last = args.get("last")
|
||||
|
|
@ -247,7 +244,7 @@ class DjangoConnectionField(ConnectionField):
|
|||
def wrap_resolve(self, parent_resolver):
|
||||
return partial(
|
||||
self.connection_resolver,
|
||||
self.resolver or parent_resolver,
|
||||
parent_resolver,
|
||||
self.connection_type,
|
||||
self.get_manager(),
|
||||
self.get_queryset_resolver(),
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ class DjangoFilterConnectionField(DjangoConnectionField):
|
|||
extra_filter_meta=None,
|
||||
filterset_class=None,
|
||||
*args,
|
||||
**kwargs,
|
||||
**kwargs
|
||||
):
|
||||
self._fields = fields
|
||||
self._provided_filterset_class = filterset_class
|
||||
|
|
|
|||
|
|
@ -1,36 +1,13 @@
|
|||
from django_filters.constants import EMPTY_VALUES
|
||||
from django_filters.filters import FilterMethod
|
||||
|
||||
from .typed_filter import TypedFilter
|
||||
|
||||
|
||||
class ArrayFilterMethod(FilterMethod):
|
||||
def __call__(self, qs, value):
|
||||
if value is None:
|
||||
return qs
|
||||
return self.method(qs, self.f.field_name, value)
|
||||
|
||||
|
||||
class ArrayFilter(TypedFilter):
|
||||
"""
|
||||
Filter made for PostgreSQL ArrayField.
|
||||
"""
|
||||
|
||||
@TypedFilter.method.setter
|
||||
def method(self, value):
|
||||
"""
|
||||
Override method setter so that in case a custom `method` is provided
|
||||
(see documentation https://django-filter.readthedocs.io/en/stable/ref/filters.html#method),
|
||||
it doesn't fall back to checking if the value is in `EMPTY_VALUES` (from the `__call__` method
|
||||
of the `FilterMethod` class) and instead use our ArrayFilterMethod that consider empty lists as values.
|
||||
|
||||
Indeed when providing a `method` the `filter` method below is overridden and replaced by `FilterMethod(self)`
|
||||
which means that the validation of the empty value is made by the `FilterMethod.__call__` method instead.
|
||||
"""
|
||||
TypedFilter.method.fset(self, value)
|
||||
if value is not None:
|
||||
self.filter = ArrayFilterMethod(self)
|
||||
|
||||
def filter(self, qs, value):
|
||||
"""
|
||||
Override the default filter class to check first whether the list is
|
||||
|
|
|
|||
|
|
@ -1,36 +1,12 @@
|
|||
from django_filters.filters import FilterMethod
|
||||
|
||||
from .typed_filter import TypedFilter
|
||||
|
||||
|
||||
class ListFilterMethod(FilterMethod):
|
||||
def __call__(self, qs, value):
|
||||
if value is None:
|
||||
return qs
|
||||
return self.method(qs, self.f.field_name, value)
|
||||
|
||||
|
||||
class ListFilter(TypedFilter):
|
||||
"""
|
||||
Filter that takes a list of value as input.
|
||||
It is for example used for `__in` filters.
|
||||
"""
|
||||
|
||||
@TypedFilter.method.setter
|
||||
def method(self, value):
|
||||
"""
|
||||
Override method setter so that in case a custom `method` is provided
|
||||
(see documentation https://django-filter.readthedocs.io/en/stable/ref/filters.html#method),
|
||||
it doesn't fall back to checking if the value is in `EMPTY_VALUES` (from the `__call__` method
|
||||
of the `FilterMethod` class) and instead use our ListFilterMethod that consider empty lists as values.
|
||||
|
||||
Indeed when providing a `method` the `filter` method below is overridden and replaced by `FilterMethod(self)`
|
||||
which means that the validation of the empty value is made by the `FilterMethod.__call__` method instead.
|
||||
"""
|
||||
TypedFilter.method.fset(self, value)
|
||||
if value is not None:
|
||||
self.filter = ListFilterMethod(self)
|
||||
|
||||
def filter(self, qs, value):
|
||||
"""
|
||||
Override the default filter class to check first whether the list is
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
from functools import reduce
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
import pytest
|
||||
from django.db import models
|
||||
|
|
@ -25,15 +25,15 @@ else:
|
|||
)
|
||||
|
||||
|
||||
STORE = {"events": []}
|
||||
|
||||
|
||||
class Event(models.Model):
|
||||
name = models.CharField(max_length=50)
|
||||
tags = ArrayField(models.CharField(max_length=50))
|
||||
tag_ids = ArrayField(models.IntegerField())
|
||||
random_field = ArrayField(models.BooleanField())
|
||||
|
||||
def __repr__(self):
|
||||
return f"Event [{self.name}]"
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def EventFilterSet():
|
||||
|
|
@ -44,18 +44,10 @@ def EventFilterSet():
|
|||
"name": ["exact", "contains"],
|
||||
}
|
||||
|
||||
# Those are actually usable with our Query fixture below
|
||||
# Those are actually usable with our Query fixture bellow
|
||||
tags__contains = ArrayFilter(field_name="tags", lookup_expr="contains")
|
||||
tags__overlap = ArrayFilter(field_name="tags", lookup_expr="overlap")
|
||||
tags = ArrayFilter(field_name="tags", lookup_expr="exact")
|
||||
tags__len = ArrayFilter(
|
||||
field_name="tags", lookup_expr="len", input_type=graphene.Int
|
||||
)
|
||||
tags__len__in = ArrayFilter(
|
||||
field_name="tags",
|
||||
method="tags__len__in_filter",
|
||||
input_type=graphene.List(graphene.Int),
|
||||
)
|
||||
|
||||
# Those are actually not usable and only to check type declarations
|
||||
tags_ids__contains = ArrayFilter(field_name="tag_ids", lookup_expr="contains")
|
||||
|
|
@ -69,14 +61,6 @@ def EventFilterSet():
|
|||
)
|
||||
random_field = ArrayFilter(field_name="random_field", lookup_expr="exact")
|
||||
|
||||
def tags__len__in_filter(self, queryset, _name, value):
|
||||
if not value:
|
||||
return queryset.none()
|
||||
return reduce(
|
||||
lambda q1, q2: q1.union(q2),
|
||||
[queryset.filter(tags__len=v) for v in value],
|
||||
).distinct()
|
||||
|
||||
return EventFilterSet
|
||||
|
||||
|
||||
|
|
@ -99,94 +83,68 @@ def Query(EventType):
|
|||
we are running unit tests in sqlite which does not have ArrayFields.
|
||||
"""
|
||||
|
||||
events = [
|
||||
Event(name="Live Show", tags=["concert", "music", "rock"]),
|
||||
Event(name="Musical", tags=["movie", "music"]),
|
||||
Event(name="Ballet", tags=["concert", "dance"]),
|
||||
Event(name="Speech", tags=[]),
|
||||
]
|
||||
|
||||
class Query(graphene.ObjectType):
|
||||
events = DjangoFilterConnectionField(EventType)
|
||||
|
||||
def resolve_events(self, info, **kwargs):
|
||||
class FakeQuerySet(QuerySet):
|
||||
def __init__(self, model=None):
|
||||
self.model = Event
|
||||
self.__store = list(events)
|
||||
events = [
|
||||
Event(name="Live Show", tags=["concert", "music", "rock"]),
|
||||
Event(name="Musical", tags=["movie", "music"]),
|
||||
Event(name="Ballet", tags=["concert", "dance"]),
|
||||
Event(name="Speech", tags=[]),
|
||||
]
|
||||
|
||||
def all(self):
|
||||
return self
|
||||
STORE["events"] = events
|
||||
|
||||
def filter(self, **kwargs):
|
||||
queryset = FakeQuerySet()
|
||||
queryset.__store = list(self.__store)
|
||||
if "tags__contains" in kwargs:
|
||||
queryset.__store = list(
|
||||
filter(
|
||||
lambda e: set(kwargs["tags__contains"]).issubset(
|
||||
set(e.tags)
|
||||
),
|
||||
queryset.__store,
|
||||
)
|
||||
m_queryset = MagicMock(spec=QuerySet)
|
||||
m_queryset.model = Event
|
||||
|
||||
def filter_events(**kwargs):
|
||||
if "tags__contains" in kwargs:
|
||||
STORE["events"] = list(
|
||||
filter(
|
||||
lambda e: set(kwargs["tags__contains"]).issubset(
|
||||
set(e.tags)
|
||||
),
|
||||
STORE["events"],
|
||||
)
|
||||
if "tags__overlap" in kwargs:
|
||||
queryset.__store = list(
|
||||
filter(
|
||||
lambda e: not set(kwargs["tags__overlap"]).isdisjoint(
|
||||
set(e.tags)
|
||||
),
|
||||
queryset.__store,
|
||||
)
|
||||
)
|
||||
if "tags__overlap" in kwargs:
|
||||
STORE["events"] = list(
|
||||
filter(
|
||||
lambda e: not set(kwargs["tags__overlap"]).isdisjoint(
|
||||
set(e.tags)
|
||||
),
|
||||
STORE["events"],
|
||||
)
|
||||
if "tags__exact" in kwargs:
|
||||
queryset.__store = list(
|
||||
filter(
|
||||
lambda e: set(kwargs["tags__exact"]) == set(e.tags),
|
||||
queryset.__store,
|
||||
)
|
||||
)
|
||||
if "tags__exact" in kwargs:
|
||||
STORE["events"] = list(
|
||||
filter(
|
||||
lambda e: set(kwargs["tags__exact"]) == set(e.tags),
|
||||
STORE["events"],
|
||||
)
|
||||
if "tags__len" in kwargs:
|
||||
queryset.__store = list(
|
||||
filter(
|
||||
lambda e: len(e.tags) == kwargs["tags__len"],
|
||||
queryset.__store,
|
||||
)
|
||||
)
|
||||
return queryset
|
||||
)
|
||||
|
||||
def union(self, *args):
|
||||
queryset = FakeQuerySet()
|
||||
queryset.__store = self.__store
|
||||
for arg in args:
|
||||
queryset.__store += arg.__store
|
||||
return queryset
|
||||
def mock_queryset_filter(*args, **kwargs):
|
||||
filter_events(**kwargs)
|
||||
return m_queryset
|
||||
|
||||
def none(self):
|
||||
queryset = FakeQuerySet()
|
||||
queryset.__store = []
|
||||
return queryset
|
||||
def mock_queryset_none(*args, **kwargs):
|
||||
STORE["events"] = []
|
||||
return m_queryset
|
||||
|
||||
def count(self):
|
||||
return len(self.__store)
|
||||
def mock_queryset_count(*args, **kwargs):
|
||||
return len(STORE["events"])
|
||||
|
||||
def distinct(self):
|
||||
queryset = FakeQuerySet()
|
||||
queryset.__store = []
|
||||
for event in self.__store:
|
||||
if event not in queryset.__store:
|
||||
queryset.__store.append(event)
|
||||
queryset.__store = sorted(queryset.__store, key=lambda e: e.name)
|
||||
return queryset
|
||||
m_queryset.all.return_value = m_queryset
|
||||
m_queryset.filter.side_effect = mock_queryset_filter
|
||||
m_queryset.none.side_effect = mock_queryset_none
|
||||
m_queryset.count.side_effect = mock_queryset_count
|
||||
m_queryset.__getitem__.side_effect = lambda index: STORE[
|
||||
"events"
|
||||
].__getitem__(index)
|
||||
|
||||
def __getitem__(self, index):
|
||||
return self.__store[index]
|
||||
|
||||
return FakeQuerySet()
|
||||
return m_queryset
|
||||
|
||||
return Query
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def schema(Query):
|
||||
return graphene.Schema(query=Query)
|
||||
|
|
|
|||
|
|
@ -1,14 +1,18 @@
|
|||
import pytest
|
||||
|
||||
from graphene import Schema
|
||||
|
||||
from ...compat import ArrayField, MissingType
|
||||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_contains_multiple(schema):
|
||||
def test_array_field_contains_multiple(Query):
|
||||
"""
|
||||
Test contains filter on a array field of string.
|
||||
"""
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Contains: ["concert", "music"]) {
|
||||
|
|
@ -28,11 +32,13 @@ def test_array_field_contains_multiple(schema):
|
|||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_contains_one(schema):
|
||||
def test_array_field_contains_one(Query):
|
||||
"""
|
||||
Test contains filter on a array field of string.
|
||||
"""
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Contains: ["music"]) {
|
||||
|
|
@ -53,11 +59,13 @@ def test_array_field_contains_one(schema):
|
|||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_contains_empty_list(schema):
|
||||
def test_array_field_contains_empty_list(Query):
|
||||
"""
|
||||
Test contains filter on a array field of string.
|
||||
"""
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Contains: []) {
|
||||
|
|
|
|||
|
|
@ -1,186 +0,0 @@
|
|||
import pytest
|
||||
|
||||
from ...compat import ArrayField, MissingType
|
||||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_len_filter(schema):
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len: 2) {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["events"]["edges"] == [
|
||||
{"node": {"name": "Musical"}},
|
||||
{"node": {"name": "Ballet"}},
|
||||
]
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len: 0) {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["events"]["edges"] == [
|
||||
{"node": {"name": "Speech"}},
|
||||
]
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len: 10) {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["events"]["edges"] == []
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len: "2") {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert len(result.errors) == 1
|
||||
assert result.errors[0].message == 'Int cannot represent non-integer value: "2"'
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len: True) {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert len(result.errors) == 1
|
||||
assert result.errors[0].message == "Int cannot represent non-integer value: True"
|
||||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_custom_filter(schema):
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len_In: 2) {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["events"]["edges"] == [
|
||||
{"node": {"name": "Ballet"}},
|
||||
{"node": {"name": "Musical"}},
|
||||
]
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len_In: [0, 2]) {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["events"]["edges"] == [
|
||||
{"node": {"name": "Ballet"}},
|
||||
{"node": {"name": "Musical"}},
|
||||
{"node": {"name": "Speech"}},
|
||||
]
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len_In: [10]) {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["events"]["edges"] == []
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len_In: []) {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["events"]["edges"] == []
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len_In: "12") {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert len(result.errors) == 1
|
||||
assert result.errors[0].message == 'Int cannot represent non-integer value: "12"'
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Len_In: True) {
|
||||
edges {
|
||||
node {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
result = schema.execute(query)
|
||||
assert len(result.errors) == 1
|
||||
assert result.errors[0].message == "Int cannot represent non-integer value: True"
|
||||
|
|
@ -1,14 +1,18 @@
|
|||
import pytest
|
||||
|
||||
from graphene import Schema
|
||||
|
||||
from ...compat import ArrayField, MissingType
|
||||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_exact_no_match(schema):
|
||||
def test_array_field_exact_no_match(Query):
|
||||
"""
|
||||
Test exact filter on a array field of string.
|
||||
"""
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags: ["concert", "music"]) {
|
||||
|
|
@ -26,11 +30,13 @@ def test_array_field_exact_no_match(schema):
|
|||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_exact_match(schema):
|
||||
def test_array_field_exact_match(Query):
|
||||
"""
|
||||
Test exact filter on a array field of string.
|
||||
"""
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags: ["movie", "music"]) {
|
||||
|
|
@ -50,11 +56,13 @@ def test_array_field_exact_match(schema):
|
|||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_exact_empty_list(schema):
|
||||
def test_array_field_exact_empty_list(Query):
|
||||
"""
|
||||
Test exact filter on a array field of string.
|
||||
"""
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags: []) {
|
||||
|
|
@ -74,10 +82,11 @@ def test_array_field_exact_empty_list(schema):
|
|||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_filter_schema_type(schema):
|
||||
def test_array_field_filter_schema_type(Query):
|
||||
"""
|
||||
Check that the type in the filter is an array field like on the object type.
|
||||
"""
|
||||
schema = Schema(query=Query)
|
||||
schema_str = str(schema)
|
||||
|
||||
assert (
|
||||
|
|
@ -103,8 +112,6 @@ def test_array_field_filter_schema_type(schema):
|
|||
"tags_Contains": "[String!]",
|
||||
"tags_Overlap": "[String!]",
|
||||
"tags": "[String!]",
|
||||
"tags_Len": "Int",
|
||||
"tags_Len_In": "[Int]",
|
||||
"tagsIds_Contains": "[Int!]",
|
||||
"tagsIds_Overlap": "[Int!]",
|
||||
"tagsIds": "[Int!]",
|
||||
|
|
|
|||
|
|
@ -1,14 +1,18 @@
|
|||
import pytest
|
||||
|
||||
from graphene import Schema
|
||||
|
||||
from ...compat import ArrayField, MissingType
|
||||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_overlap_multiple(schema):
|
||||
def test_array_field_overlap_multiple(Query):
|
||||
"""
|
||||
Test overlap filter on a array field of string.
|
||||
"""
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Overlap: ["concert", "music"]) {
|
||||
|
|
@ -30,11 +34,13 @@ def test_array_field_overlap_multiple(schema):
|
|||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_overlap_one(schema):
|
||||
def test_array_field_overlap_one(Query):
|
||||
"""
|
||||
Test overlap filter on a array field of string.
|
||||
"""
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Overlap: ["music"]) {
|
||||
|
|
@ -55,11 +61,13 @@ def test_array_field_overlap_one(schema):
|
|||
|
||||
|
||||
@pytest.mark.skipif(ArrayField is MissingType, reason="ArrayField should exist")
|
||||
def test_array_field_overlap_empty_list(schema):
|
||||
def test_array_field_overlap_empty_list(Query):
|
||||
"""
|
||||
Test overlap filter on a array field of string.
|
||||
"""
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
events (tags_Overlap: []) {
|
||||
|
|
|
|||
|
|
@ -789,7 +789,7 @@ def test_order_by():
|
|||
|
||||
query = """
|
||||
query NodeFilteringQuery {
|
||||
allReporters(orderBy: "-firstname") {
|
||||
allReporters(orderBy: "-firtsnaMe") {
|
||||
edges {
|
||||
node {
|
||||
firstName
|
||||
|
|
@ -802,7 +802,7 @@ def test_order_by():
|
|||
assert result.errors
|
||||
|
||||
|
||||
def test_order_by_is_preserved():
|
||||
def test_order_by_is_perserved():
|
||||
class ReporterType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Reporter
|
||||
|
|
|
|||
|
|
@ -1,8 +1,4 @@
|
|||
import operator
|
||||
from functools import reduce
|
||||
|
||||
import pytest
|
||||
from django.db.models import Q
|
||||
from django_filters import FilterSet
|
||||
|
||||
import graphene
|
||||
|
|
@ -48,10 +44,6 @@ def schema():
|
|||
only_first = TypedFilter(
|
||||
input_type=graphene.Boolean, method="only_first_filter"
|
||||
)
|
||||
headline_search = ListFilter(
|
||||
method="headline_search_filter",
|
||||
input_type=graphene.List(graphene.String),
|
||||
)
|
||||
|
||||
def first_n_filter(self, queryset, _name, value):
|
||||
return queryset[:value]
|
||||
|
|
@ -62,13 +54,6 @@ def schema():
|
|||
else:
|
||||
return queryset
|
||||
|
||||
def headline_search_filter(self, queryset, _name, value):
|
||||
if not value:
|
||||
return queryset.none()
|
||||
return queryset.filter(
|
||||
reduce(operator.or_, [Q(headline__icontains=v) for v in value])
|
||||
)
|
||||
|
||||
class ArticleType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Article
|
||||
|
|
@ -102,7 +87,6 @@ def test_typed_filter_schema(schema):
|
|||
"lang_InStr": "[String]",
|
||||
"firstN": "Int",
|
||||
"onlyFirst": "Boolean",
|
||||
"headlineSearch": "[String]",
|
||||
}
|
||||
|
||||
all_articles_filters = (
|
||||
|
|
@ -120,7 +104,24 @@ def test_typed_filters_work(schema):
|
|||
Article.objects.create(headline="A", reporter=reporter, editor=reporter, lang="es")
|
||||
Article.objects.create(headline="B", reporter=reporter, editor=reporter, lang="es")
|
||||
Article.objects.create(headline="C", reporter=reporter, editor=reporter, lang="en")
|
||||
Article.objects.create(headline="AB", reporter=reporter, editor=reporter, lang="es")
|
||||
|
||||
query = "query { articles (lang_In: [ES]) { edges { node { headline } } } }"
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
{"node": {"headline": "B"}},
|
||||
]
|
||||
|
||||
query = 'query { articles (lang_InStr: ["es"]) { edges { node { headline } } } }'
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
{"node": {"headline": "B"}},
|
||||
]
|
||||
|
||||
query = 'query { articles (lang_Contains: "n") { edges { node { headline } } } }'
|
||||
|
||||
|
|
@ -136,7 +137,7 @@ def test_typed_filters_work(schema):
|
|||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
{"node": {"headline": "AB"}},
|
||||
{"node": {"headline": "B"}},
|
||||
]
|
||||
|
||||
query = "query { articles (onlyFirst: true) { edges { node { headline } } } }"
|
||||
|
|
@ -146,86 +147,3 @@ def test_typed_filters_work(schema):
|
|||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
]
|
||||
|
||||
|
||||
def test_list_filters_work(schema):
|
||||
reporter = Reporter.objects.create(first_name="John", last_name="Doe", email="")
|
||||
Article.objects.create(headline="A", reporter=reporter, editor=reporter, lang="es")
|
||||
Article.objects.create(headline="B", reporter=reporter, editor=reporter, lang="es")
|
||||
Article.objects.create(headline="C", reporter=reporter, editor=reporter, lang="en")
|
||||
Article.objects.create(headline="AB", reporter=reporter, editor=reporter, lang="es")
|
||||
|
||||
query = "query { articles (lang_In: [ES]) { edges { node { headline } } } }"
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
{"node": {"headline": "AB"}},
|
||||
{"node": {"headline": "B"}},
|
||||
]
|
||||
|
||||
query = 'query { articles (lang_InStr: ["es"]) { edges { node { headline } } } }'
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
{"node": {"headline": "AB"}},
|
||||
{"node": {"headline": "B"}},
|
||||
]
|
||||
|
||||
query = "query { articles (lang_InStr: []) { edges { node { headline } } } }"
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == []
|
||||
|
||||
query = "query { articles (lang_InStr: null) { edges { node { headline } } } }"
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
{"node": {"headline": "AB"}},
|
||||
{"node": {"headline": "B"}},
|
||||
{"node": {"headline": "C"}},
|
||||
]
|
||||
|
||||
query = 'query { articles (headlineSearch: ["a", "B"]) { edges { node { headline } } } }'
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
{"node": {"headline": "AB"}},
|
||||
{"node": {"headline": "B"}},
|
||||
]
|
||||
|
||||
query = "query { articles (headlineSearch: []) { edges { node { headline } } } }"
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == []
|
||||
|
||||
query = "query { articles (headlineSearch: null) { edges { node { headline } } } }"
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
{"node": {"headline": "AB"}},
|
||||
{"node": {"headline": "B"}},
|
||||
{"node": {"headline": "C"}},
|
||||
]
|
||||
|
||||
query = 'query { articles (headlineSearch: [""]) { edges { node { headline } } } }'
|
||||
|
||||
result = schema.execute(query)
|
||||
assert not result.errors
|
||||
assert result.data["articles"]["edges"] == [
|
||||
{"node": {"headline": "A"}},
|
||||
{"node": {"headline": "AB"}},
|
||||
{"node": {"headline": "B"}},
|
||||
{"node": {"headline": "C"}},
|
||||
]
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ def get_filtering_args_from_filterset(filterset_class, type):
|
|||
isinstance(filter_field, TypedFilter)
|
||||
and filter_field.input_type is not None
|
||||
):
|
||||
# First check if the filter input type has been explicitly given
|
||||
# First check if the filter input type has been explicitely given
|
||||
field_type = filter_field.input_type
|
||||
else:
|
||||
if name not in filterset_class.declared_filters or isinstance(
|
||||
|
|
@ -145,7 +145,7 @@ def replace_csv_filters(filterset_class):
|
|||
label=filter_field.label,
|
||||
method=filter_field.method,
|
||||
exclude=filter_field.exclude,
|
||||
**filter_field.extra,
|
||||
**filter_field.extra
|
||||
)
|
||||
elif filter_type == "range":
|
||||
filterset_class.base_filters[name] = RangeFilter(
|
||||
|
|
@ -154,5 +154,5 @@ def replace_csv_filters(filterset_class):
|
|||
label=filter_field.label,
|
||||
method=filter_field.method,
|
||||
exclude=filter_field.exclude,
|
||||
**filter_field.extra,
|
||||
**filter_field.extra
|
||||
)
|
||||
|
|
|
|||
|
|
@ -23,7 +23,8 @@ def fields_for_form(form, only_fields, exclude_fields):
|
|||
for name, field in form.fields.items():
|
||||
is_not_in_only = only_fields and name not in only_fields
|
||||
is_excluded = (
|
||||
name in exclude_fields # or
|
||||
name
|
||||
in exclude_fields # or
|
||||
# name in already_created_fields
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
from django import VERSION as DJANGO_VERSION, forms
|
||||
from django import forms
|
||||
from pytest import raises
|
||||
|
||||
from graphene import (
|
||||
|
|
@ -19,16 +19,12 @@ from graphene import (
|
|||
from ..converter import convert_form_field
|
||||
|
||||
|
||||
def assert_conversion(django_field, graphene_field, *args, **kwargs):
|
||||
# Arrange
|
||||
help_text = kwargs.setdefault("help_text", "Custom Help Text")
|
||||
field = django_field(*args, **kwargs)
|
||||
# Act
|
||||
def assert_conversion(django_field, graphene_field, *args):
|
||||
field = django_field(*args, help_text="Custom Help Text")
|
||||
graphene_type = convert_form_field(field)
|
||||
# Assert
|
||||
assert isinstance(graphene_type, graphene_field)
|
||||
field = graphene_type.Field()
|
||||
assert field.description == help_text
|
||||
assert field.description == "Custom Help Text"
|
||||
return field
|
||||
|
||||
|
||||
|
|
@ -63,12 +59,7 @@ def test_should_slug_convert_string():
|
|||
|
||||
|
||||
def test_should_url_convert_string():
|
||||
kwargs = {}
|
||||
if DJANGO_VERSION >= (5, 0):
|
||||
# silence RemovedInDjango60Warning
|
||||
kwargs["assume_scheme"] = "https"
|
||||
|
||||
assert_conversion(forms.URLField, String, **kwargs)
|
||||
assert_conversion(forms.URLField, String)
|
||||
|
||||
|
||||
def test_should_choice_convert_string():
|
||||
|
|
@ -84,7 +75,8 @@ def test_should_regex_convert_string():
|
|||
|
||||
|
||||
def test_should_uuid_convert_string():
|
||||
assert_conversion(forms.UUIDField, UUID)
|
||||
if hasattr(forms, "UUIDField"):
|
||||
assert_conversion(forms.UUIDField, UUID)
|
||||
|
||||
|
||||
def test_should_integer_convert_int():
|
||||
|
|
|
|||
|
|
@ -3,8 +3,8 @@ from graphene import ID
|
|||
from graphene.types.inputobjecttype import InputObjectType
|
||||
from graphene.utils.str_converters import to_camel_case
|
||||
|
||||
from ..converter import EnumValueField
|
||||
from ..types import ErrorType # noqa Import ErrorType for backwards compatibility
|
||||
from ..converter import BlankValueField
|
||||
from ..types import ErrorType # noqa Import ErrorType for backwards compatability
|
||||
from .mutation import fields_for_form
|
||||
|
||||
|
||||
|
|
@ -57,10 +57,11 @@ class DjangoFormInputObjectType(InputObjectType):
|
|||
if (
|
||||
object_type
|
||||
and name in object_type._meta.fields
|
||||
and isinstance(object_type._meta.fields[name], EnumValueField)
|
||||
and isinstance(object_type._meta.fields[name], BlankValueField)
|
||||
):
|
||||
# Field type EnumValueField here means that field
|
||||
# with choices have been converted to enum
|
||||
# Field type BlankValueField here means that field
|
||||
# with choises have been converted to enum
|
||||
# (BlankValueField is using only for that task ?)
|
||||
setattr(cls, name, cls.get_enum_cnv_cls_instance(name, object_type))
|
||||
elif (
|
||||
object_type
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ class SerializerMutationOptions(MutationOptions):
|
|||
model_class = None
|
||||
model_operations = ["create", "update"]
|
||||
serializer_class = None
|
||||
optional_fields = ()
|
||||
|
||||
|
||||
def fields_for_serializer(
|
||||
|
|
@ -29,7 +28,6 @@ def fields_for_serializer(
|
|||
is_input=False,
|
||||
convert_choices_to_enum=True,
|
||||
lookup_field=None,
|
||||
optional_fields=(),
|
||||
):
|
||||
fields = OrderedDict()
|
||||
for name, field in serializer.fields.items():
|
||||
|
|
@ -50,13 +48,9 @@ def fields_for_serializer(
|
|||
|
||||
if is_not_in_only or is_excluded:
|
||||
continue
|
||||
is_optional = name in optional_fields or "__all__" in optional_fields
|
||||
|
||||
fields[name] = convert_serializer_field(
|
||||
field,
|
||||
is_input=is_input,
|
||||
convert_choices_to_enum=convert_choices_to_enum,
|
||||
force_optional=is_optional,
|
||||
field, is_input=is_input, convert_choices_to_enum=convert_choices_to_enum
|
||||
)
|
||||
return fields
|
||||
|
||||
|
|
@ -80,8 +74,7 @@ class SerializerMutation(ClientIDMutation):
|
|||
exclude_fields=(),
|
||||
convert_choices_to_enum=True,
|
||||
_meta=None,
|
||||
optional_fields=(),
|
||||
**options,
|
||||
**options
|
||||
):
|
||||
if not serializer_class:
|
||||
raise Exception("serializer_class is required for the SerializerMutation")
|
||||
|
|
@ -105,7 +98,6 @@ class SerializerMutation(ClientIDMutation):
|
|||
is_input=True,
|
||||
convert_choices_to_enum=convert_choices_to_enum,
|
||||
lookup_field=lookup_field,
|
||||
optional_fields=optional_fields,
|
||||
)
|
||||
output_fields = fields_for_serializer(
|
||||
serializer,
|
||||
|
|
|
|||
|
|
@ -18,9 +18,7 @@ def get_graphene_type_from_serializer_field(field):
|
|||
)
|
||||
|
||||
|
||||
def convert_serializer_field(
|
||||
field, is_input=True, convert_choices_to_enum=True, force_optional=False
|
||||
):
|
||||
def convert_serializer_field(field, is_input=True, convert_choices_to_enum=True):
|
||||
"""
|
||||
Converts a django rest frameworks field to a graphql field
|
||||
and marks the field as required if we are creating an input type
|
||||
|
|
@ -33,10 +31,7 @@ def convert_serializer_field(
|
|||
graphql_type = get_graphene_type_from_serializer_field(field)
|
||||
|
||||
args = []
|
||||
kwargs = {
|
||||
"description": field.help_text,
|
||||
"required": is_input and field.required and not force_optional,
|
||||
}
|
||||
kwargs = {"description": field.help_text, "required": is_input and field.required}
|
||||
|
||||
# if it is a tuple or a list it means that we are returning
|
||||
# the graphql type and the child type
|
||||
|
|
|
|||
|
|
@ -96,7 +96,8 @@ def test_should_regex_convert_string():
|
|||
|
||||
|
||||
def test_should_uuid_convert_string():
|
||||
assert_conversion(serializers.UUIDField, graphene.String)
|
||||
if hasattr(serializers, "UUIDField"):
|
||||
assert_conversion(serializers.UUIDField, graphene.String)
|
||||
|
||||
|
||||
def test_should_model_convert_field():
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ import datetime
|
|||
from pytest import raises
|
||||
from rest_framework import serializers
|
||||
|
||||
from graphene import Field, ResolveInfo, String
|
||||
from graphene import Field, ResolveInfo
|
||||
from graphene.types.inputobjecttype import InputObjectType
|
||||
|
||||
from ...types import DjangoObjectType
|
||||
|
|
@ -105,16 +105,6 @@ def test_exclude_fields():
|
|||
assert "created" not in MyMutation.Input._meta.fields
|
||||
|
||||
|
||||
def test_model_serializer_optional_fields():
|
||||
class MyMutation(SerializerMutation):
|
||||
class Meta:
|
||||
serializer_class = MyModelSerializer
|
||||
optional_fields = ("cool_name",)
|
||||
|
||||
assert "cool_name" in MyMutation.Input._meta.fields
|
||||
assert MyMutation.Input._meta.fields["cool_name"].type == String
|
||||
|
||||
|
||||
def test_write_only_field():
|
||||
class WriteOnlyFieldModelSerializer(serializers.ModelSerializer):
|
||||
password = serializers.CharField(write_only=True)
|
||||
|
|
@ -275,7 +265,7 @@ def test_perform_mutate_success():
|
|||
result = MyMethodMutation.mutate_and_get_payload(
|
||||
None,
|
||||
mock_info(),
|
||||
**{"cool_name": "Narf", "last_edited": datetime.date(2020, 1, 4)},
|
||||
**{"cool_name": "Narf", "last_edited": datetime.date(2020, 1, 4)}
|
||||
)
|
||||
|
||||
assert result.errors is None
|
||||
|
|
|
|||
|
|
@ -30,8 +30,6 @@ DEFAULTS = {
|
|||
# Max items returned in ConnectionFields / FilterConnectionFields
|
||||
"RELAY_CONNECTION_MAX_LIMIT": 100,
|
||||
"CAMELCASE_ERRORS": True,
|
||||
# Automatically convert Choice fields of Django into Enum fields
|
||||
"DJANGO_CHOICE_FIELD_ENUM_CONVERT": True,
|
||||
# Set to True to enable v2 naming convention for choice field Enum's
|
||||
"DJANGO_CHOICE_FIELD_ENUM_V2_NAMING": False,
|
||||
"DJANGO_CHOICE_FIELD_ENUM_CUSTOM_NAME": None,
|
||||
|
|
@ -42,10 +40,8 @@ DEFAULTS = {
|
|||
# https://github.com/graphql/graphiql/tree/main/packages/graphiql#options
|
||||
"GRAPHIQL_HEADER_EDITOR_ENABLED": True,
|
||||
"GRAPHIQL_SHOULD_PERSIST_HEADERS": False,
|
||||
"GRAPHIQL_INPUT_VALUE_DEPRECATION": False,
|
||||
"ATOMIC_MUTATIONS": False,
|
||||
"TESTING_ENDPOINT": "/graphql",
|
||||
"MAX_VALIDATION_ERRORS": None,
|
||||
}
|
||||
|
||||
if settings.DEBUG:
|
||||
|
|
|
|||
|
|
@ -122,7 +122,6 @@
|
|||
onEditOperationName: onEditOperationName,
|
||||
isHeadersEditorEnabled: GRAPHENE_SETTINGS.graphiqlHeaderEditorEnabled,
|
||||
shouldPersistHeaders: GRAPHENE_SETTINGS.graphiqlShouldPersistHeaders,
|
||||
inputValueDeprecation: GRAPHENE_SETTINGS.graphiqlInputValueDeprecation,
|
||||
query: query,
|
||||
};
|
||||
if (parameters.variables) {
|
||||
|
|
|
|||
|
|
@ -54,7 +54,6 @@ add "&raw" to the end of the URL within a browser.
|
|||
{% endif %}
|
||||
graphiqlHeaderEditorEnabled: {{ graphiql_header_editor_enabled|yesno:"true,false" }},
|
||||
graphiqlShouldPersistHeaders: {{ graphiql_should_persist_headers|yesno:"true,false" }},
|
||||
graphiqlInputValueDeprecation: {{ graphiql_input_value_deprecation|yesno:"true,false" }},
|
||||
};
|
||||
</script>
|
||||
<script src="{% static 'graphene_django/graphiql.js' %}"></script>
|
||||
|
|
|
|||
|
|
@ -1,43 +1,11 @@
|
|||
import django
|
||||
from django.db import models
|
||||
from django.utils.translation import gettext_lazy as _
|
||||
|
||||
CHOICES = ((1, "this"), (2, _("that")))
|
||||
|
||||
|
||||
def get_choices_as_class(choices_class):
|
||||
if django.VERSION >= (5, 0):
|
||||
return choices_class
|
||||
else:
|
||||
return choices_class.choices
|
||||
|
||||
|
||||
def get_choices_as_callable(choices_class):
|
||||
if django.VERSION >= (5, 0):
|
||||
|
||||
def choices():
|
||||
return choices_class.choices
|
||||
|
||||
return choices
|
||||
else:
|
||||
return choices_class.choices
|
||||
|
||||
|
||||
class TypedIntChoice(models.IntegerChoices):
|
||||
CHOICE_THIS = 1
|
||||
CHOICE_THAT = 2
|
||||
|
||||
|
||||
class TypedStrChoice(models.TextChoices):
|
||||
CHOICE_THIS = "this"
|
||||
CHOICE_THAT = "that"
|
||||
|
||||
|
||||
class Person(models.Model):
|
||||
name = models.CharField(max_length=30)
|
||||
parent = models.ForeignKey(
|
||||
"self", on_delete=models.CASCADE, null=True, blank=True, related_name="children"
|
||||
)
|
||||
|
||||
|
||||
class Pet(models.Model):
|
||||
|
|
@ -80,21 +48,6 @@ class Reporter(models.Model):
|
|||
email = models.EmailField()
|
||||
pets = models.ManyToManyField("self")
|
||||
a_choice = models.IntegerField(choices=CHOICES, null=True, blank=True)
|
||||
typed_choice = models.IntegerField(
|
||||
choices=TypedIntChoice.choices,
|
||||
null=True,
|
||||
blank=True,
|
||||
)
|
||||
class_choice = models.IntegerField(
|
||||
choices=get_choices_as_class(TypedIntChoice),
|
||||
null=True,
|
||||
blank=True,
|
||||
)
|
||||
callable_choice = models.IntegerField(
|
||||
choices=get_choices_as_callable(TypedStrChoice),
|
||||
null=True,
|
||||
blank=True,
|
||||
)
|
||||
objects = models.Manager()
|
||||
doe_objects = DoeReporterManager()
|
||||
fans = models.ManyToManyField(Person)
|
||||
|
|
@ -144,7 +97,7 @@ class CNNReporter(Reporter):
|
|||
|
||||
class APNewsReporter(Reporter):
|
||||
"""
|
||||
This class only inherits from Reporter for testing multi table inheritance
|
||||
This class only inherits from Reporter for testing multi table inheritence
|
||||
similar to what you'd see in django-polymorphic
|
||||
"""
|
||||
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ from ..converter import (
|
|||
)
|
||||
from ..registry import Registry
|
||||
from ..types import DjangoObjectType
|
||||
from .models import Article, Film, FilmDetails, Reporter, TypedIntChoice, TypedStrChoice
|
||||
from .models import Article, Film, FilmDetails, Reporter
|
||||
|
||||
# from graphene.core.types.custom_scalars import DateTime, Time, JSONString
|
||||
|
||||
|
|
@ -53,8 +53,9 @@ def assert_conversion(django_field, graphene_field, *args, **kwargs):
|
|||
|
||||
|
||||
def test_should_unknown_django_field_raise_exception():
|
||||
with raises(Exception, match="Don't know how to convert the Django field"):
|
||||
with raises(Exception) as excinfo:
|
||||
convert_django_field(None)
|
||||
assert "Don't know how to convert the Django field" in str(excinfo.value)
|
||||
|
||||
|
||||
def test_should_date_time_convert_string():
|
||||
|
|
@ -114,7 +115,8 @@ def test_should_big_auto_convert_id():
|
|||
|
||||
|
||||
def test_should_small_auto_convert_id():
|
||||
assert_conversion(models.SmallAutoField, graphene.ID, primary_key=True)
|
||||
if hasattr(models, "SmallAutoField"):
|
||||
assert_conversion(models.SmallAutoField, graphene.ID, primary_key=True)
|
||||
|
||||
|
||||
def test_should_uuid_convert_id():
|
||||
|
|
@ -164,34 +166,14 @@ def test_field_with_choices_convert_enum():
|
|||
help_text="Language", choices=(("es", "Spanish"), ("en", "English"))
|
||||
)
|
||||
|
||||
class ChoicesModel(models.Model):
|
||||
class TranslatedModel(models.Model):
|
||||
language = field
|
||||
|
||||
class Meta:
|
||||
app_label = "test"
|
||||
|
||||
graphene_type = convert_django_field_with_choices(field).type.of_type
|
||||
assert graphene_type._meta.name == "TestChoicesModelLanguageChoices"
|
||||
assert graphene_type._meta.enum.__members__["ES"].value == "es"
|
||||
assert graphene_type._meta.enum.__members__["ES"].description == "Spanish"
|
||||
assert graphene_type._meta.enum.__members__["EN"].value == "en"
|
||||
assert graphene_type._meta.enum.__members__["EN"].description == "English"
|
||||
|
||||
|
||||
def test_field_with_callable_choices_convert_enum():
|
||||
def get_choices():
|
||||
return ("es", "Spanish"), ("en", "English")
|
||||
|
||||
field = models.CharField(help_text="Language", choices=get_choices)
|
||||
|
||||
class CallableChoicesModel(models.Model):
|
||||
language = field
|
||||
|
||||
class Meta:
|
||||
app_label = "test"
|
||||
|
||||
graphene_type = convert_django_field_with_choices(field).type.of_type
|
||||
assert graphene_type._meta.name == "TestCallableChoicesModelLanguageChoices"
|
||||
assert graphene_type._meta.name == "TestTranslatedModelLanguageChoices"
|
||||
assert graphene_type._meta.enum.__members__["ES"].value == "es"
|
||||
assert graphene_type._meta.enum.__members__["ES"].description == "Spanish"
|
||||
assert graphene_type._meta.enum.__members__["EN"].value == "en"
|
||||
|
|
@ -441,102 +423,35 @@ def test_choice_enum_blank_value():
|
|||
class ReporterType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Reporter
|
||||
fields = ("callable_choice",)
|
||||
fields = (
|
||||
"first_name",
|
||||
"a_choice",
|
||||
)
|
||||
|
||||
class Query(graphene.ObjectType):
|
||||
reporter = graphene.Field(ReporterType)
|
||||
|
||||
def resolve_reporter(root, info):
|
||||
# return a model instance with blank choice field value
|
||||
return Reporter(callable_choice="")
|
||||
return Reporter.objects.first()
|
||||
|
||||
schema = graphene.Schema(query=Query)
|
||||
|
||||
# Create model with empty choice option
|
||||
Reporter.objects.create(
|
||||
first_name="Bridget", last_name="Jones", email="bridget@example.com"
|
||||
)
|
||||
|
||||
result = schema.execute(
|
||||
"""
|
||||
query {
|
||||
reporter {
|
||||
callableChoice
|
||||
firstName
|
||||
aChoice
|
||||
}
|
||||
}
|
||||
"""
|
||||
)
|
||||
assert not result.errors
|
||||
assert result.data == {
|
||||
"reporter": {"callableChoice": None},
|
||||
"reporter": {"firstName": "Bridget", "aChoice": None},
|
||||
}
|
||||
|
||||
|
||||
def test_typed_choice_value():
|
||||
"""Test that typed choices fields are resolved correctly to the enum values"""
|
||||
|
||||
class ReporterType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Reporter
|
||||
fields = ("typed_choice", "class_choice", "callable_choice")
|
||||
|
||||
class Query(graphene.ObjectType):
|
||||
reporter = graphene.Field(ReporterType)
|
||||
|
||||
def resolve_reporter(root, info):
|
||||
# assign choice values to the fields instead of their str or int values
|
||||
return Reporter(
|
||||
typed_choice=TypedIntChoice.CHOICE_THIS,
|
||||
class_choice=TypedIntChoice.CHOICE_THAT,
|
||||
callable_choice=TypedStrChoice.CHOICE_THIS,
|
||||
)
|
||||
|
||||
class CreateReporter(graphene.Mutation):
|
||||
reporter = graphene.Field(ReporterType)
|
||||
|
||||
def mutate(root, info, **kwargs):
|
||||
return CreateReporter(
|
||||
reporter=Reporter(
|
||||
typed_choice=TypedIntChoice.CHOICE_THIS,
|
||||
class_choice=TypedIntChoice.CHOICE_THAT,
|
||||
callable_choice=TypedStrChoice.CHOICE_THIS,
|
||||
),
|
||||
)
|
||||
|
||||
class Mutation(graphene.ObjectType):
|
||||
create_reporter = CreateReporter.Field()
|
||||
|
||||
schema = graphene.Schema(query=Query, mutation=Mutation)
|
||||
|
||||
reporter_fragment = """
|
||||
fragment reporter on ReporterType {
|
||||
typedChoice
|
||||
classChoice
|
||||
callableChoice
|
||||
}
|
||||
"""
|
||||
|
||||
expected_reporter = {
|
||||
"typedChoice": "A_1",
|
||||
"classChoice": "A_2",
|
||||
"callableChoice": "THIS",
|
||||
}
|
||||
|
||||
result = schema.execute(
|
||||
reporter_fragment
|
||||
+ """
|
||||
query {
|
||||
reporter { ...reporter }
|
||||
}
|
||||
"""
|
||||
)
|
||||
assert not result.errors
|
||||
assert result.data["reporter"] == expected_reporter
|
||||
|
||||
result = schema.execute(
|
||||
reporter_fragment
|
||||
+ """
|
||||
mutation {
|
||||
createReporter {
|
||||
reporter { ...reporter }
|
||||
}
|
||||
}
|
||||
"""
|
||||
)
|
||||
assert not result.errors
|
||||
assert result.data["createReporter"]["reporter"] == expected_reporter
|
||||
|
|
|
|||
|
|
@ -12,23 +12,17 @@ from .models import (
|
|||
Article as ArticleModel,
|
||||
Film as FilmModel,
|
||||
FilmDetails as FilmDetailsModel,
|
||||
Person as PersonModel,
|
||||
Reporter as ReporterModel,
|
||||
)
|
||||
|
||||
|
||||
class TestDjangoListField:
|
||||
def test_only_django_object_types(self):
|
||||
class Query(ObjectType):
|
||||
something = DjangoListField(String)
|
||||
class TestType(ObjectType):
|
||||
foo = String()
|
||||
|
||||
with pytest.raises(TypeError) as excinfo:
|
||||
Schema(query=Query)
|
||||
|
||||
assert (
|
||||
"Query fields cannot be resolved. DjangoListField only accepts DjangoObjectType types as underlying type"
|
||||
in str(excinfo.value)
|
||||
)
|
||||
with pytest.raises(AssertionError):
|
||||
DjangoListField(TestType)
|
||||
|
||||
def test_only_import_paths(self):
|
||||
list_field = DjangoListField("graphene_django.tests.schema.Human")
|
||||
|
|
@ -268,69 +262,6 @@ class TestDjangoListField:
|
|||
]
|
||||
}
|
||||
|
||||
def test_same_type_nested_list_field(self):
|
||||
class Person(DjangoObjectType):
|
||||
class Meta:
|
||||
model = PersonModel
|
||||
fields = ("name", "parent")
|
||||
|
||||
children = DjangoListField(lambda: Person)
|
||||
|
||||
class Query(ObjectType):
|
||||
persons = DjangoListField(Person)
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
query = """
|
||||
query {
|
||||
persons {
|
||||
name
|
||||
children {
|
||||
name
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
|
||||
p1 = PersonModel.objects.create(name="Tara")
|
||||
PersonModel.objects.create(name="Debra")
|
||||
|
||||
PersonModel.objects.create(
|
||||
name="Toto",
|
||||
parent=p1,
|
||||
)
|
||||
PersonModel.objects.create(
|
||||
name="Tata",
|
||||
parent=p1,
|
||||
)
|
||||
|
||||
result = schema.execute(query)
|
||||
|
||||
assert not result.errors
|
||||
assert result.data == {
|
||||
"persons": [
|
||||
{
|
||||
"name": "Tara",
|
||||
"children": [
|
||||
{"name": "Toto"},
|
||||
{"name": "Tata"},
|
||||
],
|
||||
},
|
||||
{
|
||||
"name": "Debra",
|
||||
"children": [],
|
||||
},
|
||||
{
|
||||
"name": "Toto",
|
||||
"children": [],
|
||||
},
|
||||
{
|
||||
"name": "Tata",
|
||||
"children": [],
|
||||
},
|
||||
]
|
||||
}
|
||||
|
||||
def test_get_queryset_filter(self):
|
||||
class Reporter(DjangoObjectType):
|
||||
class Meta:
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@ class TestShouldCallGetQuerySetOnForeignKey:
|
|||
class ReporterType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Reporter
|
||||
fields = "__all__"
|
||||
|
||||
@classmethod
|
||||
def get_queryset(cls, queryset, info):
|
||||
|
|
@ -37,7 +36,6 @@ class TestShouldCallGetQuerySetOnForeignKey:
|
|||
class ArticleType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Article
|
||||
fields = "__all__"
|
||||
|
||||
@classmethod
|
||||
def get_queryset(cls, queryset, info):
|
||||
|
|
@ -202,7 +200,6 @@ class TestShouldCallGetQuerySetOnForeignKeyNode:
|
|||
class ReporterType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Reporter
|
||||
fields = "__all__"
|
||||
interfaces = (Node,)
|
||||
|
||||
@classmethod
|
||||
|
|
@ -214,7 +211,6 @@ class TestShouldCallGetQuerySetOnForeignKeyNode:
|
|||
class ArticleType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Article
|
||||
fields = "__all__"
|
||||
interfaces = (Node,)
|
||||
|
||||
@classmethod
|
||||
|
|
@ -374,7 +370,6 @@ class TestShouldCallGetQuerySetOnOneToOne:
|
|||
class FilmDetailsType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = FilmDetails
|
||||
fields = "__all__"
|
||||
|
||||
@classmethod
|
||||
def get_queryset(cls, queryset, info):
|
||||
|
|
@ -385,7 +380,6 @@ class TestShouldCallGetQuerySetOnOneToOne:
|
|||
class FilmType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Film
|
||||
fields = "__all__"
|
||||
|
||||
@classmethod
|
||||
def get_queryset(cls, queryset, info):
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
import base64
|
||||
import datetime
|
||||
from unittest.mock import ANY, Mock
|
||||
|
||||
import pytest
|
||||
from django.db import models
|
||||
|
|
@ -2001,62 +2000,14 @@ def test_connection_should_succeed_if_last_higher_than_number_of_objects():
|
|||
assert result.data == expected
|
||||
|
||||
|
||||
def test_connection_should_call_resolver_function():
|
||||
resolver_mock = Mock(
|
||||
name="resolver",
|
||||
return_value=[
|
||||
Reporter(first_name="Some", last_name="One"),
|
||||
Reporter(first_name="John", last_name="Doe"),
|
||||
],
|
||||
)
|
||||
|
||||
class ReporterType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Reporter
|
||||
fields = "__all__"
|
||||
interfaces = [Node]
|
||||
|
||||
class Query(graphene.ObjectType):
|
||||
reporters = DjangoConnectionField(ReporterType, resolver=resolver_mock)
|
||||
|
||||
schema = graphene.Schema(query=Query)
|
||||
result = schema.execute(
|
||||
"""
|
||||
query {
|
||||
reporters {
|
||||
edges {
|
||||
node {
|
||||
firstName
|
||||
lastName
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
)
|
||||
|
||||
resolver_mock.assert_called_once_with(None, ANY)
|
||||
assert not result.errors
|
||||
assert result.data == {
|
||||
"reporters": {
|
||||
"edges": [
|
||||
{"node": {"firstName": "Some", "lastName": "One"}},
|
||||
{"node": {"firstName": "John", "lastName": "Doe"}},
|
||||
],
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def test_should_query_nullable_foreign_key():
|
||||
class PetType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Pet
|
||||
fields = "__all__"
|
||||
|
||||
class PersonType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Person
|
||||
fields = "__all__"
|
||||
|
||||
class Query(graphene.ObjectType):
|
||||
pet = graphene.Field(PetType, name=graphene.String(required=True))
|
||||
|
|
@ -2071,8 +2022,10 @@ def test_should_query_nullable_foreign_key():
|
|||
schema = graphene.Schema(query=Query)
|
||||
|
||||
person = Person.objects.create(name="Jane")
|
||||
Pet.objects.create(name="Stray dog", age=1)
|
||||
Pet.objects.create(name="Jane's dog", owner=person, age=1)
|
||||
[
|
||||
Pet.objects.create(name="Stray dog", age=1),
|
||||
Pet.objects.create(name="Jane's dog", owner=person, age=1),
|
||||
]
|
||||
|
||||
query_pet = """
|
||||
query getPet($name: String!) {
|
||||
|
|
@ -2115,7 +2068,6 @@ def test_should_query_nullable_one_to_one_relation_with_custom_resolver():
|
|||
class FilmType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = Film
|
||||
fields = "__all__"
|
||||
|
||||
@classmethod
|
||||
def get_queryset(cls, queryset, info):
|
||||
|
|
@ -2124,7 +2076,6 @@ def test_should_query_nullable_one_to_one_relation_with_custom_resolver():
|
|||
class FilmDetailsType(DjangoObjectType):
|
||||
class Meta:
|
||||
model = FilmDetails
|
||||
fields = "__all__"
|
||||
|
||||
@classmethod
|
||||
def get_queryset(cls, queryset, info):
|
||||
|
|
|
|||
|
|
@ -40,9 +40,6 @@ def test_should_map_fields_correctly():
|
|||
"email",
|
||||
"pets",
|
||||
"a_choice",
|
||||
"typed_choice",
|
||||
"class_choice",
|
||||
"callable_choice",
|
||||
"fans",
|
||||
"reporter_type",
|
||||
]
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
import warnings
|
||||
from collections import OrderedDict, defaultdict
|
||||
from textwrap import dedent
|
||||
from unittest.mock import patch
|
||||
|
|
@ -77,9 +76,6 @@ def test_django_objecttype_map_correct_fields():
|
|||
"email",
|
||||
"pets",
|
||||
"a_choice",
|
||||
"typed_choice",
|
||||
"class_choice",
|
||||
"callable_choice",
|
||||
"fans",
|
||||
"reporter_type",
|
||||
]
|
||||
|
|
@ -189,9 +185,6 @@ def test_schema_representation():
|
|||
email: String!
|
||||
pets: [Reporter!]!
|
||||
aChoice: TestsReporterAChoiceChoices
|
||||
typedChoice: TestsReporterTypedChoiceChoices
|
||||
classChoice: TestsReporterClassChoiceChoices
|
||||
callableChoice: TestsReporterCallableChoiceChoices
|
||||
reporterType: TestsReporterReporterTypeChoices
|
||||
articles(offset: Int, before: String, after: String, first: Int, last: Int): ArticleConnection!
|
||||
}
|
||||
|
|
@ -205,33 +198,6 @@ def test_schema_representation():
|
|||
A_2
|
||||
}
|
||||
|
||||
\"""An enumeration.\"""
|
||||
enum TestsReporterTypedChoiceChoices {
|
||||
\"""Choice This\"""
|
||||
A_1
|
||||
|
||||
\"""Choice That\"""
|
||||
A_2
|
||||
}
|
||||
|
||||
\"""An enumeration.\"""
|
||||
enum TestsReporterClassChoiceChoices {
|
||||
\"""Choice This\"""
|
||||
A_1
|
||||
|
||||
\"""Choice That\"""
|
||||
A_2
|
||||
}
|
||||
|
||||
\"""An enumeration.\"""
|
||||
enum TestsReporterCallableChoiceChoices {
|
||||
\"""Choice This\"""
|
||||
THIS
|
||||
|
||||
\"""Choice That\"""
|
||||
THAT
|
||||
}
|
||||
|
||||
\"""An enumeration.\"""
|
||||
enum TestsReporterReporterTypeChoices {
|
||||
\"""Regular\"""
|
||||
|
|
@ -433,7 +399,7 @@ def test_django_objecttype_fields_exist_on_model():
|
|||
with pytest.warns(
|
||||
UserWarning,
|
||||
match=r"Field name .* matches an attribute on Django model .* but it's not a model field",
|
||||
):
|
||||
) as record:
|
||||
|
||||
class Reporter2(DjangoObjectType):
|
||||
class Meta:
|
||||
|
|
@ -441,8 +407,7 @@ def test_django_objecttype_fields_exist_on_model():
|
|||
fields = ["first_name", "some_method", "email"]
|
||||
|
||||
# Don't warn if selecting a custom field
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("error")
|
||||
with pytest.warns(None) as record:
|
||||
|
||||
class Reporter3(DjangoObjectType):
|
||||
custom_field = String()
|
||||
|
|
@ -451,6 +416,8 @@ def test_django_objecttype_fields_exist_on_model():
|
|||
model = ReporterModel
|
||||
fields = ["first_name", "custom_field", "email"]
|
||||
|
||||
assert len(record) == 0
|
||||
|
||||
|
||||
@with_local_registry
|
||||
def test_django_objecttype_exclude_fields_exist_on_model():
|
||||
|
|
@ -478,14 +445,15 @@ def test_django_objecttype_exclude_fields_exist_on_model():
|
|||
exclude = ["custom_field"]
|
||||
|
||||
# Don't warn on exclude fields
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("error")
|
||||
with pytest.warns(None) as record:
|
||||
|
||||
class Reporter4(DjangoObjectType):
|
||||
class Meta:
|
||||
model = ReporterModel
|
||||
exclude = ["email", "first_name"]
|
||||
|
||||
assert len(record) == 0
|
||||
|
||||
|
||||
@with_local_registry
|
||||
def test_django_objecttype_neither_fields_nor_exclude():
|
||||
|
|
@ -499,22 +467,24 @@ def test_django_objecttype_neither_fields_nor_exclude():
|
|||
class Meta:
|
||||
model = ReporterModel
|
||||
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("error")
|
||||
with pytest.warns(None) as record:
|
||||
|
||||
class Reporter2(DjangoObjectType):
|
||||
class Meta:
|
||||
model = ReporterModel
|
||||
fields = ["email"]
|
||||
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("error")
|
||||
assert len(record) == 0
|
||||
|
||||
with pytest.warns(None) as record:
|
||||
|
||||
class Reporter3(DjangoObjectType):
|
||||
class Meta:
|
||||
model = ReporterModel
|
||||
exclude = ["email"]
|
||||
|
||||
assert len(record) == 0
|
||||
|
||||
|
||||
def custom_enum_name(field):
|
||||
return f"CustomEnum{field.name.title()}"
|
||||
|
|
@ -691,122 +661,6 @@ class TestDjangoObjectType:
|
|||
}"""
|
||||
)
|
||||
|
||||
def test_django_objecttype_convert_choices_global_false(
|
||||
self, graphene_settings, PetModel
|
||||
):
|
||||
graphene_settings.DJANGO_CHOICE_FIELD_ENUM_CONVERT = False
|
||||
|
||||
class Pet(DjangoObjectType):
|
||||
class Meta:
|
||||
model = PetModel
|
||||
fields = "__all__"
|
||||
|
||||
class Query(ObjectType):
|
||||
pet = Field(Pet)
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
assert str(schema) == dedent(
|
||||
"""\
|
||||
type Query {
|
||||
pet: Pet
|
||||
}
|
||||
|
||||
type Pet {
|
||||
id: ID!
|
||||
kind: String!
|
||||
cuteness: Int!
|
||||
}"""
|
||||
)
|
||||
|
||||
def test_django_objecttype_convert_choices_true_global_false(
|
||||
self, graphene_settings, PetModel
|
||||
):
|
||||
graphene_settings.DJANGO_CHOICE_FIELD_ENUM_CONVERT = False
|
||||
|
||||
class Pet(DjangoObjectType):
|
||||
class Meta:
|
||||
model = PetModel
|
||||
fields = "__all__"
|
||||
convert_choices_to_enum = True
|
||||
|
||||
class Query(ObjectType):
|
||||
pet = Field(Pet)
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
assert str(schema) == dedent(
|
||||
"""\
|
||||
type Query {
|
||||
pet: Pet
|
||||
}
|
||||
|
||||
type Pet {
|
||||
id: ID!
|
||||
kind: TestsPetModelKindChoices!
|
||||
cuteness: TestsPetModelCutenessChoices!
|
||||
}
|
||||
|
||||
\"""An enumeration.\"""
|
||||
enum TestsPetModelKindChoices {
|
||||
\"""Cat\"""
|
||||
CAT
|
||||
|
||||
\"""Dog\"""
|
||||
DOG
|
||||
}
|
||||
|
||||
\"""An enumeration.\"""
|
||||
enum TestsPetModelCutenessChoices {
|
||||
\"""Kind of cute\"""
|
||||
A_1
|
||||
|
||||
\"""Pretty cute\"""
|
||||
A_2
|
||||
|
||||
\"""OMG SO CUTE!!!\"""
|
||||
A_3
|
||||
}"""
|
||||
)
|
||||
|
||||
def test_django_objecttype_convert_choices_enum_list_global_false(
|
||||
self, graphene_settings, PetModel
|
||||
):
|
||||
graphene_settings.DJANGO_CHOICE_FIELD_ENUM_CONVERT = False
|
||||
|
||||
class Pet(DjangoObjectType):
|
||||
class Meta:
|
||||
model = PetModel
|
||||
convert_choices_to_enum = ["kind"]
|
||||
fields = "__all__"
|
||||
|
||||
class Query(ObjectType):
|
||||
pet = Field(Pet)
|
||||
|
||||
schema = Schema(query=Query)
|
||||
|
||||
assert str(schema) == dedent(
|
||||
"""\
|
||||
type Query {
|
||||
pet: Pet
|
||||
}
|
||||
|
||||
type Pet {
|
||||
id: ID!
|
||||
kind: TestsPetModelKindChoices!
|
||||
cuteness: Int!
|
||||
}
|
||||
|
||||
\"""An enumeration.\"""
|
||||
enum TestsPetModelKindChoices {
|
||||
\"""Cat\"""
|
||||
CAT
|
||||
|
||||
\"""Dog\"""
|
||||
DOG
|
||||
}"""
|
||||
)
|
||||
|
||||
|
||||
@with_local_registry
|
||||
def test_django_objecttype_name_connection_propagation():
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
import json
|
||||
from http import HTTPStatus
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
|
|
@ -38,7 +37,7 @@ def jl(**kwargs):
|
|||
|
||||
def test_graphiql_is_enabled(client):
|
||||
response = client.get(url_string(), HTTP_ACCEPT="text/html")
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response["Content-Type"].split(";")[0] == "text/html"
|
||||
|
||||
|
||||
|
|
@ -47,7 +46,7 @@ def test_qfactor_graphiql(client):
|
|||
url_string(query="{test}"),
|
||||
HTTP_ACCEPT="application/json;q=0.8, text/html;q=0.9",
|
||||
)
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response["Content-Type"].split(";")[0] == "text/html"
|
||||
|
||||
|
||||
|
|
@ -56,7 +55,7 @@ def test_qfactor_json(client):
|
|||
url_string(query="{test}"),
|
||||
HTTP_ACCEPT="text/html;q=0.8, application/json;q=0.9",
|
||||
)
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response["Content-Type"].split(";")[0] == "application/json"
|
||||
assert response_json(response) == {"data": {"test": "Hello World"}}
|
||||
|
||||
|
|
@ -64,7 +63,7 @@ def test_qfactor_json(client):
|
|||
def test_allows_get_with_query_param(client):
|
||||
response = client.get(url_string(query="{test}"))
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello World"}}
|
||||
|
||||
|
||||
|
|
@ -76,7 +75,7 @@ def test_allows_get_with_variable_values(client):
|
|||
)
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello Dolly"}}
|
||||
|
||||
|
||||
|
|
@ -95,7 +94,7 @@ def test_allows_get_with_operation_name(client):
|
|||
)
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {
|
||||
"data": {"test": "Hello World", "shared": "Hello Everyone"}
|
||||
}
|
||||
|
|
@ -104,7 +103,7 @@ def test_allows_get_with_operation_name(client):
|
|||
def test_reports_validation_errors(client):
|
||||
response = client.get(url_string(query="{ test, unknownOne, unknownTwo }"))
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [
|
||||
{
|
||||
|
|
@ -129,7 +128,7 @@ def test_errors_when_missing_operation_name(client):
|
|||
)
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [
|
||||
{
|
||||
|
|
@ -147,7 +146,7 @@ def test_errors_when_sending_a_mutation_via_get(client):
|
|||
"""
|
||||
)
|
||||
)
|
||||
assert response.status_code == HTTPStatus.METHOD_NOT_ALLOWED
|
||||
assert response.status_code == 405
|
||||
assert response_json(response) == {
|
||||
"errors": [
|
||||
{"message": "Can only perform a mutation operation from a POST request."}
|
||||
|
|
@ -166,7 +165,7 @@ def test_errors_when_selecting_a_mutation_within_a_get(client):
|
|||
)
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.METHOD_NOT_ALLOWED
|
||||
assert response.status_code == 405
|
||||
assert response_json(response) == {
|
||||
"errors": [
|
||||
{"message": "Can only perform a mutation operation from a POST request."}
|
||||
|
|
@ -185,14 +184,14 @@ def test_allows_mutation_to_exist_within_a_get(client):
|
|||
)
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello World"}}
|
||||
|
||||
|
||||
def test_allows_post_with_json_encoding(client):
|
||||
response = client.post(url_string(), j(query="{test}"), "application/json")
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello World"}}
|
||||
|
||||
|
||||
|
|
@ -201,7 +200,7 @@ def test_batch_allows_post_with_json_encoding(client):
|
|||
batch_url_string(), jl(id=1, query="{test}"), "application/json"
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == [
|
||||
{"id": 1, "data": {"test": "Hello World"}, "status": 200}
|
||||
]
|
||||
|
|
@ -210,7 +209,7 @@ def test_batch_allows_post_with_json_encoding(client):
|
|||
def test_batch_fails_if_is_empty(client):
|
||||
response = client.post(batch_url_string(), "[]", "application/json")
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [{"message": "Received an empty list in the batch request."}]
|
||||
}
|
||||
|
|
@ -223,7 +222,7 @@ def test_allows_sending_a_mutation_via_post(client):
|
|||
"application/json",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"writeTest": {"test": "Hello World"}}}
|
||||
|
||||
|
||||
|
|
@ -234,7 +233,7 @@ def test_allows_post_with_url_encoding(client):
|
|||
"application/x-www-form-urlencoded",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello World"}}
|
||||
|
||||
|
||||
|
|
@ -248,7 +247,7 @@ def test_supports_post_json_query_with_string_variables(client):
|
|||
"application/json",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello Dolly"}}
|
||||
|
||||
|
||||
|
|
@ -263,7 +262,7 @@ def test_batch_supports_post_json_query_with_string_variables(client):
|
|||
"application/json",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == [
|
||||
{"id": 1, "data": {"test": "Hello Dolly"}, "status": 200}
|
||||
]
|
||||
|
|
@ -279,7 +278,7 @@ def test_supports_post_json_query_with_json_variables(client):
|
|||
"application/json",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello Dolly"}}
|
||||
|
||||
|
||||
|
|
@ -294,7 +293,7 @@ def test_batch_supports_post_json_query_with_json_variables(client):
|
|||
"application/json",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == [
|
||||
{"id": 1, "data": {"test": "Hello Dolly"}, "status": 200}
|
||||
]
|
||||
|
|
@ -312,7 +311,7 @@ def test_supports_post_url_encoded_query_with_string_variables(client):
|
|||
"application/x-www-form-urlencoded",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello Dolly"}}
|
||||
|
||||
|
||||
|
|
@ -323,7 +322,7 @@ def test_supports_post_json_quey_with_get_variable_values(client):
|
|||
"application/json",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello Dolly"}}
|
||||
|
||||
|
||||
|
|
@ -334,7 +333,7 @@ def test_post_url_encoded_query_with_get_variable_values(client):
|
|||
"application/x-www-form-urlencoded",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello Dolly"}}
|
||||
|
||||
|
||||
|
|
@ -345,7 +344,7 @@ def test_supports_post_raw_text_query_with_get_variable_values(client):
|
|||
"application/graphql",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"test": "Hello Dolly"}}
|
||||
|
||||
|
||||
|
|
@ -366,7 +365,7 @@ def test_allows_post_with_operation_name(client):
|
|||
"application/json",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {
|
||||
"data": {"test": "Hello World", "shared": "Hello Everyone"}
|
||||
}
|
||||
|
|
@ -390,7 +389,7 @@ def test_batch_allows_post_with_operation_name(client):
|
|||
"application/json",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == [
|
||||
{
|
||||
"id": 1,
|
||||
|
|
@ -414,7 +413,7 @@ def test_allows_post_with_get_operation_name(client):
|
|||
"application/graphql",
|
||||
)
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {
|
||||
"data": {"test": "Hello World", "shared": "Hello Everyone"}
|
||||
}
|
||||
|
|
@ -431,7 +430,7 @@ def test_inherited_class_with_attributes_works(client):
|
|||
|
||||
# Check graphiql works
|
||||
response = client.get(url_string(inherited_url), HTTP_ACCEPT="text/html")
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
@pytest.mark.urls("graphene_django.tests.urls_pretty")
|
||||
|
|
@ -453,7 +452,7 @@ def test_supports_pretty_printing_by_request(client):
|
|||
|
||||
def test_handles_field_errors_caught_by_graphql(client):
|
||||
response = client.get(url_string(query="{thrower}"))
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {
|
||||
"data": None,
|
||||
"errors": [
|
||||
|
|
@ -468,7 +467,7 @@ def test_handles_field_errors_caught_by_graphql(client):
|
|||
|
||||
def test_handles_syntax_errors_caught_by_graphql(client):
|
||||
response = client.get(url_string(query="syntaxerror"))
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [
|
||||
{
|
||||
|
|
@ -482,7 +481,7 @@ def test_handles_syntax_errors_caught_by_graphql(client):
|
|||
def test_handles_errors_caused_by_a_lack_of_query(client):
|
||||
response = client.get(url_string())
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [{"message": "Must provide query string."}]
|
||||
}
|
||||
|
|
@ -491,7 +490,7 @@ def test_handles_errors_caused_by_a_lack_of_query(client):
|
|||
def test_handles_not_expected_json_bodies(client):
|
||||
response = client.post(url_string(), "[]", "application/json")
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [{"message": "The received data is not a valid JSON query."}]
|
||||
}
|
||||
|
|
@ -500,7 +499,7 @@ def test_handles_not_expected_json_bodies(client):
|
|||
def test_handles_invalid_json_bodies(client):
|
||||
response = client.post(url_string(), "[oh}", "application/json")
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [{"message": "POST body sent invalid JSON."}]
|
||||
}
|
||||
|
|
@ -515,14 +514,14 @@ def test_handles_django_request_error(client, monkeypatch):
|
|||
valid_json = json.dumps({"foo": "bar"})
|
||||
response = client.post(url_string(), valid_json, "application/json")
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {"errors": [{"message": "foo-bar"}]}
|
||||
|
||||
|
||||
def test_handles_incomplete_json_bodies(client):
|
||||
response = client.post(url_string(), '{"query":', "application/json")
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [{"message": "POST body sent invalid JSON."}]
|
||||
}
|
||||
|
|
@ -534,7 +533,7 @@ def test_handles_plain_post_text(client):
|
|||
"query helloWho($who: String){ test(who: $who) }",
|
||||
"text/plain",
|
||||
)
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [{"message": "Must provide query string."}]
|
||||
}
|
||||
|
|
@ -546,7 +545,7 @@ def test_handles_poorly_formed_variables(client):
|
|||
query="query helloWho($who: String){ test(who: $who) }", variables="who:You"
|
||||
)
|
||||
)
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
assert response.status_code == 400
|
||||
assert response_json(response) == {
|
||||
"errors": [{"message": "Variables are invalid JSON."}]
|
||||
}
|
||||
|
|
@ -554,7 +553,7 @@ def test_handles_poorly_formed_variables(client):
|
|||
|
||||
def test_handles_unsupported_http_methods(client):
|
||||
response = client.put(url_string(query="{test}"))
|
||||
assert response.status_code == HTTPStatus.METHOD_NOT_ALLOWED
|
||||
assert response.status_code == 405
|
||||
assert response["Allow"] == "GET, POST"
|
||||
assert response_json(response) == {
|
||||
"errors": [{"message": "GraphQL only supports GET and POST requests."}]
|
||||
|
|
@ -564,7 +563,7 @@ def test_handles_unsupported_http_methods(client):
|
|||
def test_passes_request_into_context_request(client):
|
||||
response = client.get(url_string(query="{request}", q="testing"))
|
||||
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
assert response.status_code == 200
|
||||
assert response_json(response) == {"data": {"request": "testing"}}
|
||||
|
||||
|
||||
|
|
@ -828,97 +827,3 @@ def test_query_errors_atomic_request(set_rollback_mock, client):
|
|||
def test_query_errors_non_atomic(set_rollback_mock, client):
|
||||
client.get(url_string(query="force error"))
|
||||
set_rollback_mock.assert_not_called()
|
||||
|
||||
|
||||
VALIDATION_URLS = [
|
||||
"/graphql/validation/",
|
||||
"/graphql/validation/alternative/",
|
||||
"/graphql/validation/inherited/",
|
||||
]
|
||||
|
||||
QUERY_WITH_TWO_INTROSPECTIONS = """
|
||||
query Instrospection {
|
||||
queryType: __schema {
|
||||
queryType {name}
|
||||
}
|
||||
mutationType: __schema {
|
||||
mutationType {name}
|
||||
}
|
||||
}
|
||||
"""
|
||||
|
||||
N_INTROSPECTIONS = 2
|
||||
|
||||
INTROSPECTION_DISALLOWED_ERROR_MESSAGE = "introspection is disabled"
|
||||
MAX_VALIDATION_ERRORS_EXCEEDED_MESSAGE = "too many validation errors"
|
||||
|
||||
|
||||
@pytest.mark.urls("graphene_django.tests.urls_validation")
|
||||
def test_allow_introspection(client):
|
||||
response = client.post(
|
||||
url_string("/graphql/", query="{__schema {queryType {name}}}")
|
||||
)
|
||||
assert response.status_code == HTTPStatus.OK
|
||||
|
||||
assert response_json(response) == {
|
||||
"data": {"__schema": {"queryType": {"name": "QueryRoot"}}}
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.parametrize("url", VALIDATION_URLS)
|
||||
@pytest.mark.urls("graphene_django.tests.urls_validation")
|
||||
def test_validation_disallow_introspection(client, url):
|
||||
response = client.post(url_string(url, query="{__schema {queryType {name}}}"))
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
|
||||
json_response = response_json(response)
|
||||
assert "data" not in json_response
|
||||
assert "errors" in json_response
|
||||
assert len(json_response["errors"]) == 1
|
||||
|
||||
error_message = json_response["errors"][0]["message"]
|
||||
assert INTROSPECTION_DISALLOWED_ERROR_MESSAGE in error_message
|
||||
|
||||
|
||||
@pytest.mark.parametrize("url", VALIDATION_URLS)
|
||||
@pytest.mark.urls("graphene_django.tests.urls_validation")
|
||||
@patch(
|
||||
"graphene_django.settings.graphene_settings.MAX_VALIDATION_ERRORS", N_INTROSPECTIONS
|
||||
)
|
||||
def test_within_max_validation_errors(client, url):
|
||||
response = client.post(url_string(url, query=QUERY_WITH_TWO_INTROSPECTIONS))
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
|
||||
json_response = response_json(response)
|
||||
assert "data" not in json_response
|
||||
assert "errors" in json_response
|
||||
assert len(json_response["errors"]) == N_INTROSPECTIONS
|
||||
|
||||
error_messages = [error["message"].lower() for error in json_response["errors"]]
|
||||
|
||||
n_introspection_error_messages = sum(
|
||||
INTROSPECTION_DISALLOWED_ERROR_MESSAGE in msg for msg in error_messages
|
||||
)
|
||||
assert n_introspection_error_messages == N_INTROSPECTIONS
|
||||
|
||||
assert all(
|
||||
MAX_VALIDATION_ERRORS_EXCEEDED_MESSAGE not in msg for msg in error_messages
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("url", VALIDATION_URLS)
|
||||
@pytest.mark.urls("graphene_django.tests.urls_validation")
|
||||
@patch("graphene_django.settings.graphene_settings.MAX_VALIDATION_ERRORS", 1)
|
||||
def test_exceeds_max_validation_errors(client, url):
|
||||
response = client.post(url_string(url, query=QUERY_WITH_TWO_INTROSPECTIONS))
|
||||
|
||||
assert response.status_code == HTTPStatus.BAD_REQUEST
|
||||
|
||||
json_response = response_json(response)
|
||||
assert "data" not in json_response
|
||||
assert "errors" in json_response
|
||||
|
||||
error_messages = (error["message"].lower() for error in json_response["errors"])
|
||||
assert any(MAX_VALIDATION_ERRORS_EXCEEDED_MESSAGE in msg for msg in error_messages)
|
||||
|
|
|
|||
|
|
@ -1,26 +0,0 @@
|
|||
from django.urls import path
|
||||
|
||||
from graphene.validation import DisableIntrospection
|
||||
|
||||
from ..views import GraphQLView
|
||||
from .schema_view import schema
|
||||
|
||||
|
||||
class View(GraphQLView):
|
||||
schema = schema
|
||||
|
||||
|
||||
class NoIntrospectionView(View):
|
||||
validation_rules = (DisableIntrospection,)
|
||||
|
||||
|
||||
class NoIntrospectionViewInherited(NoIntrospectionView):
|
||||
pass
|
||||
|
||||
|
||||
urlpatterns = [
|
||||
path("graphql/", View.as_view()),
|
||||
path("graphql/validation/", View.as_view(validation_rules=(DisableIntrospection,))),
|
||||
path("graphql/validation/alternative/", NoIntrospectionView.as_view()),
|
||||
path("graphql/validation/inherited/", NoIntrospectionViewInherited.as_view()),
|
||||
]
|
||||
|
|
@ -23,7 +23,7 @@ ALL_FIELDS = "__all__"
|
|||
|
||||
|
||||
def construct_fields(
|
||||
model, registry, only_fields, exclude_fields, convert_choices_to_enum=None
|
||||
model, registry, only_fields, exclude_fields, convert_choices_to_enum
|
||||
):
|
||||
_model_fields = get_model_fields(model)
|
||||
|
||||
|
|
@ -47,7 +47,7 @@ def construct_fields(
|
|||
continue
|
||||
|
||||
_convert_choices_to_enum = convert_choices_to_enum
|
||||
if isinstance(_convert_choices_to_enum, list):
|
||||
if not isinstance(_convert_choices_to_enum, bool):
|
||||
# then `convert_choices_to_enum` is a list of field names to convert
|
||||
if name in _convert_choices_to_enum:
|
||||
_convert_choices_to_enum = True
|
||||
|
|
@ -102,8 +102,10 @@ def validate_fields(type_, model, fields, only_fields, exclude_fields):
|
|||
if name in all_field_names:
|
||||
# Field is a custom field
|
||||
warnings.warn(
|
||||
f'Excluding the custom field "{name}" on DjangoObjectType "{type_}" has no effect. '
|
||||
'Either remove the custom field or remove the field from the "exclude" list.'
|
||||
(
|
||||
'Excluding the custom field "{field_name}" on DjangoObjectType "{type_}" has no effect. '
|
||||
'Either remove the custom field or remove the field from the "exclude" list.'
|
||||
).format(field_name=name, type_=type_)
|
||||
)
|
||||
else:
|
||||
if not hasattr(model, name):
|
||||
|
|
@ -146,7 +148,7 @@ class DjangoObjectType(ObjectType):
|
|||
connection_class=None,
|
||||
use_connection=None,
|
||||
interfaces=(),
|
||||
convert_choices_to_enum=None,
|
||||
convert_choices_to_enum=True,
|
||||
_meta=None,
|
||||
**options,
|
||||
):
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ import warnings
|
|||
from django.test import Client, TestCase, TransactionTestCase
|
||||
|
||||
from graphene_django.settings import graphene_settings
|
||||
from graphene_django.utils.utils import _DJANGO_VERSION_AT_LEAST_4_2
|
||||
|
||||
DEFAULT_GRAPHQL_URL = "/graphql"
|
||||
|
||||
|
|
@ -56,14 +55,8 @@ def graphql_query(
|
|||
else:
|
||||
body["variables"] = {"input": input_data}
|
||||
if headers:
|
||||
header_params = (
|
||||
{"headers": headers} if _DJANGO_VERSION_AT_LEAST_4_2 else headers
|
||||
)
|
||||
resp = client.post(
|
||||
graphql_url,
|
||||
json.dumps(body),
|
||||
content_type="application/json",
|
||||
**header_params,
|
||||
graphql_url, json.dumps(body), content_type="application/json", **headers
|
||||
)
|
||||
else:
|
||||
resp = client.post(
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
import inspect
|
||||
|
||||
import django
|
||||
from django.db import connection, models, transaction
|
||||
from django.db.models.manager import Manager
|
||||
from django.utils.encoding import force_str
|
||||
|
|
@ -111,7 +110,24 @@ def is_valid_django_model(model):
|
|||
|
||||
|
||||
def import_single_dispatch():
|
||||
from functools import singledispatch
|
||||
try:
|
||||
from functools import singledispatch
|
||||
except ImportError:
|
||||
singledispatch = None
|
||||
|
||||
if not singledispatch:
|
||||
try:
|
||||
from singledispatch import singledispatch
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
if not singledispatch:
|
||||
raise Exception(
|
||||
"It seems your python version does not include "
|
||||
"functools.singledispatch. Please install the 'singledispatch' "
|
||||
"package. More information here: "
|
||||
"https://pypi.python.org/pypi/singledispatch"
|
||||
)
|
||||
|
||||
return singledispatch
|
||||
|
||||
|
|
@ -129,8 +145,3 @@ def bypass_get_queryset(resolver):
|
|||
"""
|
||||
resolver._bypass_get_queryset = True
|
||||
return resolver
|
||||
|
||||
|
||||
_DJANGO_VERSION_AT_LEAST_4_2 = django.VERSION[0] > 4 or (
|
||||
django.VERSION[0] >= 4 and django.VERSION[1] >= 2
|
||||
)
|
||||
|
|
|
|||
|
|
@ -9,17 +9,10 @@ from django.shortcuts import render
|
|||
from django.utils.decorators import method_decorator
|
||||
from django.views.decorators.csrf import ensure_csrf_cookie
|
||||
from django.views.generic import View
|
||||
from graphql import (
|
||||
ExecutionResult,
|
||||
OperationType,
|
||||
execute,
|
||||
get_operation_ast,
|
||||
parse,
|
||||
validate_schema,
|
||||
)
|
||||
from graphql import OperationType, get_operation_ast, parse
|
||||
from graphql.error import GraphQLError
|
||||
from graphql.execution import ExecutionResult
|
||||
from graphql.execution.middleware import MiddlewareManager
|
||||
from graphql.validation import validate
|
||||
|
||||
from graphene import Schema
|
||||
from graphene_django.constants import MUTATION_ERRORS_FLAG
|
||||
|
|
@ -96,7 +89,6 @@ class GraphQLView(View):
|
|||
batch = False
|
||||
subscription_path = None
|
||||
execution_context_class = None
|
||||
validation_rules = None
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
|
|
@ -108,7 +100,6 @@ class GraphQLView(View):
|
|||
batch=False,
|
||||
subscription_path=None,
|
||||
execution_context_class=None,
|
||||
validation_rules=None,
|
||||
):
|
||||
if not schema:
|
||||
schema = graphene_settings.SCHEMA
|
||||
|
|
@ -137,8 +128,6 @@ class GraphQLView(View):
|
|||
), "A Schema is required to be provided to GraphQLView."
|
||||
assert not all((graphiql, batch)), "Use either graphiql or batch processing"
|
||||
|
||||
self.validation_rules = validation_rules or self.validation_rules
|
||||
|
||||
# noinspection PyUnusedLocal
|
||||
def get_root_value(self, request):
|
||||
return self.root_value
|
||||
|
|
@ -178,13 +167,11 @@ class GraphQLView(View):
|
|||
subscriptions_transport_ws_sri=self.subscriptions_transport_ws_sri,
|
||||
graphiql_plugin_explorer_version=self.graphiql_plugin_explorer_version,
|
||||
graphiql_plugin_explorer_sri=self.graphiql_plugin_explorer_sri,
|
||||
graphiql_plugin_explorer_css_sri=self.graphiql_plugin_explorer_css_sri,
|
||||
# The SUBSCRIPTION_PATH setting.
|
||||
subscription_path=self.subscription_path,
|
||||
# GraphiQL headers tab,
|
||||
graphiql_header_editor_enabled=graphene_settings.GRAPHIQL_HEADER_EDITOR_ENABLED,
|
||||
graphiql_should_persist_headers=graphene_settings.GRAPHIQL_SHOULD_PERSIST_HEADERS,
|
||||
graphiql_input_value_deprecation=graphene_settings.GRAPHIQL_INPUT_VALUE_DEPRECATION,
|
||||
)
|
||||
|
||||
if self.batch:
|
||||
|
|
@ -306,61 +293,43 @@ class GraphQLView(View):
|
|||
return None
|
||||
raise HttpError(HttpResponseBadRequest("Must provide query string."))
|
||||
|
||||
schema = self.schema.graphql_schema
|
||||
|
||||
schema_validation_errors = validate_schema(schema)
|
||||
if schema_validation_errors:
|
||||
return ExecutionResult(data=None, errors=schema_validation_errors)
|
||||
|
||||
try:
|
||||
document = parse(query)
|
||||
except Exception as e:
|
||||
return ExecutionResult(errors=[e])
|
||||
|
||||
operation_ast = get_operation_ast(document, operation_name)
|
||||
if request.method.lower() == "get":
|
||||
operation_ast = get_operation_ast(document, operation_name)
|
||||
if operation_ast and operation_ast.operation != OperationType.QUERY:
|
||||
if show_graphiql:
|
||||
return None
|
||||
|
||||
if (
|
||||
request.method.lower() == "get"
|
||||
and operation_ast is not None
|
||||
and operation_ast.operation != OperationType.QUERY
|
||||
):
|
||||
if show_graphiql:
|
||||
return None
|
||||
|
||||
raise HttpError(
|
||||
HttpResponseNotAllowed(
|
||||
["POST"],
|
||||
"Can only perform a {} operation from a POST request.".format(
|
||||
operation_ast.operation.value
|
||||
),
|
||||
raise HttpError(
|
||||
HttpResponseNotAllowed(
|
||||
["POST"],
|
||||
"Can only perform a {} operation from a POST request.".format(
|
||||
operation_ast.operation.value
|
||||
),
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
validation_errors = validate(
|
||||
schema,
|
||||
document,
|
||||
self.validation_rules,
|
||||
graphene_settings.MAX_VALIDATION_ERRORS,
|
||||
)
|
||||
|
||||
if validation_errors:
|
||||
return ExecutionResult(data=None, errors=validation_errors)
|
||||
|
||||
try:
|
||||
execute_options = {
|
||||
extra_options = {}
|
||||
if self.execution_context_class:
|
||||
extra_options["execution_context_class"] = self.execution_context_class
|
||||
|
||||
options = {
|
||||
"source": query,
|
||||
"root_value": self.get_root_value(request),
|
||||
"context_value": self.get_context(request),
|
||||
"variable_values": variables,
|
||||
"operation_name": operation_name,
|
||||
"context_value": self.get_context(request),
|
||||
"middleware": self.get_middleware(request),
|
||||
}
|
||||
if self.execution_context_class:
|
||||
execute_options[
|
||||
"execution_context_class"
|
||||
] = self.execution_context_class
|
||||
options.update(extra_options)
|
||||
|
||||
operation_ast = get_operation_ast(document, operation_name)
|
||||
if (
|
||||
operation_ast is not None
|
||||
operation_ast
|
||||
and operation_ast.operation == OperationType.MUTATION
|
||||
and (
|
||||
graphene_settings.ATOMIC_MUTATIONS is True
|
||||
|
|
@ -368,12 +337,12 @@ class GraphQLView(View):
|
|||
)
|
||||
):
|
||||
with transaction.atomic():
|
||||
result = execute(schema, document, **execute_options)
|
||||
result = self.schema.execute(**options)
|
||||
if getattr(request, MUTATION_ERRORS_FLAG, False) is True:
|
||||
transaction.set_rollback(True)
|
||||
return result
|
||||
|
||||
return execute(schema, document, **execute_options)
|
||||
return self.schema.execute(**options)
|
||||
except Exception as e:
|
||||
return ExecutionResult(errors=[e])
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,3 @@ omit = */tests/*
|
|||
[tool:pytest]
|
||||
DJANGO_SETTINGS_MODULE = examples.django_test_settings
|
||||
addopts = --random-order
|
||||
filterwarnings =
|
||||
error
|
||||
# we can't do anything about the DeprecationWarning about typing.ByteString in graphql
|
||||
default:'typing\.ByteString' is deprecated:DeprecationWarning:graphql\.pyutils\.is_iterable
|
||||
|
|
|
|||
4
setup.py
4
setup.py
|
|
@ -26,7 +26,8 @@ tests_require = [
|
|||
|
||||
|
||||
dev_requires = [
|
||||
"ruff==0.1.2",
|
||||
"black==23.7.0",
|
||||
"ruff==0.0.283",
|
||||
"pre-commit",
|
||||
] + tests_require
|
||||
|
||||
|
|
@ -49,7 +50,6 @@ setup(
|
|||
"Programming Language :: Python :: 3.9",
|
||||
"Programming Language :: Python :: 3.10",
|
||||
"Programming Language :: Python :: 3.11",
|
||||
"Programming Language :: Python :: 3.12",
|
||||
"Programming Language :: Python :: Implementation :: PyPy",
|
||||
"Framework :: Django",
|
||||
"Framework :: Django :: 3.2",
|
||||
|
|
|
|||
11
tox.ini
11
tox.ini
|
|
@ -1,8 +1,8 @@
|
|||
[tox]
|
||||
envlist =
|
||||
py{38,39,310}-django32
|
||||
py{38,39}-django42
|
||||
py{310,311,312}-django{42,50,51,main}
|
||||
py{38,39}-django{41,42}
|
||||
py{310,311}-django{41,42,main}
|
||||
pre-commit
|
||||
|
||||
[gh-actions]
|
||||
|
|
@ -11,14 +11,12 @@ python =
|
|||
3.9: py39
|
||||
3.10: py310
|
||||
3.11: py311
|
||||
3.12: py312
|
||||
|
||||
[gh-actions:env]
|
||||
DJANGO =
|
||||
3.2: django32
|
||||
4.1: django41
|
||||
4.2: django42
|
||||
5.0: django50
|
||||
5.1: django51
|
||||
main: djangomain
|
||||
|
||||
[testenv]
|
||||
|
|
@ -31,9 +29,8 @@ deps =
|
|||
-e.[test]
|
||||
psycopg2-binary
|
||||
django32: Django>=3.2,<4.0
|
||||
django41: Django>=4.1,<4.2
|
||||
django42: Django>=4.2,<4.3
|
||||
django50: Django>=5.0,<5.1
|
||||
django51: Django>=5.1,<5.2
|
||||
djangomain: https://github.com/django/django/archive/main.zip
|
||||
commands = {posargs:pytest --cov=graphene_django graphene_django examples}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user