@3g/request-proxy/src/index.spec.ts

import * as chai from 'chai';
import * as chaiAsPromised from 'chai-as-promised';
chai.use(chaiAsPromised);
const { expect } = chai;

import { assert } from 'chai';
import * as nock from 'nock';

import { createWrapper, IRequestContext } from './index';

describe('request-promise proxy', () => {
  describe('GET', () => {
    it('should output correct request options for a get request', () => {
      const BASE_URL = 'http://localhost:8082/api/';
      const wrapper = createWrapper(BASE_URL);

      const result = wrapper.buildJsonRequest('agency/thing/23');

      assert.deepEqual(result, {
        json: true,
        method: 'GET',
        url: 'http://localhost:8082/api/agency/thing/23',
      });
    });

    it('should output correct request options for a get request with qs option', () => {
      const BASE_URL = 'http://localhost:8080/api/';
      const wrapper = createWrapper(BASE_URL);

      const result = wrapper.buildJsonRequest('things', 'GET', {
        qs: { stuff: '123' },
      });

      assert.deepEqual(result, {
        json: true,
        method: 'GET',
        qs: {
          stuff: '123',
        },
        url: 'http://localhost:8080/api/things',
      });
    });

    it('should output correct request options for a get request with qs and header option', () => {
      const BASE_URL = 'http://localhost:8080/api/';
      const wrapper = createWrapper(BASE_URL);

      const result = wrapper.buildJsonRequest('things', 'GET', {
        qs: { stuff: '123' },
        headers: {
          Authorization: 'Bearer xyzz23',
        },
      });

      assert.deepEqual(result, {
        json: true,
        method: 'GET',
        qs: {
          stuff: '123',
        },
        headers: {
          Authorization: 'Bearer xyzz23',
        },
        url: 'http://localhost:8080/api/things',
      });
    });

    it('should output correct request options for a get request with context option', () => {
      const BASE_URL = 'http://localhost:8080/api/';
      const wrapper = createWrapper(BASE_URL);

      const result = wrapper.buildJsonRequest('things', 'GET', {
        qs: { stuff: '123' },
        headers: {
          Authorization: 'Bearer xyzz23',
        },
      });

      assert.deepEqual(result, {
        json: true,
        method: 'GET',
        qs: {
          stuff: '123',
        },
        headers: {
          Authorization: 'Bearer xyzz23',
        },
        url: 'http://localhost:8080/api/things',
      });
    });

    it('should handle 404 error', async () => {
      const BASE_URL = 'http://localhost:8080/api';

      nock(BASE_URL).get('/things/1').reply(404, 'not found');

      const wrapper = createWrapper(BASE_URL);

      const expectedError = '404 - "not found" - http://localhost:8080/api/things/1';
      await expect(wrapper.proxyJsonRequest('/things/1')).to.be.rejectedWith(expectedError);
    });

    it('should handle 500 error', async () => {
      const BASE_URL = 'http://localhost:8080/api';

      nock(BASE_URL).get('/things/1').reply(500, {
        message: 'Internal Server Error',
      });

      const wrapper = createWrapper(BASE_URL);

      const expectedError = '500 - {"message":"Internal Server Error"} - http://localhost:8080/api/things/1';
      await expect(wrapper.proxyJsonRequest('/things/1')).to.be.rejectedWith(expectedError);
    });
  });

  describe('POST', () => {
    it('should output correct request options for a post request with body', () => {
      const BASE_URL = 'http://localhost:8082/api/';
      const wrapper = createWrapper(BASE_URL);

      const result = wrapper.buildJsonRequest('agency/thing', 'POST', {
        body: {
          name: 'new thing',
          description: 'this is new',
        },
      });

      assert.deepEqual(result, {
        json: true,
        method: 'POST',
        body: {
          name: 'new thing',
          description: 'this is new',
        },
        url: 'http://localhost:8082/api/agency/thing',
      });
    });
  });

  describe('PUT', () => {
    it('should output correct request options for a put request with body', () => {
      const BASE_URL = 'http://localhost:8082/api/';
      const wrapper = createWrapper(BASE_URL);

      const result = wrapper.buildJsonRequest('agency/thing/23', 'PUT', {
        body: {
          description: 'this is even newer',
        },
      });

      assert.deepEqual(result, {
        json: true,
        method: 'PUT',
        body: {
          description: 'this is even newer',
        },
        url: 'http://localhost:8082/api/agency/thing/23',
      });
    });
  });

  describe('DELETE', () => {
    it('should output correct request options for a delete request', () => {
      const BASE_URL = 'http://localhost:8082/api/';
      const wrapper = createWrapper(BASE_URL);

      const result = wrapper.buildJsonRequest('agency/thing/23', 'DELETE');

      assert.deepEqual(result, {
        json: true,
        method: 'DELETE',
        url: 'http://localhost:8082/api/agency/thing/23',
      });
    });
  });

  describe('Istio HEADERS', () => {
    it('GET should forward Request Headers', () => {
      const BASE_URL = 'http://localhost:8082/api/';
      const wrapper = createWrapper(BASE_URL);

      const result = wrapper.buildJsonRequest('agency/thing/23', 'GET', {}, {
        request: {
          headers: {
            'x-request-id': 'xRequestId',
            'x-b3-traceid': 'traceId',
            'x-b3-spanid': 'spanId',
            'x-b3-parentspanid': 'parentSpanId',
            'x-b3-sampled': 'sampleId',
            'x-b3-flags': 'flags',
            'x-ot-span-context': 'spanContext',
          },
        },
      } as IRequestContext);

      assert.deepEqual(result, {
        json: true,
        method: 'GET',
        headers: {
          'x-request-id': 'xRequestId',
          'x-b3-traceid': 'traceId',
          'x-b3-spanid': 'spanId',
          'x-b3-parentspanid': 'parentSpanId',
          'x-b3-sampled': 'sampleId',
          'x-b3-flags': 'flags',
          'x-ot-span-context': 'spanContext',
        },
        url: 'http://localhost:8082/api/agency/thing/23',
      });
    });
    it('GET should forward Request Headers including manual sent', () => {
      const BASE_URL = 'http://localhost:8082/api/';
      const wrapper = createWrapper(BASE_URL);

      const result = wrapper.buildJsonRequest('agency/thing/23', 'GET', {
        headers: {
          'x-request-id': 'thisShouldNotWinId',
        },
      }, {
        request: {
          headers: {
            'x-request-id': 'xRequestId',
            'x-b3-traceid': 'traceId',
            'x-b3-spanid': 'spanId',
            'x-b3-parentspanid': 'parentSpanId',
            'x-b3-sampled': 'sampleId',
            'x-b3-flags': 'flags',
            'x-ot-span-context': 'spanContext',
          },
        },
      } as IRequestContext);

      assert.deepEqual(result, {
        json: true,
        method: 'GET',
        headers: {
          'x-request-id': 'xRequestId',
          'x-b3-traceid': 'traceId',
          'x-b3-spanid': 'spanId',
          'x-b3-parentspanid': 'parentSpanId',
          'x-b3-sampled': 'sampleId',
          'x-b3-flags': 'flags',
          'x-ot-span-context': 'spanContext',
        },
        url: 'http://localhost:8082/api/agency/thing/23',
      });
    });
  });
});