server.error.parser.js

import {ServerErrorResponseParser} from '../../../../src/components/common/Helpers/ServerErrorParser/server.error.response.parser';

describe('ServerErrorParser', () => {
  test('hasError', () => {
    const testCases = [{
      name: 'Empty response object',
      response: {},
      actual: false
    }, {
      name: 'Undefined',
      response: undefined,
      actual: false
    }, {
      name: 'Null',
      response: null,
      actual: false
    }, {
      name: 'Empty response error array',
      response: { errors: [] },
      actual: false
    }, {
      name: 'Has global error without message',
      response: { errors: [{ location: null }] },
      actual: true
    }, {
      name: 'Has global error with message',
      response: { errors: [{ location: null, message: 'message' }] },
      actual: true
    }, {
      name: 'Has empty error',
      response: { errors: [{}] },
      actual: true
    }, {
      name: 'Has error with location and message',
      response: { errors: [{ location: 'location', message: 'message' }] },
      actual: true
    }, {
      name: 'Has error with location',
      response: { errors: [{ location: 'location' }] },
      actual: true
    }];

    testCases.forEach(function(testCase) {
      const serverErrorParser = new ServerErrorResponseParser(testCase.response);
      expect(serverErrorParser.hasErrors()).toBe(testCase.actual);
    });
  });

  test('hasGlobalError', () => {
    const testCases = [{
      name: 'Empty response object',
      response: {},
      actual: false
    }, {
      name: 'Undefined',
      response: undefined,
      actual: false
    }, {
      name: 'Null',
      response: null,
      actual: false
    }, {
      name: 'Empty response error array',
      response: { errors: [] },
      actual: false
    }, {
      name: 'Has global error without message',
      response: { errors: [{ location: null }] },
      actual: true
    }, {
      name: 'Has global error with message',
      response: { errors: [{ location: null, message: 'message' }] },
      actual: true
    }, {
      name: 'Has empty error',
      response: { errors: [{}] },
      actual: false
    }, {
      name: 'Has error with location and message',
      response: { errors: [{ location: 'location', message: 'message' }] },
      actual: false
    }, {
      name: 'Has error with location',
      response: { errors: [{ location: 'location' }] },
      actual: false
    }];

    testCases.forEach(function(testCase) {
      const serverErrorParser = new ServerErrorResponseParser(testCase.response);
      expect(serverErrorParser.hasGlobalError()).toBe(testCase.actual);
    });
  });

  test('hasErrorByLocation', () => {
    const testCases = [{
      name: 'Empty response object',
      location: 'location',
      response: {},
      actual: false
    }, {
      name: 'Undefined',
      location: 'location',
      response: undefined,
      actual: false
    }, {
      name: 'Null',
      location: 'location',
      response: null,
      actual: false
    }, {
      name: 'Empty response error array',
      location: 'location',
      response: { errors: [] },
      actual: false
    }, {
      name: 'Has global error without message and location === "null"',
      location: null,
      response: { errors: [{ location: null }] },
      actual: true
    }, {
      name: 'Has global error without message and location === "location"',
      location: 'location',
      response: { errors: [{ location: null }] },
      actual: false
    }, {
      name: 'Has global error with message and location === "null"',
      location: null,
      response: { errors: [{ location: null, message: 'message' }] },
      actual: true
    }, {
      name: 'Has global error with message and location === "location"',
      location: 'location',
      response: { errors: [{ location: null, message: 'message' }] },
      actual: false
    }, {
      name: 'Has empty error',
      location: 'location',
      response: { errors: [{}] },
      actual: false
    }, {
      name: 'Has error with current location and message',
      location: 'currentLocation',
      response: { errors: [{ location: 'currentLocation', message: 'message' }] },
      actual: true
    },{
      name: 'Has error with another location and message',
      location: 'currentLocation',
      response: { errors: [{ location: 'anotherLocation', message: 'message' }] },
      actual: false
    }, {
      name: 'Has error with current location without message',
      location: 'currentLocation',
      response: { errors: [{ location: 'currentLocation' }] },
      actual: true
    }];

    testCases.forEach(function(testCase) {
      const serverErrorParser = new ServerErrorResponseParser(testCase.response);

      if (serverErrorParser.hasErrorByLocation(testCase.location) !== testCase.actual) {
        console.log(testCase.name);
      }

      expect(serverErrorParser.hasErrorByLocation(testCase.location)).toBe(testCase.actual);
    });
  });

  test('getGlobalMessages', () => {
    const testCases = [{
      name: 'Empty response object',
      response: {},
      actual: []
    }, {
      name: 'Undefined',
      response: undefined,
      actual: []
    }, {
      name: 'Null',
      response: null,
      actual: []
    }, {
      name: 'Empty response error array',
      response: { errors: [] },
      actual: []
    },  {
      name: 'Has global error without message',
      response: { errors: [{ location: null }] },
      actual: []
    }, {
      name: 'Has global error with message',
      response: { errors: [{ location: null, message: 'message' }] },
      actual: ['message']
    }, {
      name: 'Has empty error',
      response: { errors: [{}] },
      actual: []
    }, {
      name: 'Has error with location and message',
      response: { errors: [{ location: 'location', message: 'message' }] },
      actual: []
    }, {
      name: 'Has error with location',
      response: { errors: [{ location: 'location' }] },
      actual: []
    }];

    testCases.forEach(function(testCase) {
      const serverErrorParser = new ServerErrorResponseParser(testCase.response);
      expect(serverErrorParser.getGlobalMessages()).toEqual(testCase.actual);
    });
  });


  test('getMessagesByLocation', () => {
    const testCases = [{
      name: 'Empty response object',
      location: 'location',
      response: {},
      actual: []
    }, {
      name: 'Undefined',
      location: 'location',
      response: undefined,
      actual: []
    }, {
      name: 'Null',
      location: 'location',
      response: null,
      actual: []
    }, {
      name: 'Empty response error array',
      location: 'location',
      response: { errors: [] },
      actual: []
    }, {
      name: 'Has global error without message and location === "null"',
      location: null,
      response: { errors: [{ location: null }] },
      actual: []
    }, {
      name: 'Has global error without message and location === "location"',
      location: 'location',
      response: { errors: [{ location: null }] },
      actual: []
    }, {
      name: 'Has global error with message and location === "null"',
      location: null,
      response: { errors: [{ location: null, message: 'message' }] },
      actual: ['message']
    }, {
      name: 'Has global error with message and location === "location"',
      location: 'location',
      response: { errors: [{ location: null, message: 'message' }] },
      actual: []
    }, {
      name: 'Has empty error',
      location: 'location',
      response: { errors: [{}] },
      actual: []
    }, {
      name: 'Has error with current location and message',
      location: 'currentLocation',
      response: { errors: [{ location: 'currentLocation', message: 'message' }] },
      actual: ['message']
    }, {
      name: 'Has two errors with current location and message',
      location: 'currentLocation',
      response: { errors: [
        { location: 'currentLocation', message: 'message one' },
        { location: 'currentLocation', message: 'message two' }
      ]},
      actual: ['message one', 'message two']
    }, {
      name: 'Has error with another location and message',
      location: 'currentLocation',
      response: { errors: [{ location: 'anotherLocation', message: 'message' }] },
      actual: []
    }, {
      name: 'Has error with current location without message',
      location: 'currentLocation',
      response: { errors: [{ location: 'currentLocation' }] },
      actual: []
    }];

    testCases.forEach(function(testCase) {
      const serverErrorParser = new ServerErrorResponseParser(testCase.response);
      expect(serverErrorParser.getMessagesByLocation(testCase.location)).toEqual(testCase.actual);
    });
  });

  test('findByLocation', () => {
    const testCases = [{
      name: 'Empty response object',
      location: 'location',
      response: {},
      actual: []
    }, {
      name: 'Undefined',
      location: 'location',
      response: undefined,
      actual: []
    }, {
      name: 'Null',
      location: 'location',
      response: null,
      actual: []
    }, {
      name: 'Empty response error array',
      location: 'location',
      response: { errors: [] },
      actual: []
    }, {
      name: 'Has global error without message and location === "null"',
      location: null,
      response: { errors: [{ location: null }] },
      actual: [{ location: null }]
    }, {
      name: 'Has global error without message and location === "location"',
      location: 'location',
      response: { errors: [{ location: null }] },
      actual: []
    }, {
      name: 'Has global error with message and location === "null"',
      location: null,
      response: { errors: [{ location: null, message: 'message' }] },
      actual: [{ location: null, message: 'message' }]
    }, {
      name: 'Has global error with message and location === "location"',
      location: 'location',
      response: { errors: [{ location: null, message: 'message' }] },
      actual: []
    }, {
      name: 'Has empty error',
      location: 'location',
      response: { errors: [{}] },
      actual: []
    }, {
      name: 'Has error with current location and message',
      location: 'currentLocation',
      response: { errors: [{ location: 'currentLocation', message: 'message' }] },
      actual: [{ location: 'currentLocation', message: 'message' }]
    }, {
      name: 'Has two errors with current location and message',
      location: 'currentLocation',
      response: { errors: [
        { location: 'currentLocation', message: 'message one' },
        { location: 'currentLocation', message: 'message two' }
      ]},
      actual: [
        { location: 'currentLocation', message: 'message one' },
        { location: 'currentLocation', message: 'message two' }
      ]
    }, {
      name: 'Has error with another location and message',
      location: 'currentLocation',
      response: { errors: [{ location: 'anotherLocation', message: 'message' }] },
      actual: []
    }, {
      name: 'Has error with current location without message',
      location: 'currentLocation',
      response: { errors: [{ location: 'currentLocation' }] },
      actual: [{ location: 'currentLocation' }]
    }];

    testCases.forEach(function(testCase) {
      const serverErrorParser = new ServerErrorResponseParser(testCase.response);
      expect(serverErrorParser.findByLocation(testCase.location)).toEqual(testCase.actual);
    });
  });
});