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');
+const { MysteryBoxError } = require('../../lib/errors');
+const crypto = require('crypto');
+
+function _verbose(mb) {
+ if (process.env.VERBOSE_TESTS) {
+ mb.on('statistics', (...args) => console.log(...args));
+ }
+}
describe('MysteryBox', function () {
let mb, options, object;
options = {
encryptionSecret: 'this is not a very good secret',
};
- mb = new MysteryBox(stubLogger, options);
});
afterEach(function () {
sinon.restore();
describe('constructor', function () {
it('needs a secret', async function () {
options = {};
- assert.rejects(() => new MysteryBox(stubLogger, options));
+ assert.rejects(() => new MysteryBox(options));
});
it('accepts multiple secrets', async function () {
options = {
encryptionSecret: ['first poor secret', 'second poor secret'],
};
- mb = new MysteryBox(stubLogger, options);
+ mb = new MysteryBox(options);
+ _verbose(mb);
object = {
foo: 'bar',
baz: 'quux',
});
it('covers options', function () {
- assert.rejects(() => new MysteryBox(stubLogger));
+ assert.rejects(() => new MysteryBox());
});
it('covers bad flags', function () {
options.defaultFlags = 300;
- assert.rejects(() => new MysteryBox(stubLogger, options), RangeError);
+ assert.rejects(() => new MysteryBox(options), MysteryBoxError);
});
it('covers missing ciphers', function () {
- sinon.stub(MysteryBox._test.crypto, 'getCiphers').returns(['rot13']);
- assert.rejects(() => new MysteryBox(stubLogger, options));
+ sinon.stub(crypto, 'getCiphers').returns(['rot13']);
+ assert.rejects(() => new MysteryBox(options));
});
}); // constructor
+ describe('_ensureArray', function () {
+ it('returns empty array for no data', function () {
+ const result = MysteryBox._ensureArray();
+ assert.deepStrictEqual(result, []);
+ });
+ it('returns same array passed in', function () {
+ const expected = [1, 2, 3, 'foo'];
+ const result = MysteryBox._ensureArray(expected);
+ assert.deepStrictEqual(result, expected);
+ });
+ it('returns array containing non-array data', function () {
+ const data = 'bar';
+ const result = MysteryBox._ensureArray(data);
+ assert.deepStrictEqual(result, [data]);
+ });
+ }); // _ensureArray
+
describe('_keyFromSecret', function () {
it('covers invalid', async function () {
- assert.rejects(() => MysteryBox._keyFromSecret('unknown deriver', 'secret', 'salt', 32), RangeError);
+ assert.rejects(() => MysteryBox._keyFromSecret('unknown deriver', 'secret', 'salt', 32), MysteryBoxError);
});
}); // _keyFromSecret
_check(0xfe, 8, 0x00);
});
it('covers unsupported', function () {
- assert.throws(() => MysteryBox._versionHeaderDecode(0xff), RangeError);
+ assert.throws(() => MysteryBox._versionHeaderDecode(0xff), MysteryBoxError);
});
}); // _versionHeaderDecode
});
it('covers too big', function () {
const buffer = Buffer.from([0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
- assert.throws(() => MysteryBox._versionDecode(buffer), RangeError);
+ assert.throws(() => MysteryBox._versionDecode(buffer), MysteryBoxError);
});
}); // _versionDecode
});
it('covers too large', function () {
const version = 277076930199552;
- assert.rejects(() => MysteryBox._versionEncode(version), RangeError);
+ assert.rejects(() => MysteryBox._versionEncode(version), MysteryBoxError);
});
it('recipricates', function () {
[
describe('pack, unpack', function () {
beforeEach(function () {
- mb = new MysteryBox(stubLogger, options);
+ mb = new MysteryBox(options);
+ _verbose(mb);
});
it('covers packing unsupported version', async function () {
- assert.rejects(() => mb.pack({}, 0), RangeError);
+ assert.rejects(() => mb.pack({}, 0), MysteryBoxError);
});
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('base64url');
- assert.rejects(() => mb.unpack(badPayload), RangeError);
+ assert.rejects(() => mb.unpack(badPayload), MysteryBoxError);
});
it('encrypts and decrypts default version', async function () {
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'] });
+ const oldmb = new MysteryBox({ encryptionSecret: 'old secret' });
+ _verbose(oldmb);
+ const newmb = new MysteryBox({ encryptionSecret: ['new secret', 'old secret'] });
+ _verbose(newmb);
object = {
foo: 'bar',
baz: 'quux',
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'] });
+ const oldmb = new MysteryBox({ encryptionSecret: 'very old secret' });
+ _verbose(oldmb);
+ const newmb = new MysteryBox({ encryptionSecret: ['new secret', 'old secret'] });
+ _verbose(newmb);
object = {
foo: 'bar',
baz: 'quux',
assert.rejects(() => newmb.unpack(oldEncrypted));
});
- it('encrypts and decrypts all available versions +brotli', async function () {
+ it('encrypts and decrypts all available versions no compression', async function () {
Object.keys(mb.versionParameters).map((v) => Number(v)).forEach(async (version) => {
object = {
foo: 'bar',
});
});
+ 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, mb.Flags.Brotli);
+ 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 = {
baz: 'quux',
flarp: 13,
};
- const encryptedResult = await mb.pack(object, version, 0x01);
+ const encryptedResult = await mb.pack(object, version, mb.Flags.Flate);
const decryptedResult = await mb.unpack(encryptedResult);
assert.deepStrictEqual(decryptedResult, object, `${version} results not symmetric`);
});
object = {
longProperty: 'x'.repeat(384 * 1024).split('').map(() => String.fromCharCode(rnd())).join(''),
};
- const encryptedResult = await mb.pack(object, mb.bestVersion, 0x00);
+ const encryptedResult = await mb.pack(object, mb.bestVersion, mb.Flags.Brotli);
const decryptedResult = await mb.unpack(encryptedResult);
assert.deepStrictEqual(decryptedResult, object);
});
object = {
longProperty: 'x'.repeat(384 * 1024).split('').map(() => String.fromCharCode(rnd())).join(''),
};
- const encryptedResult = await mb.pack(object, mb.bestVersion, 0x01);
+ const encryptedResult = await mb.pack(object, mb.bestVersion, mb.Flags.Flate);
const decryptedResult = await mb.unpack(encryptedResult);
assert.deepStrictEqual(decryptedResult, object);
});
it('handles undefined', async function () {
- assert.rejects(() => mb.unpack(), RangeError);
+ assert.rejects(() => mb.unpack(), MysteryBoxError);
});
it('handles incomplete', async function () {
this.slow(500);
const encryptedResult = await mb.pack({ foo: 'bar' });
- assert.rejects(() => mb.unpack(encryptedResult.slice(0, 6)), RangeError);
+ assert.rejects(() => mb.unpack(encryptedResult.slice(0, 6)), MysteryBoxError);
});
it('covers internal error, incorrect version byte size, pack', async function () {
+ this.slow(500);
const version = 1;
sinon.stub(mb.versionParameters[version], 'versionBytes').value(10);
assert.rejects(() => mb.pack({}, version), Error);
});
it('covers internal error, incorrect version byte size, unpack', async function () {
+ this.slow(500);
const version = 1;
const encryptedResult = await mb.pack({}, version);
sinon.stub(mb.versionParameters[version], 'versionBytes').value(10);
projects / squeep-mystery-box / blobdiff