Schema validation basics in Postman - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the result of this Postman test script?

Given this Postman test script validating a JSON response schema, what will be the test result?

Postman

pm.test('Validate user schema', function () {
    const schema = {
        type: 'object',
        properties: {
            id: { type: 'integer' },
            name: { type: 'string' },
            email: { type: 'string', format: 'email' }
        },
        required: ['id', 'name', 'email']
    };
    pm.response.to.have.jsonSchema(schema);
});

A Test passes if response JSON has integer id, string name, and valid email string

B Test fails if response JSON has any extra properties beyond id, name, and email

C Test passes even if email is missing from response JSON

D Test fails if id is a string instead of integer

💡 Hint

Check what the required array means and how jsonSchema validates types.

The schema requires id, name, and email properties with specified types. The test passes only if all are present and valid. Extra properties do not cause failure by default.

❓ assertion

intermediate

Which assertion correctly validates a JSON array schema in Postman?

You want to validate that the response is an array of objects, each with a required id (integer) and optional name (string). Which assertion is correct?

A pm.response.to.have.jsonSchema({ type: 'array', items: { type: 'object', properties: { id: { type: 'string' }, name: { type: 'string' } }, required: ['id'] } });

B pm.response.to.have.jsonSchema({ type: 'array', items: { type: 'object', properties: { id: { type: 'integer' }, name: { type: 'string' } }, required: ['id'] } });

C pm.response.to.have.jsonSchema({ type: 'array', properties: { id: { type: 'integer' }, name: { type: 'string' } }, required: ['id'] });

D pm.response.to.have.jsonSchema({ type: 'object', properties: { id: { type: 'integer' }, name: { type: 'string' } }, required: ['id'] });

💡 Hint

Remember the difference between type: 'array' and type: 'object' and where items is used.

Option B correctly defines a schema for an array where each item is an object with required integer id and optional string name. Option B is for a single object, not an array. Option B misuses properties at array level. Option B wrongly expects id as string.

🔧 Debug

advanced

Why does this Postman schema validation test fail?

Examine the test script below. The response JSON is {"id": 5, "name": "Alice"}. Why does the test fail?

Postman

pm.test('Validate user schema', function () {
    const schema = {
        type: 'object',
        properties: {
            id: { type: 'integer' },
            name: { type: 'string' },
            email: { type: 'string', format: 'email' }
        },
        required: ['id', 'name', 'email']
    };
    pm.response.to.have.jsonSchema(schema);
});

A The schema has syntax errors causing failure

B The 'id' property is not an integer

C The 'name' property is not a string

D The response is missing the required 'email' property

💡 Hint

Check the required properties and compare with the response JSON.

The schema requires 'email' property, but the response JSON does not have it. This causes the validation to fail.

🧠 Conceptual

advanced

What does the 'additionalProperties: false' option do in JSON schema validation?

In a Postman JSON schema, what is the effect of setting additionalProperties: false inside an object schema?

A It makes all properties optional regardless of the 'required' list

B It allows any extra properties beyond those listed in 'properties' without failing validation

C It causes the validation to fail if the response JSON contains any properties not listed in 'properties'

D It disables all schema validation for that object

💡 Hint

Think about how strict the schema is about unexpected properties.

Setting additionalProperties: false means the JSON must not have any properties other than those explicitly defined in properties. Extra properties cause validation failure.

❓ framework

expert

How to write a Postman test to validate nested JSON schema with arrays and objects?

You receive a JSON response with this structure:

{
  "user": {
    "id": 10,
    "roles": ["admin", "editor"]
  }
}

Which Postman test script correctly validates that user is an object with integer id and an array roles of strings?

A

pm.test('Validate nested schema', () => {
  const schema = {
    type: 'object',
    properties: {
      user: {
        type: 'object',
        properties: {
          id: { type: 'integer' },
          roles: { type: 'array', items: { type: 'string' } }
        },
        required: ['id', 'roles']
      }
    },
    required: ['user']
  };
  pm.response.to.have.jsonSchema(schema);
});

B

pm.test('Validate nested schema', () => {
  const schema = {
    type: 'object',
    properties: {
      user: {
        type: 'array',
        items: { type: 'string' }
      }
    },
    required: ['user']
  };
  pm.response.to.have.jsonSchema(schema);
});

C

pm.test('Validate nested schema', () => {
  const schema = {
    type: 'object',
    properties: {
      id: { type: 'integer' },
      roles: { type: 'array', items: { type: 'string' } }
    },
    required: ['id', 'roles']
  };
  pm.response.to.have.jsonSchema(schema);
});

D

pm.test('Validate nested schema', () => {
  const schema = {
    type: 'object',
    properties: {
      user: {
        type: 'object',
        properties: {
          id: { type: 'string' },
          roles: { type: 'array', items: { type: 'integer' } }
        },
        required: ['id', 'roles']
      }
    },
    required: ['user']
  };
  pm.response.to.have.jsonSchema(schema);
});

💡 Hint

Focus on the nested user object and the types inside it.

Option A correctly defines user as an object with required integer id and array of strings roles. Option A wrongly treats user as an array. Option A misses the user nesting. Option A has wrong types for id and roles.