create-boom-error/test/index.test.js

Simply create sub-classed Boom errors for Hapi applications.

'use strict';

const expect = require('chai').expect;
const { createBoomError, isDecoratedBoom } = require('../index.js');

describe('create-boom-error', () => {

  it('checks if the error subclasses the base error class', () => {
    const StringError = createBoomError('StringError', 404, 'string message');
    const err = new StringError();
    const regularErr = new Error();

    expect(isDecoratedBoom(err)).to.be.true;
    expect(isDecoratedBoom(regularErr)).to.be.false;
  });

  it('should create a boom error with a string message', () => {
    const StringError = createBoomError('StringError', 404, 'string message');
    const err = new StringError();

    expect(err instanceof StringError).to.be.true;
    expect(err instanceof Error).to.be.true;
    expect(err.message).to.eql('string message');
    expect(err.code).to.eql('string_error');
    expect(err.output).to.eql({
      statusCode: 404,
      payload: {
        statusCode: 404,
        error: 'Not Found',
        message: 'string message'
      },
      headers: {}
    });
  });

  it('should create a boom error with a function message', () => {
    const FunctionError = createBoomError('FunctionError', 422, (value) => `value is ${value}`);
    const err = new FunctionError('one');

    expect(err instanceof FunctionError).to.be.true;
    expect(err instanceof Error).to.be.true;
    expect(err.message).to.eql('value is one');
    expect(err.code).to.eql('function_error');
    expect(err.output).to.eql({
      statusCode: 422,
      payload: {
        statusCode: 422,
        error: 'Unprocessable Entity',
        message: 'value is one'
      },
      headers: {}
    });
  });

  it('should create a boom error without a message', function () {
    const EmptyError = createBoomError('EmptyError', 422);
    const err = new EmptyError();

    expect(err instanceof EmptyError).to.be.true;
    expect(err instanceof Error).to.be.true;
    expect(err.code).to.eql('empty_error');
    expect(err.output).to.eql({
      statusCode: 422,
      payload: {
        statusCode: 422,
        error: 'Unprocessable Entity'
      },
      headers: {}
    });
  });

  it('should create a boom error with an optional error code', () => {
    const code = 'invalid';
    const CodeError = createBoomError('CodeError', 422, null, code);
    const err = new CodeError();

    expect(err instanceof CodeError).to.be.true;
    expect(err instanceof Error).to.be.true;
    expect(err.code).to.eql(code);
    expect(err.output).to.eql({
      statusCode: 422,
      payload: {
        statusCode: 422,
        error: 'Unprocessable Entity'
      },
      headers: {}
    });
  });
});