Schema testing in GraphQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What does a GraphQL schema define?

In GraphQL, what is the main purpose of a schema?

A It defines the types of data and the queries/mutations allowed.

B It formats the output data into JSON strings.

C It manages user authentication and permissions.

D It stores the actual data records in the database.

💡 Hint

Think about what tells GraphQL what data can be requested and how.

A GraphQL schema defines the data types and the operations (queries and mutations) clients can perform. It acts like a contract between client and server.

❓ query_result

intermediate

Output of a simple GraphQL query

Given this schema snippet:

type Query { greeting: String }

And this resolver returns "Hello!" for greeting, what is the output of this query?

{ greeting }

A SyntaxError: Missing query keyword

B { "greeting": "Hello!" }

C { "data": { "greeting": null } }

D { "data": { "greeting": "Hello!" } }

💡 Hint

GraphQL responses always wrap data inside a 'data' field.

GraphQL responses wrap the returned data inside a 'data' object. So the greeting field appears inside 'data'.

📝 Syntax

advanced

Identify the syntax error in this schema

Which option contains a syntax error in this GraphQL schema definition?

GraphQL

type User { id: ID! name: String! age: Int }

A type User { id: ID! name: String! age: Int! }

B type User { id: ID! name: String! age Int }

C type User { id: ID! name: String! age: Int }

D } tnI :ega !gnirtS :eman !DI :di { resU epyt

💡 Hint

Look carefully at the colon usage between field name and type.

Option B is missing a colon ':' between 'age' and 'Int', which is required syntax in GraphQL schema definitions.

❓ optimization

advanced

Best practice to avoid over-fetching in GraphQL schema

Which schema design helps avoid over-fetching data in GraphQL?

A Define many nested fields and allow clients to request only what they need.

B Return all fields by default in every query to simplify client code.

C Use a single large type with all possible fields combined.

D Disable query selection sets and always return fixed data.

💡 Hint

GraphQL lets clients specify exactly what fields they want.

GraphQL's power is letting clients request only the fields they need, avoiding over-fetching. Designing schema with nested fields supports this.

🔧 Debug

expert

Why does this schema cause an error?

Given this schema snippet:

type Query { user(id: ID!): User }

type User { id: ID! name: String! friend: User }

Why might this schema cause issues in some GraphQL servers?

A Because the User type must not have fields of type User.

B Because the Query type must not have arguments in fields.

C Because the User type references itself without using a list or nullable type, causing infinite recursion.

D Because ID! is not a valid GraphQL type.

💡 Hint

Think about recursive types and how GraphQL handles them.

The User type references itself in the friend field without making it nullable or a list, which can cause infinite recursion or stack overflow in some servers if not handled properly.

Practice

1. What is the main purpose of schema testing in GraphQL?

easy

A. To check the database connection

B. To test the speed of GraphQL queries

C. To verify that the GraphQL schema matches the expected structure and types

D. To validate user authentication tokens

Solution

1. Step 1: Understand schema testing purpose

   Schema testing ensures the GraphQL schema is correct and matches the design.

2. Step 2: Compare options to purpose

   Only verifying schema structure and types matches schema testing's goal.

3. Final Answer:

   To verify that the GraphQL schema matches the expected structure and types -> Option C

4. Quick Check:

   Schema testing = verify schema structure [OK]

Hint: Schema testing checks schema structure, not performance or auth [OK]

Common Mistakes:

• Confusing schema testing with performance testing
• Thinking schema testing checks database connections
• Assuming schema testing validates user authentication

2. Which of the following is the correct syntax to define a GraphQL schema type for a User with fields id (ID!) and name (String)?

easy

A. User { id: ID! name: String }

B. schema User { id: ID! name: String }

C. type User (id: ID!, name: String)

D. type User { id: ID! name: String }

Solution

1. Step 1: Recall GraphQL type syntax

   GraphQL types use the keyword type followed by name and curly braces with fields.

2. Step 2: Match syntax to options

   type User { id: ID! name: String } correctly uses type User { id: ID! name: String }. Others misuse keywords or punctuation.

3. Final Answer:

   type User { id: ID! name: String } -> Option D

4. Quick Check:

   Correct type syntax = type User { id: ID! name: String } [OK]

Hint: GraphQL types start with 'type' keyword and use braces {} [OK]

Common Mistakes:

• Using 'schema' instead of 'type' keyword
• Using parentheses instead of braces
• Omitting the 'type' keyword

3. Given this GraphQL schema snippet:

type Query { user(id: ID!): User }

And this query:

{ user(id: "123") { id name } }

What is the expected shape of the response data?

medium

A. {"user": {"id": "123", "name": "Alice"}}

B. {"data": {"user": {"id": "123", "name": "Alice"}}}

C. {"data": {"user": null}}

D. {"error": "User not found"}

Solution

1. Step 1: Understand GraphQL response format

   GraphQL responses wrap results inside a data object with requested fields.

2. Step 2: Match query and schema to response

   The query requests user with id "123" and fields id and name. Assuming user exists, response includes these inside data.

3. Final Answer:

   {"data": {"user": {"id": "123", "name": "Alice"}}} -> Option B

4. Quick Check:

   GraphQL response wraps data in 'data' key [OK]

Hint: GraphQL responses always wrap results inside 'data' key [OK]

Common Mistakes:

• Returning data without 'data' wrapper
• Confusing null user with error response
• Assuming error is returned instead of null

4. You wrote this schema test to check if the email field exists on User type:

expect(schema.getType('User').getFields()).toHaveProperty('email')

But the test fails. What is the most likely cause?

medium

A. The User type does not have an email field defined

B. The getFields() method is not valid on schema types

C. The test syntax is incorrect and should use hasProperty

D. The schema variable is undefined

Solution

1. Step 1: Understand what getFields() returns

   The getFields() method returns an object of fields defined on the type.

2. Step 2: Analyze test failure reason

   If test fails checking for 'email', likely the User type lacks that field in schema definition.

3. Final Answer:

   The User type does not have an email field defined -> Option A

4. Quick Check:

   Missing field causes test failure [OK]

Hint: Test fails if field is missing in schema type [OK]

Common Mistakes:

• Assuming method getFields() is invalid
• Confusing test assertion method names
• Not checking if schema variable is defined

5. You want to write a schema test to ensure the Post type has a field comments that returns a list of Comment types. Which test code correctly verifies this?

hard

A. expect(schema.getType('Post').getFields().comments.type.toString()).toBe('[Comment!]!')

B. expect(schema.getType('Post').getFields().comments.type.ofType.name).toBe('Comment')

C. expect(schema.getType('Post').getFields().comments.type.toString()).toBe('[Comment]')

D. expect(schema.getType('Post').getFields().comments.type.name).toBe('Comment')

Solution

1. Step 1: Understand GraphQL list and non-null syntax

   A list of Comment types with non-null items and non-null list is represented as [Comment!]!.

2. Step 2: Match test code to expected type string

   expect(schema.getType('Post').getFields().comments.type.toString()).toBe('[Comment!]!') checks the full type string including non-null markers, correctly verifying the list of non-null Comments.

3. Final Answer:

   expect(schema.getType('Post').getFields().comments.type.toString()).toBe('[Comment!]!') -> Option A

4. Quick Check:

   List of non-null Comments = '[Comment!]!' [OK]

Hint: Use toString() to check full list and non-null type syntax [OK]

Common Mistakes:

• Checking only inner type name without list brackets
• Ignoring non-null markers in type string
• Using wrong property to access type name