[squeep-mystery-box] / test / lib / mystery-box.js

/* eslint-env mocha */
/* eslint-disable capitalized-comments */
'use strict';

const assert = require('assert');
const sinon = require('sinon'); // eslint-disable-line node/no-unpublished-require
const MysteryBox = require('../../lib/mystery-box');
const stubLogger = require('../stub-logger');

describe('MysteryBox', function () {
  let mb, options, object;
  beforeEach(function () {
    options = {
      encryptionSecret: 'this is not a very good secret',
    };
  });
  afterEach(function () {
    sinon.restore();
  });

  describe('constructor', function () {
    it('needs a secret', async function () {
      options = {};
      assert.rejects(() => new MysteryBox(stubLogger, options));
    });

    it('accepts multiple secrets', async function () {
      this.slow(500);
      options = {
        encryptionSecret: ['first poor secret', 'second poor secret'],
      };
      mb = new MysteryBox(stubLogger, options);
      object = {
        foo: 'bar',
        baz: 'quux',
        flarp: 13,
      };
      const encryptedResult = await mb.pack(object);
      const decryptedResult = await mb.unpack(encryptedResult);
      assert.deepStrictEqual(decryptedResult, object);
    });

    it('covers options', function () {
      assert.rejects(() => new MysteryBox(stubLogger));
    });

    it('covers bad flags', function () {
      options.defaultFlags = 300;
      assert.rejects(() => new MysteryBox(stubLogger, options), RangeError);
    });

    it('covers missing ciphers', function () {
      sinon.stub(MysteryBox._test.crypto, 'getCiphers').returns(['rot13']);
      assert.rejects(() => new MysteryBox(stubLogger, options));
    });
  }); // constructor

  describe('_keyFromSecret', function () {
    it('covers invalid', async function () {
      assert.rejects(() => MysteryBox._keyFromSecret('unknown deriver', 'secret', 'salt', 32), RangeError);
    });
  }); // _keyFromSecret

  describe('pack, unpack', function () {
    beforeEach(function () {
      mb = new MysteryBox(stubLogger, options);
    });
  
    it('covers packing unsupported version', async function () {
      assert.rejects(() => mb.pack({}, 0), RangeError);
    });

    it('covers unpacking unsupported version', async function () {
      const badBuffer = Buffer.alloc(128);
      badBuffer.writeUInt8(0, 0); // No such thing as version 0
      const badPayload = badBuffer.toString('base64');
      assert.rejects(() => mb.unpack(badPayload), RangeError);
    });

    it('encrypts and decrypts default version', async function () {
      this.slow(500);
      object = {
        foo: 'bar',
        baz: 'quux',
        flarp: 13,
      };
      const encryptedResult = await mb.pack(object);
      const decryptedResult = await mb.unpack(encryptedResult);
      assert.deepStrictEqual(decryptedResult, object);
    });

    it('encrypts and decrypts default version, buffer contents', async function () {
      this.slow(500);
      object = Buffer.from('a fine little buffer');
      const encryptedResult = await mb.pack(object);
      const decryptedResult = await mb.unpack(encryptedResult);
      assert.deepStrictEqual(decryptedResult, object);
    });

    it('decrypts secondary (older) secret', async function () {
      this.slow(500);
      const oldmb = new MysteryBox(stubLogger, { encryptionSecret: 'old secret' });
      const newmb = new MysteryBox(stubLogger, { encryptionSecret: ['new secret', 'old secret'] });
      object = {
        foo: 'bar',
        baz: 'quux',
        flarp: 13,
      };
      const oldEncrypted = await oldmb.pack(object);
      const newDecrypted = await newmb.unpack(oldEncrypted);
      assert.deepStrictEqual(newDecrypted, object);
    });

    it('fails to decrypt invalid secret', async function () {
      this.slow(500);
      const oldmb = new MysteryBox(stubLogger, { encryptionSecret: 'very old secret' });
      const newmb = new MysteryBox(stubLogger, { encryptionSecret: ['new secret', 'old secret'] });
      object = {
        foo: 'bar',
        baz: 'quux',
        flarp: 13,
      };
      const oldEncrypted = await oldmb.pack(object);
      assert.rejects(() => newmb.unpack(oldEncrypted));
    });

    it('encrypts and decrypts all available versions +brotli', async function () {
      Object.keys(mb.versionParameters).map((v) => Number(v)).forEach(async (version) => {
        object = {
          foo: 'bar',
          baz: 'quux',
          flarp: 13,
        };
        const encryptedResult = await mb.pack(object, version, 0x00);
        const decryptedResult = await mb.unpack(encryptedResult);
        assert.deepStrictEqual(decryptedResult, object, `${version} results not symmetric`);
      });
    });

    it('encrypts and decrypts all available versions +flate', async function () {
      Object.keys(mb.versionParameters).map((v) => Number(v)).forEach(async (version) => {
        object = {
          foo: 'bar',
          baz: 'quux',
          flarp: 13,
        };
        const encryptedResult = await mb.pack(object, version, 0x01);
        const decryptedResult = await mb.unpack(encryptedResult);
        assert.deepStrictEqual(decryptedResult, object, `${version} results not symmetric`);
      });
    });

    it('handles large object +brotli', async function () {
      this.timeout(5000);
      this.slow(2000);
      const firstChar = 32, lastChar = 126;
      const rnd = () => {
        return Math.floor(firstChar + (lastChar - firstChar + 1) * Math.random());
      }
      object = {
        longProperty: 'x'.repeat(384 * 1024).split('').map(() => String.fromCharCode(rnd())).join(''),
      };
      const encryptedResult = await mb.pack(object, mb.bestVersion, 0x00);
      const decryptedResult = await mb.unpack(encryptedResult);
      assert.deepStrictEqual(decryptedResult, object);
    });

    it('handles large object +flate', async function () {
      this.timeout(5000);
      this.slow(2000);
      const firstChar = 32, lastChar = 126;
      const rnd = () => {
        return Math.floor(firstChar + (lastChar - firstChar + 1) * Math.random());
      }
      object = {
        longProperty: 'x'.repeat(384 * 1024).split('').map(() => String.fromCharCode(rnd())).join(''),
      };
      const encryptedResult = await mb.pack(object, mb.bestVersion, 0x01);
      const decryptedResult = await mb.unpack(encryptedResult);
      assert.deepStrictEqual(decryptedResult, object);
    });

    it('handles undefined', async function () {
      assert.rejects(() => mb.unpack(), RangeError);
    });

    it('handles incomplete', async function () {
      this.slow(500);
      const encryptedResult = await mb.pack({ foo: 'bar' });
      assert.rejects(() => mb.unpack(encryptedResult.slice(0, 6)), RangeError);
    });

  }); // pack, unpack

}); // MysteryBox