Resolver Testing

[Shailu-s]

I am new to GraphQL and this library so i am unable to write tests for my resolvers. I cannot any documentation regarding tests in adriane docs so i have to ask here. I hope someone can write a dummy test for one of my resolver so i will get a start.

@query.field("teacher")
@convert_kwargs_to_snake_case
def resolve_teacher(_, info, id):
    try:
        return Teacher.objects.get(
            uuid=id,
            agent__user=info.context.get('user'),
            deleted_at__isnull=True,
            agent__deleted_at__isnull=True
        )
    except Teacher.DoesNotExist:
        raise GraphQLError(message="Teacher not found")

[rafalp]

There are two ways to test resolvers:

Unit testing resolver functions

In this approach you mock info argument (just Mock(context={"user": User}) is fine) and then call your resolver like any other python function:

def test_teacher_resolver_returns_teacher_if_valid_id_is_given(teacher_fixture):
    info = Mock(context={})
    result = resolve_teacher(None, info, id=teacher_fixture.id)
    assert result == teacher_fixture

Pros

• Easy to get started
• Easy to write

Cons

• Doesn't test if resolver is actually bound to schema.
• Doesn't test if resolver's result is understood by child resolvers.
• Doesn't test how GraphQL error handler will behave when resolver returns error.

Testing with test client

In this approach you use test client to send GraphQL query to your API, then inspect JSON response. If you are using Django, you may use their test client, for ASGI apps HTTPX library also has one.

def test_teacher_query_returns_teacher_if_valid_id_is_given(teacher_fixture, run_graphql_query):
    query = """
        query GetTeacher($id: ID!) {
            teacher(id: $id) {
                id
                name
            }
        }
    """
    result = run_graphql_query(query, {"id": teacher_fixture.id})
    assert not result.errors
    assert result.data == {
        "teacher": {
            "id": str(teacher_fixture.id),
            "name: teacher_fixture.name,
        },
    }

Pros

• Tests if resolver is bound to schema.
• Tests if resolver's result works with child resolvers.
• Tests how errors raised by Resolver are handled by GraphQL and served to client.

Cons

• You need to write test util that wraps test client and uses it to run GraphQL query (its annoyingly verbose otherwise)
• You will need to write and maintain test queries in your tests suite

Which one to go?

Most of people I've discussed this with seem to agree that test client approach is better because it checks not only resolver itself but also that resolver works with schema, child resolvers and error handling.

Personally I've started with unit testing just resolver functions, but quickly moved to running test client and testing GraphQL fields because that caught more errors (eg. me breaking error handling by mistake or changing field name on model breaking GraphQL field). Here's example of this approach from my OS project.

[papi1992]

hi @rafalp, the example link doesn't work, could you help where it moved?

[rafalp]

@papi1992 fixed link.

[Shailu-s]

Thanks @rafalp for your quick response. It helped me save my time . I have successfully created tests for my project.

[rafalp]

Can you describe your tech stack? Are you using Django?

[Shailu-s]

Yes I am using django, this is how i am trying to write tests:

import asyncio
from python_graphql_client import GraphqlClient

def run_graphql_query(query):
    client = GraphqlClient(endpoint="http://127.0.0.1:8080/graphql/")
    variables = {"id": "65840474-fb15-443e-9753-b94ccdf19005"}
    data = asyncio.run(client.execute_async(query=query, variables=variables))
    print(data)
    return data

def test_teacher_query_returns_teacher_if_valid_id_is_given(run_graphql_query):
    query = """
        query GetTrigeer($id: ID!) {
            trigger(id:$id){
            amount
            }
        }
    """
    result = run_graphql_query(query)
    assert not result.errors
    assert result.data == {
        "trigger": {
            "amount": "654",
        },
    }``

But for this to work, I have to start the localserver first then run tests on different terminal. I am looking for a way to eliminate this process.

[rafalp]

You don't have to use python_graphql_client. Django has custom test client. run_graphql_query should only be an abstraction that creates GraphQL JSON request with keys query and variables that makes POST to /graphql/ url.

[Shailu-s]

Thanks i will try this right now.

[Shailu-s]

class ResolverTest(TestCase):
    query = """
        query GetTrigeer($id: ID!) {
            trigger(id:$id){
            amount
            }
        }
    """
    
    def run_graphql_query(query,trigger):
        c = Client()
        variables = {"id": str(trigger.uuid)}
        r = c.post("/graphql/", data={
            "operations": json.dumps(
                {"query": query, "variables": variables}
            )
        })

        print(r.json()["data"])
        return r

    trigger = Trigger.objects.get(amount=655)
    run_graphql_query(query,trigger)``

So far i am able to fetch the result but bypassing authentication and info. This is my resolver:

@query.field("trigger")
@convert_kwargs_to_snake_case
def resolve_trigger(_, info, id):
    try:
        return Trigger.objects.get(
            uuid=id,
            # agent__user=info.context.get('user'),
            deleted_at__isnull=True,
            agent__deleted_at__isnull=True
        )
    except Trigger.DoesNotExist:
        raise GraphQLError(message="Trigger not found")

and
trigger(id: ID!): Trigger @isAuthenticated
Now @rafalp how to pass info in my test, it says Mock in not serializable plus i have to authenticate, I am sorry to bother so much but if you write out just this little code that would be helpful. Thank you Sir.