To help you get started, we've collected the most common ways that gavel is being used within popular public projects.

apiaryio / dredd / lib / TransactionRunner.js View on Github

validateTransaction(test, transaction, callback) {
    logger.debug('Validating HTTP transaction by Gavel.js');
    let gavelResult = { fields: {} };

    try {
      gavelResult = gavel.validate(transaction.expected, transaction.real);
    } catch (validationError) {
      logger.debug('Gavel.js validation errored:', validationError);
      this.emitError(validationError, test);
    }

    test.title = transaction.id;
    test.actual = transaction.real;
    test.expected = transaction.expected;
    test.request = transaction.request;

    // TODO
    // Gavel result MUST NOT be undefined. Check transaction runner tests
    // to find where and why it is.
    const { valid: isValid } = gavelResult;

    if (isValid) {

View more ways to use gavel

Gavel

Gavel tells you whether an actual HTTP message is valid against an expected HTTP message.

Install

npm install gavel

Usage

CLI

# (Optional) Record HTTP messages
curl -s --trace - https://httpbin.org/ip | curl-trace-parser > expected
curl -s --trace - https://httpbin.org/ip | curl-trace-parser > actual

# Perform the validation
cat actual | gavel expected

> Gavel CLI is not supported on Windows. Example above uses curl-trace-parser.

NodeJS

const gavel = require('gavel');

// Define HTTP messages
const expected = {
  statusCode: 200,
  headers: {
    'Content-Type': 'application/json'
  }
};

const actual = {
  statusCode: 404,
  headers: {
    'Content-Type': 'application/json'
  }
};

// Perform the validation
const result = gavel.validate(expected, actual);

The code above would return the following validation result:

{
  valid: false,
  fields: {
    statusCode: {
      valid: false,
      kind: 'text',
      values: {
        expected: '200',
        actual: '404'
      },
      errors: [
        {
          message: `Expected status code '200', but got '404'.`
        }
      ]
    },
    headers: {
      valid: true,
      kind: 'json',
      values: {
        expected: {
          'Content-Type': 'application/json'
        },
        actual: {
          'Content-Type': 'application/json'
        }
      },
      errors: []
    }
  }
}

Usage with JSON Schema

> When a parsable JSON body is expected without an explicit schema the default schema is inferred.

You can describe the body expectations using JSON Schema by providing a valid schema to the bodySchema property of the expected HTTP message:

const gavel = require('gavel');

const expected = {
  bodySchema: {
    type: 'object',
    properties: {
      fruits: {
        type: 'array',
        items: {
          type: 'string'
        }
      }
    }
  }
};

const actual = {
  body: JSON.stringify({
    fruits: ['apple', 'banana', 2]
  })
};

const result = gavel.validate(expected, actual);

The validation result against the given JSON Schema will look as follows:

{
  valid: false,
  fields: {
    body: {
      valid: false,
      kind: 'json',
      values: {
        actual: "{\"fruits\":[\"apple\",\"banana\",2]}"
      },
      errors: [
        {
          message: `At '/fruits/2' Invalid type: number (expected string)`,
          location: {
            pointer: '/fruits/2'
          }
        }
      ]
    }
  }
}

Supported JSON Schema versions

• JSON Schema Draft 7
• JSON Schema Draft 6
• JSON Schema Draft 4

Examples

Take a look at the Gherkin specification, which describes on examples how validation of each field behaves:

• method
• uri
• statusCode
• headers
• body
• bodySchema

Type definitions

Gavel ships with TypeScript type definitions. Please refer to the definitions file for more details.

API

• validate(expected: HttpMessage, actual: HttpMessage): ValidationResult

License

MIT