diff --git a/tests/ApprovalController.test.js b/tests/ApprovalController.test.js index 38daf92a89c..6f174aea25a 100644 --- a/tests/ApprovalController.test.js +++ b/tests/ApprovalController.test.js @@ -1,4 +1,3 @@ -const assert = require('assert'); const { ERROR_CODES } = require('eth-rpc-errors'); const ApprovalController = require('../dist/approval/ApprovalController.js').default; @@ -13,40 +12,25 @@ describe('ApprovalController: Input Validation', () => { it('validates input', () => { const approvalController = getApprovalController(); - assert.throws( - () => approvalController.add({ id: null, origin: 'bar.baz' }), - getNoFalsyIdError(), - 'should throw on falsy id', - ); + expect(() => approvalController.add({ id: null, origin: 'bar.baz' })).toThrow(getNoFalsyIdError()); - assert.throws( - () => approvalController.add({ id: 'foo' }), - getMissingOriginError(), - 'should throw on falsy origin', - ); + expect(() => approvalController.add({ id: 'foo' })).toThrow(getMissingOriginError()); - assert.throws( - () => approvalController.add({ id: 'foo', origin: 'bar.baz', type: {} }), + expect(() => approvalController.add({ id: 'foo', origin: 'bar.baz', type: {} })).toThrow( getNonStringTypeError(ERROR_CODES.rpc.internal), - 'should throw on non-string type', ); - assert.throws( - () => approvalController.add({ id: 'foo', origin: 'bar.baz', type: '' }), + expect(() => approvalController.add({ id: 'foo', origin: 'bar.baz', type: '' })).toThrow( getEmptyStringTypeError(ERROR_CODES.rpc.internal), - 'should throw on empty string type', ); - assert.throws( - () => - approvalController.add({ - id: 'foo', - origin: 'bar.baz', - requestData: 'foo', - }), - getInvalidRequestDataError(), - 'should throw on non-object requestData', - ); + expect(() => + approvalController.add({ + id: 'foo', + origin: 'bar.baz', + requestData: 'foo', + }), + ).toThrow(getInvalidRequestDataError()); }); }); @@ -56,11 +40,11 @@ describe('ApprovalController: Input Validation', () => { approvalController.add({ id: 'foo', origin: 'bar.baz' }); - assert.strictEqual(approvalController.get('fizz'), undefined, 'should return undefined'); + expect(approvalController.get('fizz')).toBeUndefined(); - assert.strictEqual(approvalController.get(), undefined, 'should return undefined'); + expect(approvalController.get()).toBeUndefined(); - assert.strictEqual(approvalController.get({}), undefined, 'should return undefined'); + expect(approvalController.get({})).toBeUndefined(); }); }); @@ -68,13 +52,9 @@ describe('ApprovalController: Input Validation', () => { it('validates input', () => { const approvalController = getApprovalController(); - assert.throws( - () => approvalController.has({}), - getMissingIdOrOriginError(), - 'should throw on falsy id and origin', - ); + expect(() => approvalController.has({})).toThrow(getMissingIdOrOriginError()); - assert.throws(() => approvalController.has({ type: false }), getNoFalsyTypeError(), 'should throw on falsy type'); + expect(() => approvalController.has({ type: false })).toThrow(getNoFalsyTypeError()); }); }); @@ -92,12 +72,11 @@ describe('ApprovalController: Input Validation', () => { approvalController._delete('foo'); - assert.ok( + expect( !approvalController.has({ id: 'foo' }) && !approvalController.has({ origin: 'bar.baz' }) && !approvalController.state[STORE_KEY].foo, - 'should have deleted entry', - ); + ).toEqual(true); }); it('deletes one entry out of many without side-effects', () => { @@ -106,36 +85,26 @@ describe('ApprovalController: Input Validation', () => { approvalController._delete('fizz'); - assert.ok( + expect( !approvalController.has({ id: 'fizz' }) && !approvalController.has({ origin: 'bar.baz', type: 'myType' }), - 'should have deleted entry', - ); + ).toEqual(true); - assert.ok( - approvalController.has({ id: 'foo' }) && approvalController.has({ origin: 'bar.baz' }), - 'should still have non-deleted entry', - ); + expect(approvalController.has({ id: 'foo' }) && approvalController.has({ origin: 'bar.baz' })).toEqual(true); }); it('does nothing when deleting non-existing entry', () => { approvalController.add({ id: 'foo', origin: 'bar.baz' }); - assert.doesNotThrow( - () => approvalController._delete('fizz'), - 'should not throw when deleting non-existing entry', - ); + expect(() => approvalController._delete('fizz')).not.toThrow(); - assert.ok( - approvalController.has({ id: 'foo' }) && approvalController.has({ origin: 'bar.baz' }), - 'should still have non-deleted entry', - ); + expect(approvalController.has({ id: 'foo' }) && approvalController.has({ origin: 'bar.baz' })).toEqual(true); }); }); describe('miscellaneous', () => { it('isEmptyOrigin: handles non-existing origin', () => { const approvalController = getApprovalController(); - assert.doesNotThrow(() => approvalController._isEmptyOrigin('kaplar')); + expect(() => approvalController._isEmptyOrigin('kaplar')).not.toThrow(); }); }); }); diff --git a/tests/ApprovalController.test.ts b/tests/ApprovalController.test.ts index 0beea49818b..87a25a3adbf 100644 --- a/tests/ApprovalController.test.ts +++ b/tests/ApprovalController.test.ts @@ -1,6 +1,5 @@ import ApprovalController from '../dist/approval/ApprovalController'; -const assert = require('assert'); const { ERROR_CODES } = require('eth-rpc-errors'); const sinon = require('sinon'); @@ -24,100 +23,73 @@ describe('approval controller', () => { }); it('adds id if non provided', () => { - assert.doesNotThrow(() => approvalController.add({ id: undefined, origin: 'bar.baz' }), 'should add entry'); + expect(() => approvalController.add({ id: undefined, origin: 'bar.baz' })).not.toThrow(); const id = Object.keys(approvalController.state[STORE_KEY])[0]; - assert.ok(id && typeof id === 'string', 'should have added entry with string id'); + expect(id && typeof id === 'string').toBeTruthy(); }); it('adds correctly specified entry with custom type', () => { - assert.doesNotThrow(() => approvalController.add({ id: 'foo', origin: 'bar.baz', type: 'myType' })); - - assert.ok(approvalController.has({ id: 'foo' }), 'should have added entry'); - assert.ok(approvalController.has({ origin: 'bar.baz', type: 'myType' }), 'should have added entry'); - assert.deepStrictEqual( - approvalController.state[STORE_KEY], - { foo: { id: 'foo', origin: 'bar.baz', type: 'myType' } }, - 'should have added entry to store', - ); + expect(() => approvalController.add({ id: 'foo', origin: 'bar.baz', type: 'myType' })).not.toThrow(); + + expect(approvalController.has({ id: 'foo' })).toEqual(true); + expect(approvalController.has({ origin: 'bar.baz', type: 'myType' })).toEqual(true); + expect(approvalController.state[STORE_KEY]).toEqual({ foo: { id: 'foo', origin: 'bar.baz', type: 'myType' } }); }); it('adds correctly specified entry with request data', () => { - assert.doesNotThrow(() => + expect(() => approvalController.add({ id: 'foo', origin: 'bar.baz', type: undefined, requestData: { foo: 'bar' }, }), - ); + ).not.toThrow(); - assert.ok(approvalController.has({ id: 'foo' }), 'should have added entry'); - assert.ok(approvalController.has({ origin: 'bar.baz' }), 'should have added entry'); - assert.deepStrictEqual( - approvalController.state[STORE_KEY].foo.requestData, - { foo: 'bar' }, - 'should have added entry with correct request data', - ); + expect(approvalController.has({ id: 'foo' })).toEqual(true); + expect(approvalController.has({ origin: 'bar.baz' })).toEqual(true); + expect(approvalController.state[STORE_KEY].foo.requestData).toEqual({ foo: 'bar' }); }); it('adds multiple entries for same origin with different types and ids', () => { const ORIGIN = 'bar.baz'; - assert.doesNotThrow(() => approvalController.add({ id: 'foo1', origin: ORIGIN }), 'should add entry'); - assert.doesNotThrow( - () => approvalController.add({ id: 'foo2', origin: ORIGIN, type: 'myType1' }), - 'should add entry', - ); - assert.doesNotThrow( - () => approvalController.add({ id: 'foo3', origin: ORIGIN, type: 'myType2' }), - 'should add entry', - ); + expect(() => approvalController.add({ id: 'foo1', origin: ORIGIN })).not.toThrow(); + expect(() => approvalController.add({ id: 'foo2', origin: ORIGIN, type: 'myType1' })).not.toThrow(); + expect(() => approvalController.add({ id: 'foo3', origin: ORIGIN, type: 'myType2' })).not.toThrow(); - assert.ok( + expect( approvalController.has({ id: 'foo1' }) && approvalController.has({ id: 'foo3' }) && approvalController.has({ id: 'foo3' }), - 'should have added entries', - ); - assert.ok( + ).toEqual(true); + expect( approvalController.has({ origin: ORIGIN }) && approvalController.has({ origin: ORIGIN, type: 'myType1' }) && approvalController.has({ origin: ORIGIN, type: 'myType2' }), - 'should have added entries', - ); + ).toEqual(true); }); it('throws on id collision', () => { - assert.doesNotThrow(() => approvalController.add({ id: 'foo', origin: 'bar.baz' }), 'should add entry'); + expect(() => approvalController.add({ id: 'foo', origin: 'bar.baz' })).not.toThrow(); - assert.throws( - () => approvalController.add({ id: 'foo', origin: 'fizz.buzz' }), - getIdCollisionError('foo'), - 'should have thrown expected error', - ); + expect(() => approvalController.add({ id: 'foo', origin: 'fizz.buzz' })).toThrow(getIdCollisionError('foo')); }); it('throws on origin and default type collision', () => { - assert.doesNotThrow(() => approvalController.add({ id: 'foo', origin: 'bar.baz' }), 'should add entry'); + expect(() => approvalController.add({ id: 'foo', origin: 'bar.baz' })).not.toThrow(); - assert.throws( - () => approvalController.add({ id: 'foo1', origin: 'bar.baz' }), + expect(() => approvalController.add({ id: 'foo1', origin: 'bar.baz' })).toThrow( getOriginTypeCollisionError('bar.baz'), - 'should have thrown expected error', ); }); it('throws on origin and custom type collision', () => { - assert.doesNotThrow( - () => approvalController.add({ id: 'foo', origin: 'bar.baz', type: 'myType' }), - 'should add entry', - ); + expect(() => approvalController.add({ id: 'foo', origin: 'bar.baz', type: 'myType' })).not.toThrow(); - assert.throws( - () => approvalController.add({ id: 'foo1', origin: 'bar.baz', type: 'myType' }), + expect(() => approvalController.add({ id: 'foo1', origin: 'bar.baz', type: 'myType' })).toThrow( getOriginTypeCollisionError('bar.baz', 'myType'), - 'should have thrown expected error', ); }); }); @@ -136,8 +108,8 @@ describe('approval controller', () => { type: 'myType', requestData: { foo: 'bar' }, }); - assert.ok(result instanceof Promise, 'should return expected result'); - assert.ok(showApprovalSpy.calledOnce, 'should have called _showApprovalRequest once'); + expect(result instanceof Promise).toEqual(true); + expect(showApprovalSpy.calledOnce).toEqual(true); }); }); @@ -151,21 +123,13 @@ describe('approval controller', () => { it('gets entry with default type', () => { approvalController.add({ id: 'foo', origin: 'bar.baz' }); - assert.deepStrictEqual( - approvalController.get('foo'), - { id: 'foo', origin: 'bar.baz' }, - 'should retrieve expected entry', - ); + expect(approvalController.get('foo')).toEqual({ id: 'foo', origin: 'bar.baz' }); }); it('gets entry with custom type', () => { approvalController.add({ id: 'foo', origin: 'bar.baz', type: 'myType' }); - assert.deepStrictEqual( - approvalController.get('foo'), - { id: 'foo', origin: 'bar.baz', type: 'myType' }, - 'should retrieve expected entry', - ); + expect(approvalController.get('foo')).toEqual({ id: 'foo', origin: 'bar.baz', type: 'myType' }); }); }); @@ -179,57 +143,37 @@ describe('approval controller', () => { it('returns true for existing entry by id', () => { approvalController.add({ id: 'foo', origin: 'bar.baz' }); - assert.strictEqual(approvalController.has({ id: 'foo' }), true, 'should return true for existing entry by id'); + expect(approvalController.has({ id: 'foo' })).toEqual(true); }); it('returns true for existing entry by origin', () => { approvalController.add({ id: 'foo', origin: 'bar.baz' }); - assert.strictEqual( - approvalController.has({ origin: 'bar.baz' }), - true, - 'should return true for existing entry by origin', - ); + expect(approvalController.has({ origin: 'bar.baz' })).toEqual(true); }); it('returns true for existing entry by origin and custom type', () => { approvalController.add({ id: 'foo', origin: 'bar.baz', type: 'myType' }); - assert.strictEqual( - approvalController.has({ origin: 'bar.baz', type: 'myType' }), - true, - 'should return true for existing entry by origin and custom type', - ); + expect(approvalController.has({ origin: 'bar.baz', type: 'myType' })).toEqual(true); }); it('returns false for non-existing entry by id', () => { approvalController.add({ id: 'foo', origin: 'bar.baz' }); - assert.strictEqual( - approvalController.has({ id: 'fizz' }), - false, - 'should return false for non-existing entry by id', - ); + expect(approvalController.has({ id: 'fizz' })).toEqual(false); }); it('returns false for non-existing entry by origin', () => { approvalController.add({ id: 'foo', origin: 'bar.baz' }); - assert.strictEqual( - approvalController.has({ origin: 'fizz.buzz' }), - false, - 'should return false for non-existing entry by origin', - ); + expect(approvalController.has({ origin: 'fizz.buzz' })).toEqual(false); }); it('returns false for non-existing entry by origin and type', () => { approvalController.add({ id: 'foo', origin: 'bar.baz' }); - assert.strictEqual( - approvalController.has({ origin: 'bar.baz', type: 'myType' }), - false, - 'should return false for non-existing entry by origin and type', - ); + expect(approvalController.has({ origin: 'bar.baz', type: 'myType' })).toEqual(false); }); }); @@ -244,10 +188,6 @@ describe('approval controller', () => { numDeletions = 0; }); - afterEach(() => { - assert.strictEqual(deleteSpy.callCount, numDeletions, `should have called '_delete' ${numDeletions} times`); - }); - it('resolves approval promise', async () => { numDeletions = 1; @@ -255,7 +195,8 @@ describe('approval controller', () => { approvalController.resolve('foo', 'success'); const result = await approvalPromise; - assert.strictEqual(result, 'success', 'should have resolved expected value'); + expect(result).toEqual('success'); + expect(deleteSpy.callCount).toEqual(numDeletions); }); it('resolves multiple approval promises out of order', async () => { @@ -267,16 +208,18 @@ describe('approval controller', () => { approvalController.resolve('foo2', 'success2'); let result = await approvalPromise2; - assert.strictEqual(result, 'success2', 'should have resolved expected value'); + expect(result).toEqual('success2'); approvalController.resolve('foo1', 'success1'); result = await approvalPromise1; - assert.strictEqual(result, 'success1', 'should have resolved expected value'); + expect(result).toEqual('success1'); + expect(deleteSpy.callCount).toEqual(numDeletions); }); it('throws on unknown id', () => { - assert.throws(() => approvalController.resolve('foo'), getIdNotFoundError('foo'), 'should reject on unknown id'); + expect(() => approvalController.resolve('foo')).toThrow(getIdNotFoundError('foo')); + expect(deleteSpy.callCount).toEqual(numDeletions); }); }); @@ -291,50 +234,41 @@ describe('approval controller', () => { numDeletions = 0; }); - afterEach(() => { - assert.strictEqual(deleteSpy.callCount, numDeletions, `should have called '_delete' ${numDeletions} times`); - }); - it('rejects approval promise', async () => { numDeletions = 1; - const approvalPromise = assert.rejects( - () => approvalController.add({ id: 'foo', origin: 'bar.baz' }), - getError('failure'), - 'should reject with expected error', - ); - approvalController.reject('foo', new Error('failure')); + const approvalPromise = approvalController.add({ id: 'foo', origin: 'bar.baz' }).catch((error) => { + expect(error).toMatchObject(getError('failure')); + }); + approvalController.reject('foo', new Error('failure')); await approvalPromise; + expect(deleteSpy.callCount).toEqual(numDeletions); }); it('rejects multiple approval promises out of order', async () => { numDeletions = 2; - const rejectionPromise1 = assert.rejects( - () => approvalController.add({ id: 'foo1', origin: 'bar.baz' }), - getError('failure1'), - 'should reject with expected error', - ); - const rejectionPromise2 = assert.rejects( - () => approvalController.add({ id: 'foo2', origin: 'bar.baz', type: 'myType2' }), - getError('failure2'), - 'should reject with expected error', - ); + const rejectionPromise1 = approvalController.add({ id: 'foo1', origin: 'bar.baz' }).catch((error) => { + expect(error).toMatchObject(getError('failure1')); + }); + const rejectionPromise2 = approvalController + .add({ id: 'foo2', origin: 'bar.baz', type: 'myType2' }) + .catch((error) => { + expect(error).toMatchObject(getError('failure2')); + }); approvalController.reject('foo2', new Error('failure2')); await rejectionPromise2; approvalController.reject('foo1', new Error('failure1')); await rejectionPromise1; + expect(deleteSpy.callCount).toEqual(numDeletions); }); it('throws on unknown id', () => { - assert.throws( - () => approvalController.reject('foo', new Error('bar')), - getIdNotFoundError('foo'), - 'should reject on unknown id', - ); + expect(() => approvalController.reject('foo', new Error('bar'))).toThrow(getIdNotFoundError('foo')); + expect(deleteSpy.callCount).toEqual(numDeletions); }); }); @@ -344,21 +278,17 @@ describe('approval controller', () => { const promise1 = approvalController.add({ id: 'foo1', origin: 'bar.baz' }); const promise2 = approvalController.add({ id: 'foo2', origin: 'bar.baz', type: 'myType2' }); - const promise3 = assert.rejects( - () => approvalController.add({ id: 'foo3', origin: 'fizz.buzz' }), - getError('failure3'), - 'should reject with expected error', - ); - const promise4 = assert.rejects( - () => approvalController.add({ id: 'foo4', origin: 'bar.baz', type: 'myType4' }), - getError('failure4'), - 'should reject with expected error', - ); + const promise3 = approvalController.add({ id: 'foo3', origin: 'fizz.buzz' }).catch((error) => { + expect(error).toMatchObject(getError('failure3')); + }); + const promise4 = approvalController.add({ id: 'foo4', origin: 'bar.baz', type: 'myType4' }).catch((error) => { + expect(error).toMatchObject(getError('failure4')); + }); approvalController.resolve('foo2', 'success2'); let result = await promise2; - assert.strictEqual(result, 'success2', 'should have resolved expected value'); + expect(result).toEqual('success2'); approvalController.reject('foo4', new Error('failure4')); await promise4; @@ -366,57 +296,40 @@ describe('approval controller', () => { approvalController.reject('foo3', new Error('failure3')); await promise3; - assert.ok(!approvalController.has({ origin: 'fizz.buzz' }), 'should have deleted origin'); - assert.ok(approvalController.has({ origin: 'bar.baz' }), 'should have origin with remaining approval'); + expect(approvalController.has({ origin: 'fizz.buzz' })).toEqual(false); + expect(approvalController.has({ origin: 'bar.baz' })).toEqual(true); approvalController.resolve('foo1', 'success1'); result = await promise1; - assert.strictEqual(result, 'success1', 'should have resolved expected value'); + expect(result).toEqual('success1'); - assert.ok(!approvalController.has({ origin: 'bar.baz' }), 'origins should be removed'); + expect(approvalController.has({ origin: 'bar.baz' })).toEqual(false); }); }); describe('clear', () => { - let approvalController: ApprovalController, numDeletions: number, deleteSpy: any; + let approvalController: ApprovalController; beforeEach(() => { approvalController = new ApprovalController({ ...defaultConfig }); - deleteSpy = sinon.spy(approvalController, '_delete'); - numDeletions = 0; - }); - - afterEach(() => { - assert.strictEqual(deleteSpy.callCount, numDeletions, `should have called '_delete' ${numDeletions} times`); }); it('does nothing if state is already empty', () => { - assert.doesNotThrow(() => approvalController.clear(), 'should not throw'); + expect(() => approvalController.clear()).not.toThrow(); }); it('deletes existing entries', async () => { - numDeletions = 3; - - const clearPromise = Promise.all([ - assert.rejects( - () => approvalController.add({ id: 'foo1', origin: 'bar.baz' }), - 'every approval promise should reject', - ), - assert.rejects( - () => approvalController.add({ id: 'foo2', origin: 'bar.baz', type: 'myType' }), - 'every approval promise should reject', - ), - assert.rejects( - () => approvalController.add({ id: 'foo3', origin: 'fizz.buzz', type: 'myType' }), - 'every approval promise should reject', - ), - ]); + const rejectSpy = sinon.spy(approvalController, 'reject'); + + approvalController.add({ id: 'foo1', origin: 'bar.baz' }).catch((_error) => undefined); + approvalController.add({ id: 'foo2', origin: 'bar.baz', type: 'myType' }).catch((_error) => undefined); + approvalController.add({ id: 'foo3', origin: 'fizz.buzz', type: 'myType' }).catch((_error) => undefined); approvalController.clear(); - await clearPromise; - assert.deepStrictEqual(approvalController.state[STORE_KEY], {}, 'store should be empty'); + expect(approvalController.state[STORE_KEY]).toEqual({}); + expect(rejectSpy.callCount).toEqual(3); }); }); });