insomnia/app/common/__tests__/har.test.js

import path from 'path';
import * as harUtils from '../har';
import * as render from '../render';
import * as models from '../../models';
import {AUTH_BASIC} from '../constants';
import {globalBeforeEach} from '../../__jest__/before-each';

describe('exportHar()', () => {
  beforeEach(globalBeforeEach);
  it('exports single requests', async () => {
    const wrk = await models.workspace.create({_id: 'wrk_1', name: 'Workspace'});
    const req1 = await models.request.create({
      _id: 'req_1',
      name: 'Request 1',
      parentId: wrk._id,

      url: 'https://httpstat.us/200',
      method: 'POST',
      body: {
        mimeType: 'application/json',
        text: '{}'
      },
      headers: [
        { name: 'Content-Type', value: 'application/json' },
        { name: 'Accept', value: 'application/json', disabled: false },
        { name: 'X-Disabled', value: 'X-Disabled', disabled: true }
      ]
    });
    await models.response.create({
      parentId: req1._id,

      statusCode: 200,
      statusMessage: 'OK',
      elapsedTime: 999,
      headers: [
        { name: 'Content-Type', value: 'application/json' }
      ],
      contentType: 'application/json',
      bodyPath: path.join(__dirname, '../__fixtures__/har/test-response.json.gz')
    });

    const exportRequests = [ { requestId: req1._id, environmentId: 'n/a' } ];
    const harExport = await harUtils.exportHar(exportRequests);

    expect(harExport).toMatchObject({
      log: {
        version: '1.2',
        creator: {
          name: 'Insomnia REST Client'
        },
        entries: [
          {
            startedDateTime: expect.any(String),
            time: 999,
            request: {
              method: 'POST',
              url: 'https://httpstat.us/200',
              httpVersion: 'HTTP/1.1',
              cookies: [],
              headers: [
                { name: 'Content-Type', value: 'application/json' },
                { name: 'Accept', value: 'application/json' }
              ],
              queryString: [],
              postData: {
                mimeType: 'application/json',
                params: [],
                text: '{}'
              },
              headersSize: -1,
              bodySize: -1
            },
            response: {
              status: 200,
              statusText: 'OK',
              httpVersion: 'HTTP/1.1',
              cookies: [],
              headers: [
                { name: 'Content-Type', value: 'application/json' }
              ],
              content: {
                size: 15,
                mimeType: 'application/json',
                text: '{"key":"value"}'
              },
              redirectURL: '',
              headersSize: -1,
              bodySize: -1
            },
            cache: {},
            timings: {
              blocked: -1,
              dns: -1,
              connect: -1,
              send: 0,
              wait: 999,
              receive: 0,
              ssl: -1
            },
            comment: req1.name
          }
        ]
      }
    });
  });

  it('exports multiple requests', async () => {
    const workspace = await models.workspace.create({_id: 'wrk_1', name: 'Workspace'});

    const baseReq = await models.request.create({
      _id: 'req_0',
      type: models.request.type,
      name: 'Request',
      parentId: workspace._id,

      url: 'http://localhost',
      method: 'GET',
      body: {},
      headers: [
        { name: 'X-Environment', value: '{{ envvalue }}' }
      ]
    });
    const req1 = await models.request.duplicate(baseReq);
    req1._id = 'req_1';
    req1.name = 'Request 1';
    req1.headers.push({ name: 'X-Request', value: '1' });
    await models.request.create(req1);
    const req2 = await models.request.duplicate(baseReq);
    req2._id = 'req_2';
    req2.name = 'Request 2';
    req2.headers.push({ name: 'X-Request', value: '2' });
    await models.request.create(req2);
    const req3 = await models.request.duplicate(baseReq);
    req3._id = 'req_3';
    req3.name = 'Request 3';
    req3.headers.push({ name: 'X-Request', value: '3' });
    await models.request.create(req3);

    await models.response.create({
      _id: 'res_1',
      parentId: req1._id,
      statusCode: 204
    });
    await models.response.create({
      _id: 'res_2',
      parentId: req2._id,
      statusCode: 404
    });
    await models.response.create({
      _id: 'res_3',
      parentId: req3._id,
      statusCode: 500
    });

    const envBase = await models.environment.getOrCreateForWorkspace(workspace);
    await models.environment.update(envBase, {
      data: {
        envvalue: ''
      }
    });
    const envPublic = await models.environment.create({_id: 'env_1', name: 'Public', parentId: envBase._id});
    await models.environment.update(envPublic, {
      data: {
        envvalue: 'public'
      }
    });
    const envPrivate = await models.environment.create({_id: 'env_2', name: 'Private', isPrivate: true, parentId: envBase._id});
    await models.environment.update(envPrivate, {
      data: {
        envvalue: 'private'
      }
    });

    const exportRequests = [
      { requestId: req1._id, environmentId: 'n/a' },
      { requestId: req2._id, environmentId: envPublic._id },
      { requestId: req3._id, environmentId: envPrivate._id }
    ];
    const harExport = await harUtils.exportHar(exportRequests);

    expect(harExport).toMatchObject({
      log: {
        version: '1.2',
        creator: {
          name: 'Insomnia REST Client'
        },
        entries: [
          {
            request: {
              headers: [
                { name: 'X-Environment', value: '' },
                { name: 'X-Request', value: '1' }
              ]
            },
            response: {
              status: 204
            },
            comment: req1.name
          },
          {
            request: {
              headers: [
                { name: 'X-Environment', value: 'public' },
                { name: 'X-Request', value: '2' }
              ]
            },
            response: {
              status: 404
            },
            comment: req2.name
          },
          {
            request: {
              headers: [
                { name: 'X-Environment', value: 'private' },
                { name: 'X-Request', value: '3' }
              ]
            },
            response: {
              status: 500
            },
            comment: req3.name
          }
        ]
      }
    });
  });
});

