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.