Testing
GraphQL presents a unique challenge for contract testing. REST APIs have stable URL paths and HTTP verbs — easy to record as contracts. GraphQL routes everything through a single endpoint (POST /graphql) with the operation in the request body. The schema is flexible and self-describing. So where does contract testing
Testing
GraphQL's flexibility is a double-edged sword. The same feature that lets clients fetch exactly what they need also lets an attacker craft a query that brings your server to its knees. The same resolver pattern that makes GraphQL elegant also creates N+1 query problems at scale.
GraphQL
Apollo Client components are hard to test without the right tools because they depend on a live GraphQL server. Apollo's MockedProvider lets you define expected operations and their responses, so you can test components in complete isolation. This guide covers the full spectrum: loading states, successful responses, errors,
GraphQL
GraphQL persisted queries reduce payload size and improve security by replacing full query strings with short hash identifiers. But they introduce new failure modes — hash mismatches, cache invalidation bugs, and APQ negotiation failures — that require dedicated testing strategies. This guide covers everything you need to test persisted queries and APQ
GraphQL
GraphQL error handling is fundamentally different from REST. A 200 response can contain errors. A query can partially succeed — returning some data while failing on other fields. Null propagation can silently wipe out entire subtrees. If you're only testing the happy path, you're missing half the
Database Testing
Nhost is an open-source Firebase alternative that combines PostgreSQL, Hasura GraphQL Engine, Auth (JWT-based), Storage, and serverless functions into a single deployable platform. It's popular with teams who want typed GraphQL APIs auto-generated from their database schema without writing resolvers. Testing Nhost applications involves several
GraphQL
Code-first GraphQL frameworks like Pothos (TypeScript) and Strawberry (Python) generate schemas from type-annotated code, which fundamentally changes the testing approach. Your types become the schema, so testing the types tests the schema. This post covers testing strategies specific to code-first GraphQL — plugin testing, type resolution, auth guards,
Hasura
Hasura generates a GraphQL API directly from your PostgreSQL schema, which means your tests must cover things that don't exist in hand-written APIs: role-based permission rules, relationship traversal, computed fields backed by SQL functions, and event triggers. This post shows a complete pytest-based testing strategy
GraphQL
GraphQL schemas evolve, and every change carries the risk of breaking clients. Contract testing catches breaking changes before deployment by comparing schema versions and validating that client queries still work against the new schema. This post covers what counts as a breaking change, how to use GraphQL Inspector for schema
Apollo Server
Apollo Server v4 introduced a cleaner testing API centered on executeOperation, which lets you run full GraphQL operations without spinning up an HTTP server. This post covers testing resolvers, DataSources, authentication via context, subscriptions with graphql-ws, and how to use snapshot testing effectively for GraphQL responses — all with Jest.
Testing
Apollo Client is the most widely used GraphQL client for React, and testing it properly means going beyond shallow component tests. You need to verify that your components handle loading states, successful data responses, error states, and cache interactions correctly. Apollo provides MockedProvider for exactly this purpose — this guide shows
Testing
urql is a lightweight, extensible GraphQL client for React that uses an exchange-based architecture. Unlike Apollo's MockedProvider, urql testing uses mock exchanges to intercept operations. This guide covers everything from basic query mocking to offline support testing and subscriptions. Understanding urql's Exchange Architecture urql processes