describe('exportHarResponse()', () => {
  beforeEach(globalBeforeEach);
  it('exports a default har response for an empty response', async () => {
    const notFoundResponse = null;

    const harResponse = await harUtils.exportHarResponse(notFoundResponse);

    expect(harResponse).toMatchObject({
      status: 0,
      statusText: '',
      httpVersion: 'HTTP/1.1',
      content: {
        size: 0,
        mimeType: ''
      }
    });
  });
  it('exports a valid har response for a non empty response', async () => {
    const response = Object.assign(models.response.init(), {
      _id: 'res_123',
      type: models.response.type,
      parentId: 'req_123',
      modified: 0,
      created: 0,

      statusCode: 200,
      statusMessage: 'OK',
      headers: [
        { name: 'Content-Type', value: 'application/json' },
        { name: 'Content-Length', value: '2' },
        { name: 'Set-Cookie', value: 'sessionid=12345; HttpOnly; Path=/' }
      ],
      contentType: 'application/json',
      bodyPath: path.join(__dirname, '../__fixtures__/har/test-response.json.gz')
    });

    const harResponse = await harUtils.exportHarResponse(response);

    expect(harResponse).toMatchObject({
      status: 200,
      statusText: 'OK',
      httpVersion: 'HTTP/1.1',
      cookies: [
        {
          name: 'sessionid',
          value: '12345',
          path: '/',
          httpOnly: true
        }
      ],
      headers: [
        { name: 'Content-Type', value: 'application/json' },
        { name: 'Content-Length', value: '2' },
        { name: 'Set-Cookie', value: 'sessionid=12345; HttpOnly; Path=/' }
      ],
      content: {
        size: 15,
        mimeType: 'application/json',
        text: '{"key":"value"}'
      },
      redirectURL: '',
      headersSize: -1,
      bodySize: -1
    });
  });
});

describe('exportHarWithRequest()', () => {
  beforeEach(globalBeforeEach);
  it('renders does it correctly', async () => {
    const workspace = await models.workspace.create();
    const cookies = [{
      creation: new Date('2016-10-05T04:40:49.505Z'),
      key: 'foo',
      value: 'barrrrr',
      expires: new Date('2096-10-12T04:40:49.000Z'),
      domain: 'google.com',
      path: '/',
      hostOnly: true,
      lastAccessed: new Date('2096-10-05T04:40:49.505Z')
    }];

    const cookieJar = await models.cookieJar.getOrCreateForParentId(workspace._id);
    await models.cookieJar.update(cookieJar, {
      parentId: workspace._id,
      cookies
    });

    const request = Object.assign(models.request.init(), {
      _id: 'req_123',
      parentId: workspace._id,
      headers: [{name: 'Content-Type', value: 'application/json'}],
      parameters: [{name: 'foo bar', value: 'hello&world'}],
      method: 'POST',
      body: {
        text: 'foo bar'
      },
      url: 'http://google.com',
      authentication: {
        type: AUTH_BASIC,
        username: 'user',
        password: 'pass'
      }
    });

    const renderedRequest = await render.getRenderedRequest(request);
    const har = await harUtils.exportHarWithRequest(renderedRequest);

    expect(har.cookies.length).toBe(1);
    expect(har).toEqual({
      bodySize: -1,
      cookies: [{
        domain: 'google.com',
        expires: '2096-10-12T04:40:49.000Z',
        name: 'foo',
        path: '/',
        value: 'barrrrr'
      }],
      headers: [
        {name: 'Content-Type', value: 'application/json'},
        {name: 'Authorization', value: 'Basic dXNlcjpwYXNz'}
      ],
      headersSize: -1,
      httpVersion: 'HTTP/1.1',
      method: 'POST',
      postData: {
        mimeType: '',
        params: [],
        text: 'foo bar'
      },
      queryString: [{name: 'foo bar', value: 'hello&world'}],
      url: 'http://google.com/'
    });
  });
});