serverless/test/unit/lib/utils/telemetry/index.test.js

'use strict';

const path = require('path');
const fsp = require('fs').promises;
const fse = require('fs-extra');
const proxyquire = require('proxyquire');
const { expect } = require('chai');
const { v1: uuid } = require('uuid');
const wait = require('timers-ext/promise/sleep');
const cacheDirPath = require('../../../../../lib/utils/telemetry/cache-path');

const telemetryUrl = 'https://..';
const isFilename = RegExp.prototype.test.bind(/^(?:\.[^.].*|\.\..+|[^.].*)$/);

describe('test/unit/lib/utils/telemetry/index.test.js', () => {
  let storeLocally;
  let send;
  let expectedState = 'success';
  let usedUrl;
  let usedOptions;

  const cacheEvent = async (timestamp = Date.now()) => {
    await fse.writeJson(path.join(cacheDirPath, uuid()), { payload: {}, timestamp });
  };

  before(() => {
    ({ storeLocally, send } = proxyquire('../../../../../lib/utils/telemetry/index.js', {
      '@serverless/utils/analytics-and-notfications-url': telemetryUrl,
      './are-disabled': false,
      'node-fetch': async (url, options) => {
        usedUrl = url;
        usedOptions = options;
        await wait(500);
        switch (expectedState) {
          case 'success':
            return { status: 200, json: async () => [] };
          case 'networkError':
            throw Object.assign(new Error('Network error'), { code: 'NETWORK_ERROR' });
          case 'responseBodyError':
            return {
              status: 200,
              json: async () => {
                throw Object.assign(new Error('Response body error'), {
                  code: 'RESPONSE_BODY_ERROR',
                });
              },
            };
          default:
            throw new Error(`Unexpected state: ${expectedState}`);
        }
      },
    }));
  });

  afterEach(async () => {
    usedOptions = null;
    usedUrl = null;
    const dirFilenames = await fsp.readdir(cacheDirPath);
    await Promise.all(
      dirFilenames.map(async (filename) => fsp.unlink(path.join(cacheDirPath, filename)))
    );
  });

  it('`storeLocally` should persist an event in cacheDir', async () => {
    const payload = { test: 'payloadvalue' };
    storeLocally(payload);
    const dirFilenames = await fsp.readdir(cacheDirPath);
    expect(dirFilenames.length).to.equal(1);
    const persistedEvent = await fse.readJson(path.join(cacheDirPath, dirFilenames[0]));
    expect(persistedEvent.payload).to.deep.equal({ ...payload, id: dirFilenames[0] });
    expect(persistedEvent).to.have.property('timestamp');
  });

  it('Should cache failed requests and rerun then with `send`', async () => {
    expectedState = 'networkError';
    await cacheEvent();
    await send();
    expect(usedUrl).to.equal(telemetryUrl);
    const dirFilenames = await fsp.readdir(cacheDirPath);
    expect(dirFilenames.filter(isFilename).length).to.equal(1);

    expectedState = 'success';
    await send();
    const dirFilenamesAfterSend = await fsp.readdir(cacheDirPath);
    expect(dirFilenamesAfterSend.filter(isFilename).length).to.equal(0);

    // Check that one event was send with request
    expect(JSON.parse(usedOptions.body)).to.have.lengthOf(1);
  });

  it('Should ditch stale events at `send`', async () => {
    await Promise.all([cacheEvent(0), cacheEvent(0), cacheEvent(), cacheEvent(), cacheEvent(0)]);
    expectedState = 'success';
    const dirFilenames = await fsp.readdir(cacheDirPath);
    expect(dirFilenames.filter(isFilename).length).to.equal(5);
    await send();
    const dirFilenamesAfterSend = await fsp.readdir(cacheDirPath);
    expect(dirFilenamesAfterSend.filter(isFilename).length).to.equal(0);
    // Check if only two events were send with request
    expect(JSON.parse(usedOptions.body)).to.have.lengthOf(2);
  });

  it('Should ignore body procesing error', async () => {
    expectedState = 'responseBodyError';
    await cacheEvent();
    await send();
    const dirFilenames = await fsp.readdir(cacheDirPath);
    expect(dirFilenames.filter(isFilename).length).to.equal(0);
  });

  it('Should not send request when there are no events to send', async () => {
    await send();
    expect(usedUrl).to.be.null;
    expect(usedOptions).to.be.null;
  });
});