From 9eef43e967b94e18c04d4a090042cc93d7f9631f Mon Sep 17 00:00:00 2001 From: Shuffledex Date: Mon, 4 Nov 2019 10:15:57 -0300 Subject: [PATCH 01/10] test: add SetDividendWallet test coverage --- src/procedures/SetDividendsWallet.ts | 25 ++- .../__tests__/SetDividendsWallet.ts | 152 ++++++++++++++++++ 2 files changed, 173 insertions(+), 4 deletions(-) create mode 100644 src/procedures/__tests__/SetDividendsWallet.ts diff --git a/src/procedures/SetDividendsWallet.ts b/src/procedures/SetDividendsWallet.ts index 22716cc..e70843c 100644 --- a/src/procedures/SetDividendsWallet.ts +++ b/src/procedures/SetDividendsWallet.ts @@ -12,9 +12,15 @@ import { DividendType, } from '../types'; import { PolymathError } from '../PolymathError'; -import { SecurityToken, Erc20DividendsManager, EthDividendsManager } from '../entities'; +import { + SecurityToken, + Erc20DividendsManager, + EthDividendsManager, +} from '../entities'; -export class SetDividendsWallet extends Procedure { +export class SetDividendsWallet extends Procedure< + SetDividendsWalletProcedureArgs +> { public type = ProcedureType.SetDividendsWallet; public async prepareTransactions() { @@ -22,7 +28,9 @@ export class SetDividendsWallet extends Procedure { + let target: SetDividendsWallet; + let contextMock: MockManager; + let wrappersMock: MockManager; + let tokenFactoryMock: MockManager< + tokenFactoryModule.MockedTokenFactoryObject + >; + let securityTokenMock: MockManager< + contractWrappersModule.SecurityToken_3_0_0 + >; + let erc20DividendMock: MockManager< + contractWrappersModule.ERC20DividendCheckpointContract_3_0_0 + >; + + beforeEach(() => { + // Mock the context, wrappers, tokenFactory and securityToken to test SetDividendsWallet + contextMock = ImportMock.mockClass(contextModule, 'Context'); + wrappersMock = ImportMock.mockClass(wrappersModule, 'PolymathBase'); + tokenFactoryMock = ImportMock.mockClass( + tokenFactoryModule, + 'MockedTokenFactoryObject' + ); + securityTokenMock = ImportMock.mockClass( + contractWrappersModule, + 'SecurityToken_3_0_0' + ); + + erc20DividendMock = ImportMock.mockClass( + contractWrappersModule, + 'ERC20DividendCheckpointContract_3_0_0' + ); + + tokenFactoryMock.mock( + 'getSecurityTokenInstanceFromTicker', + securityTokenMock.getMockInstance() + ); + + contextMock.set('contractWrappers', wrappersMock.getMockInstance()); + wrappersMock.set('tokenFactory', tokenFactoryMock.getMockInstance()); + }); + + afterEach(() => { + restore(); + }); + + describe('Types', () => { + test('should extend procedure and have SetDividendsWallet type', async () => { + target = new SetDividendsWallet( + { ...params, dividendType: DividendType.Erc20 }, + contextMock.getMockInstance() + ); + expect(target instanceof Procedure).toBe(true); + expect(target.type).toBe(ProcedureType.SetDividendsWallet); + }); + }); + + describe('SetDividendsWallet', () => { + test('should throw if there is no valid dividend type being provided', async () => { + // Instantiate SetDividendsWallet with incorrect dividend type + target = new SetDividendsWallet( + { + symbol: params.symbol, + dividendType: 'wrong' as DividendType, + address: params.address, + }, + contextMock.getMockInstance() + ); + + expect(target.prepareTransactions()).rejects.toThrow( + new PolymathError({ + code: ErrorCode.ProcedureValidationError, + message: "Dividends of the specified type haven't been enabled", + }) + ); + }); + + test('should throw if an Erc20 dividend module is not attached', async () => { + target = new SetDividendsWallet( + { ...params, dividendType: DividendType.Erc20 }, + contextMock.getMockInstance() + ); + + wrappersMock.mock('getAttachedModules', Promise.resolve([])); + + // Real call + expect(target.prepareTransactions()).rejects.toThrowError( + new PolymathError({ + code: ErrorCode.ProcedureValidationError, + message: "Dividends of the specified type haven't been enabled", + }) + ); + }); + + test('should throw if an Eth dividend module is not attached', async () => { + target = new SetDividendsWallet( + { ...params, dividendType: DividendType.Eth }, + contextMock.getMockInstance() + ); + + wrappersMock.mock('getAttachedModules', Promise.resolve([])); + + // Real call + expect(target.prepareTransactions()).rejects.toThrowError( + new PolymathError({ + code: ErrorCode.ProcedureValidationError, + message: "Dividends of the specified type haven't been enabled", + }) + ); + }); + + test('should add transactions to the queue for change wallet with a new Erc20 dividend module', async () => { + target = new SetDividendsWallet( + { ...params, dividendType: DividendType.Erc20 }, + contextMock.getMockInstance() + ); + + wrappersMock.mock( + 'getAttachedModules', + Promise.resolve([erc20DividendMock.getMockInstance()]) + ); + + const addTransactionSpy = spy(target, 'addTransaction'); + + // Real call + await target.prepareTransactions(); + + // Verifications + expect( + addTransactionSpy + .getCall(0) + .calledWith(erc20DividendMock.getMockInstance().changeWallet) + ).toEqual(true); + expect(addTransactionSpy.callCount).toEqual(1); + }); + }); +}); From 873eee88eacf767c1d60b9d45eb76e67bb3ceb1f Mon Sep 17 00:00:00 2001 From: Shuffledex Date: Mon, 4 Nov 2019 12:10:57 -0300 Subject: [PATCH 02/10] fix: check erc20 and eth add transaction separately --- .../__tests__/SetDividendsWallet.ts | 43 ++++++++++++++++--- 1 file changed, 38 insertions(+), 5 deletions(-) diff --git a/src/procedures/__tests__/SetDividendsWallet.ts b/src/procedures/__tests__/SetDividendsWallet.ts index 7603070..1e9f798 100644 --- a/src/procedures/__tests__/SetDividendsWallet.ts +++ b/src/procedures/__tests__/SetDividendsWallet.ts @@ -27,6 +27,9 @@ describe('SetDividendsWallet', () => { let erc20DividendMock: MockManager< contractWrappersModule.ERC20DividendCheckpointContract_3_0_0 >; + let ethDividendMock: MockManager< + contractWrappersModule.EtherDividendCheckpointContract_3_0_0 + >; beforeEach(() => { // Mock the context, wrappers, tokenFactory and securityToken to test SetDividendsWallet @@ -41,11 +44,6 @@ describe('SetDividendsWallet', () => { 'SecurityToken_3_0_0' ); - erc20DividendMock = ImportMock.mockClass( - contractWrappersModule, - 'ERC20DividendCheckpointContract_3_0_0' - ); - tokenFactoryMock.mock( 'getSecurityTokenInstanceFromTicker', securityTokenMock.getMockInstance() @@ -125,6 +123,11 @@ describe('SetDividendsWallet', () => { }); test('should add transactions to the queue for change wallet with a new Erc20 dividend module', async () => { + erc20DividendMock = ImportMock.mockClass( + contractWrappersModule, + 'ERC20DividendCheckpointContract_3_0_0' + ); + target = new SetDividendsWallet( { ...params, dividendType: DividendType.Erc20 }, contextMock.getMockInstance() @@ -148,5 +151,35 @@ describe('SetDividendsWallet', () => { ).toEqual(true); expect(addTransactionSpy.callCount).toEqual(1); }); + + test('should add transactions to the queue for change wallet with a new Eth dividend module', async () => { + ethDividendMock = ImportMock.mockClass( + contractWrappersModule, + 'EtherDividendCheckpointContract_3_0_0' + ); + + target = new SetDividendsWallet( + { ...params, dividendType: DividendType.Eth }, + contextMock.getMockInstance() + ); + + wrappersMock.mock( + 'getAttachedModules', + Promise.resolve([ethDividendMock.getMockInstance()]) + ); + + const addTransactionSpy = spy(target, 'addTransaction'); + + // Real call + await target.prepareTransactions(); + + // Verifications + expect( + addTransactionSpy + .getCall(0) + .calledWith(ethDividendMock.getMockInstance().changeWallet) + ).toEqual(true); + expect(addTransactionSpy.callCount).toEqual(1); + }); }); }); From d3ae9e475387d7d8a98174980e279d569b544053 Mon Sep 17 00:00:00 2001 From: Shuffledex Date: Mon, 4 Nov 2019 12:57:22 -0300 Subject: [PATCH 03/10] fix: add improvements requested by Jere's review --- src/procedures/__tests__/SetDividendsWallet.ts | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/procedures/__tests__/SetDividendsWallet.ts b/src/procedures/__tests__/SetDividendsWallet.ts index 1e9f798..d35432b 100644 --- a/src/procedures/__tests__/SetDividendsWallet.ts +++ b/src/procedures/__tests__/SetDividendsWallet.ts @@ -72,11 +72,7 @@ describe('SetDividendsWallet', () => { test('should throw if there is no valid dividend type being provided', async () => { // Instantiate SetDividendsWallet with incorrect dividend type target = new SetDividendsWallet( - { - symbol: params.symbol, - dividendType: 'wrong' as DividendType, - address: params.address, - }, + { ...params, dividendType: 'wrong' as DividendType }, contextMock.getMockInstance() ); @@ -122,7 +118,7 @@ describe('SetDividendsWallet', () => { ); }); - test('should add transactions to the queue for change wallet with a new Erc20 dividend module', async () => { + test('should add a transaction to the queue to change the dividends wallet of an attached ERC20 dividends module', async () => { erc20DividendMock = ImportMock.mockClass( contractWrappersModule, 'ERC20DividendCheckpointContract_3_0_0' @@ -152,7 +148,7 @@ describe('SetDividendsWallet', () => { expect(addTransactionSpy.callCount).toEqual(1); }); - test('should add transactions to the queue for change wallet with a new Eth dividend module', async () => { + test('should add a transaction to the queue to change the dividends wallet of an attached ETH dividends module', async () => { ethDividendMock = ImportMock.mockClass( contractWrappersModule, 'EtherDividendCheckpointContract_3_0_0' From 5568ee22967b2546dbbbe78d178d65b9275556e2 Mon Sep 17 00:00:00 2001 From: Shuffledex Date: Mon, 4 Nov 2019 15:59:00 -0300 Subject: [PATCH 04/10] fix: fix mockFactories name import --- .../__tests__/AssignSecurityTokenRole.ts | 65 ++++++++++++++----- .../__tests__/ControllerTransfer.ts | 25 +++++-- src/procedures/__tests__/CreateCheckpoint.ts | 38 ++++++++--- .../CreateErc20DividendDistribution.ts | 48 ++++++++++---- .../CreateEtherDividendDistribution.ts | 53 +++++++++++---- .../__tests__/CreateSecurityToken.ts | 47 ++++++++++---- 6 files changed, 207 insertions(+), 69 deletions(-) diff --git a/src/procedures/__tests__/AssignSecurityTokenRole.ts b/src/procedures/__tests__/AssignSecurityTokenRole.ts index 4c7868a..c1c0a0a 100644 --- a/src/procedures/__tests__/AssignSecurityTokenRole.ts +++ b/src/procedures/__tests__/AssignSecurityTokenRole.ts @@ -8,9 +8,14 @@ import * as tokenFactoryModule from '../../testUtils/MockedTokenFactoryObject'; import { AssignSecurityTokenRole } from '../../procedures/AssignSecurityTokenRole'; import { Procedure } from '~/procedures/Procedure'; import { PolymathError } from '~/PolymathError'; -import { ErrorCode, Feature, PolyTransactionTag, SecurityTokenRole } from '~/types'; +import { + ErrorCode, + Feature, + PolyTransactionTag, + SecurityTokenRole, +} from '~/types'; import * as securityTokenFactoryModule from '~/entities/factories/SecurityTokenFactory'; -import { mockFactories } from '~/testUtils/MockFactories'; +import { mockFactories } from '~/testUtils/mockFactories'; const params = { symbol: 'TEST1', @@ -24,20 +29,32 @@ describe('AssignSecurityTokenRole', () => { let target: AssignSecurityTokenRole; let contextMock: MockManager; let wrappersMock: MockManager; - let tokenFactoryMock: MockManager; - let gpmMock: MockManager; + let tokenFactoryMock: MockManager< + tokenFactoryModule.MockedTokenFactoryObject + >; + let gpmMock: MockManager< + contractWrappersModule.GeneralPermissionManager_3_0_0 + >; - let securityTokenFactoryMock: MockManager; + let securityTokenFactoryMock: MockManager< + securityTokenFactoryModule.SecurityTokenFactory + >; beforeEach(() => { // Mock the context, wrappers, and tokenFactory to test AssignSecurityRole contextMock = ImportMock.mockClass(contextModule, 'Context'); wrappersMock = ImportMock.mockClass(wrappersModule, 'PolymathBase'); - tokenFactoryMock = ImportMock.mockClass(tokenFactoryModule, 'MockedTokenFactoryObject'); + tokenFactoryMock = ImportMock.mockClass( + tokenFactoryModule, + 'MockedTokenFactoryObject' + ); contextMock.set('contractWrappers', wrappersMock.getMockInstance()); wrappersMock.set('tokenFactory', tokenFactoryMock.getMockInstance()); - gpmMock = ImportMock.mockClass(contractWrappersModule, 'GeneralPermissionManager_3_0_0'); + gpmMock = ImportMock.mockClass( + contractWrappersModule, + 'GeneralPermissionManager_3_0_0' + ); // Setup factories and security token mock securityTokenFactoryMock = ImportMock.mockClass( @@ -57,7 +74,10 @@ describe('AssignSecurityTokenRole', () => { gpmMock.mock('getAllDelegates', Promise.resolve([params.delegateAddress])); gpmMock.mock('getAllDelegatesWithPerm', Promise.resolve([])); - wrappersMock.mock('getAttachedModules', Promise.resolve([gpmMock.getMockInstance()])); + wrappersMock.mock( + 'getAttachedModules', + Promise.resolve([gpmMock.getMockInstance()]) + ); tokenFactoryMock.mock('getSecurityTokenInstanceFromTicker', {}); wrappersMock.mock('roleToPermission', { @@ -87,9 +107,11 @@ describe('AssignSecurityTokenRole', () => { // Verifications expect( - addTransactionSpy.getCall(0).calledWithExactly(gpmMock.getMockInstance().changePermission, { - tag: PolyTransactionTag.ChangePermission, - }) + addTransactionSpy + .getCall(0) + .calledWithExactly(gpmMock.getMockInstance().changePermission, { + tag: PolyTransactionTag.ChangePermission, + }) ).toEqual(true); expect(addTransactionSpy.callCount).toEqual(1); }); @@ -102,14 +124,18 @@ describe('AssignSecurityTokenRole', () => { // Verifications expect( - addTransactionSpy.getCall(0).calledWithExactly(gpmMock.getMockInstance().addDelegate, { - tag: PolyTransactionTag.AddDelegate, - }) + addTransactionSpy + .getCall(0) + .calledWithExactly(gpmMock.getMockInstance().addDelegate, { + tag: PolyTransactionTag.AddDelegate, + }) ).toEqual(true); expect( - addTransactionSpy.getCall(1).calledWithExactly(gpmMock.getMockInstance().changePermission, { - tag: PolyTransactionTag.ChangePermission, - }) + addTransactionSpy + .getCall(1) + .calledWithExactly(gpmMock.getMockInstance().changePermission, { + tag: PolyTransactionTag.ChangePermission, + }) ).toEqual(true); expect(addTransactionSpy.callCount).toEqual(2); }); @@ -142,7 +168,10 @@ describe('AssignSecurityTokenRole', () => { }); test('should throw if role has already been assigned to delegate', async () => { - gpmMock.mock('getAllDelegatesWithPerm', Promise.resolve([params.delegateAddress])); + gpmMock.mock( + 'getAllDelegatesWithPerm', + Promise.resolve([params.delegateAddress]) + ); // Real call expect(target.prepareTransactions()).rejects.toThrowError( new PolymathError({ diff --git a/src/procedures/__tests__/ControllerTransfer.ts b/src/procedures/__tests__/ControllerTransfer.ts index ed14ca3..65ddbf6 100644 --- a/src/procedures/__tests__/ControllerTransfer.ts +++ b/src/procedures/__tests__/ControllerTransfer.ts @@ -10,7 +10,7 @@ import { ControllerTransfer } from '../../procedures/ControllerTransfer'; import { Procedure } from '~/procedures/Procedure'; import { PolymathError } from '~/PolymathError'; import { ErrorCode, ProcedureType } from '~/types'; -import { mockFactories } from '~/testUtils/MockFactories'; +import { mockFactories } from '~/testUtils/mockFactories'; const params1 = { symbol: 'TEST1', @@ -24,22 +24,35 @@ describe('ControllerTransfer', () => { let target: ControllerTransfer; let contextMock: MockManager; let wrappersMock: MockManager; - let tokenFactoryMock: MockManager; - let securityTokenMock: MockManager; + let tokenFactoryMock: MockManager< + tokenFactoryModule.MockedTokenFactoryObject + >; + let securityTokenMock: MockManager< + contractWrappersModule.SecurityToken_3_0_0 + >; beforeEach(() => { // Mock the context, wrappers, and tokenFactory to test CreateCheckpoint contextMock = ImportMock.mockClass(contextModule, 'Context'); wrappersMock = ImportMock.mockClass(wrappersModule, 'PolymathBase'); - tokenFactoryMock = ImportMock.mockClass(tokenFactoryModule, 'MockedTokenFactoryObject'); + tokenFactoryMock = ImportMock.mockClass( + tokenFactoryModule, + 'MockedTokenFactoryObject' + ); - securityTokenMock = ImportMock.mockClass(contractWrappersModule, 'SecurityToken_3_0_0'); + securityTokenMock = ImportMock.mockClass( + contractWrappersModule, + 'SecurityToken_3_0_0' + ); securityTokenMock.mock('balanceOf', Promise.resolve(params1.amount)); securityTokenMock.mock('controller', Promise.resolve(params1.owner)); const ownerPromise = new Promise((resolve, reject) => { resolve(params1.owner); }); - contextMock.set('currentWallet', new Wallet({ address: () => ownerPromise })); + contextMock.set( + 'currentWallet', + new Wallet({ address: () => ownerPromise }) + ); tokenFactoryMock.mock( 'getSecurityTokenInstanceFromTicker', securityTokenMock.getMockInstance() diff --git a/src/procedures/__tests__/CreateCheckpoint.ts b/src/procedures/__tests__/CreateCheckpoint.ts index cc48c78..c182f9a 100644 --- a/src/procedures/__tests__/CreateCheckpoint.ts +++ b/src/procedures/__tests__/CreateCheckpoint.ts @@ -12,7 +12,7 @@ import * as checkpointFactoryModule from '~/entities/factories/CheckpointFactory import * as contextModule from '../../Context'; import * as wrappersModule from '../../PolymathBase'; import * as tokenFactoryModule from '../../testUtils/MockedTokenFactoryObject'; -import { mockFactories } from '~/testUtils/MockFactories'; +import { mockFactories } from '~/testUtils/mockFactories'; const params = { symbol: 'TEST1', @@ -24,21 +24,33 @@ const params = { describe('CreateCheckpoint', () => { let target: CreateCheckpoint; - let securityTokenMock: MockManager; + let securityTokenMock: MockManager< + contractWrappersModule.SecurityToken_3_0_0 + >; let contextMock: MockManager; let wrappersMock: MockManager; - let tokenFactoryMock: MockManager; + let tokenFactoryMock: MockManager< + tokenFactoryModule.MockedTokenFactoryObject + >; // Mock factories - let checkpointFactoryMock: MockManager; + let checkpointFactoryMock: MockManager< + checkpointFactoryModule.CheckpointFactory + >; beforeEach(() => { // Mock the context, wrappers, and tokenFactory to test CreateCheckpoint contextMock = ImportMock.mockClass(contextModule, 'Context'); wrappersMock = ImportMock.mockClass(wrappersModule, 'PolymathBase'); - tokenFactoryMock = ImportMock.mockClass(tokenFactoryModule, 'MockedTokenFactoryObject'); - securityTokenMock = ImportMock.mockClass(contractWrappersModule, 'SecurityToken_3_0_0'); + tokenFactoryMock = ImportMock.mockClass( + tokenFactoryModule, + 'MockedTokenFactoryObject' + ); + securityTokenMock = ImportMock.mockClass( + contractWrappersModule, + 'SecurityToken_3_0_0' + ); tokenFactoryMock.mock( 'getSecurityTokenInstanceFromTicker', securityTokenMock.getMockInstance() @@ -46,7 +58,10 @@ describe('CreateCheckpoint', () => { contextMock.set('contractWrappers', wrappersMock.getMockInstance()); wrappersMock.set('tokenFactory', tokenFactoryMock.getMockInstance()); - checkpointFactoryMock = ImportMock.mockClass(checkpointFactoryModule, 'CheckpointFactory'); + checkpointFactoryMock = ImportMock.mockClass( + checkpointFactoryModule, + 'CheckpointFactory' + ); const factoryMockSetup = mockFactories(); factoryMockSetup.checkpointFactory = checkpointFactoryMock.getMockInstance(); contextMock.set('factories', factoryMockSetup); @@ -91,7 +106,9 @@ describe('CreateCheckpoint', () => { // Real call const resolver = await target.prepareTransactions(); - expect(resolver.run({} as TransactionReceiptWithDecodedLogs)).rejects.toThrow( + expect( + resolver.run({} as TransactionReceiptWithDecodedLogs) + ).rejects.toThrow( new PolymathError({ code: ErrorCode.UnexpectedEventLogs, message: @@ -107,7 +124,10 @@ describe('CreateCheckpoint', () => { index: () => 1, }, }; - const fetchStub = checkpointFactoryMock.mock('fetch', Promise.resolve(checkpointObject)); + const fetchStub = checkpointFactoryMock.mock( + 'fetch', + Promise.resolve(checkpointObject) + ); ImportMock.mockFunction(utilsModule, 'findEvents', [ { args: { diff --git a/src/procedures/__tests__/CreateErc20DividendDistribution.ts b/src/procedures/__tests__/CreateErc20DividendDistribution.ts index 4581908..4132ed9 100644 --- a/src/procedures/__tests__/CreateErc20DividendDistribution.ts +++ b/src/procedures/__tests__/CreateErc20DividendDistribution.ts @@ -14,7 +14,7 @@ import { ErrorCode, ProcedureType } from '~/types'; import { ApproveErc20 } from '../ApproveErc20'; import * as dividendDistributionSecurityTokenFactoryModule from '~/entities/factories/DividendDistributionFactory'; import * as utilsModule from '~/utils'; -import { mockFactories } from '~/testUtils/MockFactories'; +import { mockFactories } from '~/testUtils/mockFactories'; const params = { symbol: 'TEST1', @@ -31,9 +31,15 @@ describe('CreateErc20DividendDistribution', () => { let contextMock: MockManager; let wrappersMock: MockManager; let approvalMock: MockManager; - let tokenFactoryMock: MockManager; - let gpmMock: MockManager; - let erc20DividendsMock: MockManager; + let tokenFactoryMock: MockManager< + tokenFactoryModule.MockedTokenFactoryObject + >; + let gpmMock: MockManager< + contractWrappersModule.GeneralPermissionManager_3_0_0 + >; + let erc20DividendsMock: MockManager< + contractWrappersModule.ERC20DividendCheckpoint_3_0_0 + >; let dividendDistributionFactoryMock: MockManager< dividendDistributionSecurityTokenFactoryModule.DividendDistributionFactory @@ -43,7 +49,10 @@ describe('CreateErc20DividendDistribution', () => { // Mock the context, wrappers, and tokenFactory to test CreateErc20DividendDistribution contextMock = ImportMock.mockClass(contextModule, 'Context'); wrappersMock = ImportMock.mockClass(wrappersModule, 'PolymathBase'); - tokenFactoryMock = ImportMock.mockClass(tokenFactoryModule, 'MockedTokenFactoryObject'); + tokenFactoryMock = ImportMock.mockClass( + tokenFactoryModule, + 'MockedTokenFactoryObject' + ); // Import mock out of ApproveErc20 approvalMock = ImportMock.mockClass(approveModule, 'ApproveErc20'); @@ -54,7 +63,10 @@ describe('CreateErc20DividendDistribution', () => { contextMock.set('contractWrappers', wrappersMock.getMockInstance()); wrappersMock.set('tokenFactory', tokenFactoryMock.getMockInstance()); - gpmMock = ImportMock.mockClass(contractWrappersModule, 'GeneralPermissionManager_3_0_0'); + gpmMock = ImportMock.mockClass( + contractWrappersModule, + 'GeneralPermissionManager_3_0_0' + ); erc20DividendsMock = ImportMock.mockClass( contractWrappersModule, 'ERC20DividendCheckpoint_3_0_0' @@ -76,7 +88,10 @@ describe('CreateErc20DividendDistribution', () => { contextMock.set('factories', factoryMockSetup); // Instantiate CreateErc20DividendDistribution - target = new CreateErc20DividendDistribution(params, contextMock.getMockInstance()); + target = new CreateErc20DividendDistribution( + params, + contextMock.getMockInstance() + ); }); afterEach(() => { @@ -103,7 +118,8 @@ describe('CreateErc20DividendDistribution', () => { addTransactionSpy .getCall(0) .calledWith( - erc20DividendsMock.getMockInstance().createDividendWithCheckpointAndExclusions + erc20DividendsMock.getMockInstance() + .createDividendWithCheckpointAndExclusions ) ).toEqual(true); expect(addTransactionSpy.callCount).toEqual(1); @@ -134,11 +150,14 @@ describe('CreateErc20DividendDistribution', () => { addTransactionSpy .getCall(0) .calledWith( - erc20DividendsMock.getMockInstance().createDividendWithCheckpointAndExclusions + erc20DividendsMock.getMockInstance() + .createDividendWithCheckpointAndExclusions ) ).toEqual(true); expect( - addTransactionSpy.getCall(1).calledWith(erc20DividendsMock.getMockInstance().setWithholding) + addTransactionSpy + .getCall(1) + .calledWith(erc20DividendsMock.getMockInstance().setWithholding) ).toEqual(true); expect(addTransactionSpy.callCount).toEqual(2); expect(addProcedureSpy.callCount).toEqual(1); @@ -166,7 +185,9 @@ describe('CreateErc20DividendDistribution', () => { // Real call const resolver = await target.prepareTransactions(); - expect(resolver.run({} as TransactionReceiptWithDecodedLogs)).rejects.toThrow( + expect( + resolver.run({} as TransactionReceiptWithDecodedLogs) + ).rejects.toThrow( new PolymathError({ code: ErrorCode.UnexpectedEventLogs, message: @@ -182,7 +203,10 @@ describe('CreateErc20DividendDistribution', () => { index: () => Promise.resolve(1), }, }; - const fetchStub = dividendDistributionFactoryMock.mock('fetch', dividendObject); + const fetchStub = dividendDistributionFactoryMock.mock( + 'fetch', + dividendObject + ); ImportMock.mockFunction(utilsModule, 'findEvents', [ { args: { diff --git a/src/procedures/__tests__/CreateEtherDividendDistribution.ts b/src/procedures/__tests__/CreateEtherDividendDistribution.ts index 6227b9b..427d869 100644 --- a/src/procedures/__tests__/CreateEtherDividendDistribution.ts +++ b/src/procedures/__tests__/CreateEtherDividendDistribution.ts @@ -12,7 +12,7 @@ import * as utilsModule from '~/utils'; import * as contextModule from '../../Context'; import * as wrappersModule from '../../PolymathBase'; import * as tokenFactoryModule from '../../testUtils/MockedTokenFactoryObject'; -import { mockFactories } from '~/testUtils/MockFactories'; +import { mockFactories } from '~/testUtils/mockFactories'; const params = { symbol: 'TEST1', @@ -27,9 +27,15 @@ describe('CreateEtherDividendDistribution', () => { let target: CreateEtherDividendDistribution; let contextMock: MockManager; let wrappersMock: MockManager; - let tokenFactoryMock: MockManager; - let gpmMock: MockManager; - let etherDividendsMock: MockManager; + let tokenFactoryMock: MockManager< + tokenFactoryModule.MockedTokenFactoryObject + >; + let gpmMock: MockManager< + contractWrappersModule.GeneralPermissionManager_3_0_0 + >; + let etherDividendsMock: MockManager< + contractWrappersModule.EtherDividendCheckpoint_3_0_0 + >; let dividendDistributionFactoryMock: MockManager< dividendDistributionSecurityTokenFactoryModule.DividendDistributionFactory @@ -39,16 +45,25 @@ describe('CreateEtherDividendDistribution', () => { // Mock the context, wrappers, and tokenFactory to test CreateEtherDividendDistribution contextMock = ImportMock.mockClass(contextModule, 'Context'); wrappersMock = ImportMock.mockClass(wrappersModule, 'PolymathBase'); - tokenFactoryMock = ImportMock.mockClass(tokenFactoryModule, 'MockedTokenFactoryObject'); + tokenFactoryMock = ImportMock.mockClass( + tokenFactoryModule, + 'MockedTokenFactoryObject' + ); contextMock.set('contractWrappers', wrappersMock.getMockInstance()); wrappersMock.set('tokenFactory', tokenFactoryMock.getMockInstance()); - gpmMock = ImportMock.mockClass(contractWrappersModule, 'GeneralPermissionManager_3_0_0'); + gpmMock = ImportMock.mockClass( + contractWrappersModule, + 'GeneralPermissionManager_3_0_0' + ); etherDividendsMock = ImportMock.mockClass( contractWrappersModule, 'EtherDividendCheckpoint_3_0_0' ); - wrappersMock.mock('getAttachedModules', Promise.resolve([etherDividendsMock])); + wrappersMock.mock( + 'getAttachedModules', + Promise.resolve([etherDividendsMock]) + ); tokenFactoryMock.mock('getSecurityTokenInstanceFromTicker', {}); dividendDistributionFactoryMock = ImportMock.mockClass( @@ -60,7 +75,10 @@ describe('CreateEtherDividendDistribution', () => { contextMock.set('factories', factoryMockSetup); // Instantiate CreateEtherDividendDistribution - target = new CreateEtherDividendDistribution(params, contextMock.getMockInstance()); + target = new CreateEtherDividendDistribution( + params, + contextMock.getMockInstance() + ); }); afterEach(() => { restore(); @@ -84,7 +102,8 @@ describe('CreateEtherDividendDistribution', () => { addTransactionSpy .getCall(0) .calledWith( - etherDividendsMock.getMockInstance().createDividendWithCheckpointAndExclusions + etherDividendsMock.getMockInstance() + .createDividendWithCheckpointAndExclusions ) ).toEqual(true); expect(addTransactionSpy.callCount).toEqual(1); @@ -113,11 +132,14 @@ describe('CreateEtherDividendDistribution', () => { addTransactionSpy .getCall(0) .calledWith( - etherDividendsMock.getMockInstance().createDividendWithCheckpointAndExclusions + etherDividendsMock.getMockInstance() + .createDividendWithCheckpointAndExclusions ) ).toEqual(true); expect( - addTransactionSpy.getCall(1).calledWith(etherDividendsMock.getMockInstance().setWithholding) + addTransactionSpy + .getCall(1) + .calledWith(etherDividendsMock.getMockInstance().setWithholding) ).toEqual(true); expect(addTransactionSpy.callCount).toEqual(2); }); @@ -128,7 +150,9 @@ describe('CreateEtherDividendDistribution', () => { // Real call const resolver = await target.prepareTransactions(); - expect(resolver.run({} as TransactionReceiptWithDecodedLogs)).rejects.toThrow( + expect( + resolver.run({} as TransactionReceiptWithDecodedLogs) + ).rejects.toThrow( new PolymathError({ code: ErrorCode.UnexpectedEventLogs, message: @@ -144,7 +168,10 @@ describe('CreateEtherDividendDistribution', () => { index: () => 1, }, }; - const fetchStub = dividendDistributionFactoryMock.mock('fetch', dividendObject); + const fetchStub = dividendDistributionFactoryMock.mock( + 'fetch', + dividendObject + ); ImportMock.mockFunction(utilsModule, 'findEvents', [ { args: { diff --git a/src/procedures/__tests__/CreateSecurityToken.ts b/src/procedures/__tests__/CreateSecurityToken.ts index a8621a8..0b2a4a3 100644 --- a/src/procedures/__tests__/CreateSecurityToken.ts +++ b/src/procedures/__tests__/CreateSecurityToken.ts @@ -14,7 +14,7 @@ import { ApproveErc20 } from '../ApproveErc20'; import * as securityTokenFactoryModule from '~/entities/factories/SecurityTokenFactory'; import { TransactionReceiptWithDecodedLogs } from 'ethereum-protocol'; import * as utilsModule from '~/utils'; -import { mockFactories } from '~/testUtils/MockFactories'; +import { mockFactories } from '~/testUtils/mockFactories'; const params = { symbol: 'TEST1', @@ -31,8 +31,12 @@ describe('CreateSecurityToken', () => { let wrappersMock: MockManager; let approvalMock: MockManager; - let securityTokenRegistryMock: MockManager; - let securityTokenFactoryMock: MockManager; + let securityTokenRegistryMock: MockManager< + contractWrappersModule.SecurityTokenRegistry + >; + let securityTokenFactoryMock: MockManager< + securityTokenFactoryModule.SecurityTokenFactory + >; beforeEach(() => { // Mock the context, wrappers, and tokenFactory to test @@ -51,7 +55,10 @@ describe('CreateSecurityToken', () => { ); securityTokenRegistryMock.mock('tickerAvailable', Promise.resolve(false)); - securityTokenRegistryMock.mock('isTickerRegisteredByCurrentIssuer', Promise.resolve(true)); + securityTokenRegistryMock.mock( + 'isTickerRegisteredByCurrentIssuer', + Promise.resolve(true) + ); securityTokenRegistryMock.mock('isTokenLaunched', Promise.resolve(false)); securityTokenRegistryMock.mock( 'getFees', @@ -60,12 +67,18 @@ describe('CreateSecurityToken', () => { securityTokenRegistryMock.mock('address', Promise.resolve(params.address)); contextMock.set('contractWrappers', wrappersMock.getMockInstance()); - wrappersMock.set('securityTokenRegistry', securityTokenRegistryMock.getMockInstance()); + wrappersMock.set( + 'securityTokenRegistry', + securityTokenRegistryMock.getMockInstance() + ); const ownerPromise = new Promise((resolve, reject) => { resolve(params.owner); }); - contextMock.set('currentWallet', new Wallet({ address: () => ownerPromise })); + contextMock.set( + 'currentWallet', + new Wallet({ address: () => ownerPromise }) + ); wrappersMock.mock('isTestnet', Promise.resolve(false)); securityTokenFactoryMock = ImportMock.mockClass( @@ -111,7 +124,9 @@ describe('CreateSecurityToken', () => { // Real call const resolver = await target.prepareTransactions(); - expect(resolver.run({} as TransactionReceiptWithDecodedLogs)).rejects.toThrow( + expect( + resolver.run({} as TransactionReceiptWithDecodedLogs) + ).rejects.toThrow( new PolymathError({ code: ErrorCode.UnexpectedEventLogs, message: @@ -128,7 +143,10 @@ describe('CreateSecurityToken', () => { address: () => params.address, }, }; - const createStub = securityTokenFactoryMock.mock('create', creationObject); + const createStub = securityTokenFactoryMock.mock( + 'create', + creationObject + ); ImportMock.mockFunction(utilsModule, 'findEvents', [ { args: { @@ -148,7 +166,10 @@ describe('CreateSecurityToken', () => { }); test('should throw error if token has been reserved by other user', async () => { - securityTokenRegistryMock.mock('isTickerRegisteredByCurrentIssuer', Promise.resolve(false)); + securityTokenRegistryMock.mock( + 'isTickerRegisteredByCurrentIssuer', + Promise.resolve(false) + ); // Real call expect(target.prepareTransactions()).rejects.toThrowError( new PolymathError({ @@ -166,7 +187,9 @@ describe('CreateSecurityToken', () => { expect(target.prepareTransactions()).rejects.toThrowError( new PolymathError({ code: ErrorCode.ProcedureValidationError, - message: `The security token symbol ${params.symbol} has already been launched."`, + message: `The security token symbol ${ + params.symbol + } has already been launched."`, }) ); }); @@ -181,7 +204,9 @@ describe('CreateSecurityToken', () => { expect( addTransactionSpy .getCall(0) - .calledWith(securityTokenRegistryMock.getMockInstance().generateNewSecurityToken) + .calledWith( + securityTokenRegistryMock.getMockInstance().generateNewSecurityToken + ) ).toEqual(true); expect(addTransactionSpy.callCount).toEqual(1); From a8e8fd92a2b956c2aacf96e85419f70038112995 Mon Sep 17 00:00:00 2001 From: Shuffledex Date: Tue, 5 Nov 2019 10:02:58 -0300 Subject: [PATCH 05/10] fix: export resolver method --- src/procedures/SetDividendsWallet.ts | 54 ++++++++++++++++------------ 1 file changed, 31 insertions(+), 23 deletions(-) diff --git a/src/procedures/SetDividendsWallet.ts b/src/procedures/SetDividendsWallet.ts index e70843c..00dc95e 100644 --- a/src/procedures/SetDividendsWallet.ts +++ b/src/procedures/SetDividendsWallet.ts @@ -12,12 +12,42 @@ import { DividendType, } from '../types'; import { PolymathError } from '../PolymathError'; +import { Factories } from '../Context'; import { SecurityToken, Erc20DividendsManager, EthDividendsManager, } from '../entities'; +export const createResolver = async ( + dividendType: DividendType, + factories: Factories, + symbol: string +) => { + let refresh; + // eslint-disable-next-line default-case + switch (dividendType) { + case DividendType.Erc20: { + refresh = factories.erc20DividendsManagerFactory.refresh( + Erc20DividendsManager.generateId({ + securityTokenId: SecurityToken.generateId({ symbol }), + dividendType, + }) + ); + break; + } + case DividendType.Eth: { + refresh = factories.ethDividendsManagerFactory.refresh( + EthDividendsManager.generateId({ + securityTokenId: SecurityToken.generateId({ symbol }), + dividendType, + }) + ); + } + } + return refresh; +}; + export class SetDividendsWallet extends Procedure< SetDividendsWalletProcedureArgs > { @@ -72,29 +102,7 @@ export class SetDividendsWallet extends Procedure< await this.addTransaction(dividendModule.changeWallet, { tag: PolyTransactionTag.SetDividendsWallet, - resolver: async () => { - switch (dividendType) { - case DividendType.Erc20: { - return factories.erc20DividendsManagerFactory.refresh( - Erc20DividendsManager.generateId({ - securityTokenId: SecurityToken.generateId({ symbol }), - dividendType, - }) - ); - } - case DividendType.Eth: { - return factories.ethDividendsManagerFactory.refresh( - EthDividendsManager.generateId({ - securityTokenId: SecurityToken.generateId({ symbol }), - dividendType, - }) - ); - } - default: { - break; - } - } - }, + resolver: () => createResolver(dividendType, factories, symbol), })({ wallet: address }); } } From 9bd6e03bb4912b88b23c9d5dfd808c36f63c2dd6 Mon Sep 17 00:00:00 2001 From: Shuffledex Date: Tue, 5 Nov 2019 15:55:00 -0300 Subject: [PATCH 06/10] fix: improve createResolver return method --- src/procedures/SetDividendsWallet.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/procedures/SetDividendsWallet.ts b/src/procedures/SetDividendsWallet.ts index 00dc95e..a0caf43 100644 --- a/src/procedures/SetDividendsWallet.ts +++ b/src/procedures/SetDividendsWallet.ts @@ -19,11 +19,11 @@ import { EthDividendsManager, } from '../entities'; -export const createResolver = async ( +export const createResolver = ( dividendType: DividendType, factories: Factories, symbol: string -) => { +) => async () => { let refresh; // eslint-disable-next-line default-case switch (dividendType) { @@ -102,7 +102,7 @@ export class SetDividendsWallet extends Procedure< await this.addTransaction(dividendModule.changeWallet, { tag: PolyTransactionTag.SetDividendsWallet, - resolver: () => createResolver(dividendType, factories, symbol), + resolver: createResolver(dividendType, factories, symbol), })({ wallet: address }); } } From e7244c25bcc356a6aa874832eae5793bae0f569e Mon Sep 17 00:00:00 2001 From: Shuffledex Date: Wed, 6 Nov 2019 09:46:38 -0300 Subject: [PATCH 07/10] fix: should throw if there is no valid security token being provided --- .../__tests__/SetDividendsWallet.ts | 24 ++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/src/procedures/__tests__/SetDividendsWallet.ts b/src/procedures/__tests__/SetDividendsWallet.ts index d35432b..268dda9 100644 --- a/src/procedures/__tests__/SetDividendsWallet.ts +++ b/src/procedures/__tests__/SetDividendsWallet.ts @@ -1,5 +1,5 @@ import { ImportMock, MockManager } from 'ts-mock-imports'; -import { spy, restore } from 'sinon'; +import { stub, spy, restore } from 'sinon'; import * as contractWrappersModule from '@polymathnetwork/contract-wrappers'; import * as contextModule from '../../Context'; import * as wrappersModule from '../../PolymathBase'; @@ -69,6 +69,28 @@ describe('SetDividendsWallet', () => { }); describe('SetDividendsWallet', () => { + test('should throw if there is no valid security token being provided', async () => { + // Instantiate SetDividendsWallet with incorrect security symbol + target = new SetDividendsWallet( + { ...params, dividendType: DividendType.Erc20 }, + contextMock.getMockInstance() + ); + + tokenFactoryMock.set( + 'getSecurityTokenInstanceFromTicker', + stub() + .withArgs({ address: params.symbol }) + .throws() + ); + + expect(target.prepareTransactions()).rejects.toThrow( + new PolymathError({ + code: ErrorCode.ProcedureValidationError, + message: `There is no Security Token with symbol ${params.symbol}`, + }) + ); + }); + test('should throw if there is no valid dividend type being provided', async () => { // Instantiate SetDividendsWallet with incorrect dividend type target = new SetDividendsWallet( From dc555ffa595c658f63df50225bfb5a565c0601a9 Mon Sep 17 00:00:00 2001 From: Shuffledex Date: Thu, 7 Nov 2019 13:19:36 -0300 Subject: [PATCH 08/10] fix: add tests to cover 100% --- src/procedures/SetDividendsWallet.ts | 8 +- .../__tests__/SetDividendsWallet.ts | 74 +++++++++++++++++++ 2 files changed, 80 insertions(+), 2 deletions(-) diff --git a/src/procedures/SetDividendsWallet.ts b/src/procedures/SetDividendsWallet.ts index a0caf43..d9d5bbf 100644 --- a/src/procedures/SetDividendsWallet.ts +++ b/src/procedures/SetDividendsWallet.ts @@ -19,7 +19,7 @@ import { EthDividendsManager, } from '../entities'; -export const createResolver = ( +export const createSetDividendWalletResolver = ( dividendType: DividendType, factories: Factories, symbol: string @@ -102,7 +102,11 @@ export class SetDividendsWallet extends Procedure< await this.addTransaction(dividendModule.changeWallet, { tag: PolyTransactionTag.SetDividendsWallet, - resolver: createResolver(dividendType, factories, symbol), + resolver: createSetDividendWalletResolver( + dividendType, + factories, + symbol + ), })({ wallet: address }); } } diff --git a/src/procedures/__tests__/SetDividendsWallet.ts b/src/procedures/__tests__/SetDividendsWallet.ts index 268dda9..1486eea 100644 --- a/src/procedures/__tests__/SetDividendsWallet.ts +++ b/src/procedures/__tests__/SetDividendsWallet.ts @@ -2,12 +2,22 @@ import { ImportMock, MockManager } from 'ts-mock-imports'; import { stub, spy, restore } from 'sinon'; import * as contractWrappersModule from '@polymathnetwork/contract-wrappers'; import * as contextModule from '../../Context'; +import { Factories } from '../../Context'; import * as wrappersModule from '../../PolymathBase'; import * as tokenFactoryModule from '../../testUtils/MockedTokenFactoryObject'; import { SetDividendsWallet } from '../../procedures/SetDividendsWallet'; +import * as setDividendsWalletModule from '../../procedures/SetDividendsWallet'; import { Procedure } from '~/procedures/Procedure'; import { ProcedureType, DividendType, ErrorCode } from '~/types'; import { PolymathError } from '~/PolymathError'; +import { mockFactories } from '~/testUtils/mockFactories'; +import * as erc20FactoryModule from '~/entities/factories/Erc20DividendsManagerFactory'; +import * as ethFactoryModule from '~/entities/factories/EthDividendsManagerFactory'; +import { + SecurityToken, + Erc20DividendsManager, + EthDividendsManager, +} from '~/entities'; const params = { symbol: 'TEST1', @@ -30,6 +40,11 @@ describe('SetDividendsWallet', () => { let ethDividendMock: MockManager< contractWrappersModule.EtherDividendCheckpointContract_3_0_0 >; + let erc20FactoryMock: MockManager< + erc20FactoryModule.Erc20DividendsManagerFactory + >; + let ethFactoryMock: MockManager; + let factoriesMockedSetup: Factories; beforeEach(() => { // Mock the context, wrappers, tokenFactory and securityToken to test SetDividendsWallet @@ -51,6 +66,19 @@ describe('SetDividendsWallet', () => { contextMock.set('contractWrappers', wrappersMock.getMockInstance()); wrappersMock.set('tokenFactory', tokenFactoryMock.getMockInstance()); + + erc20FactoryMock = ImportMock.mockClass( + erc20FactoryModule, + 'Erc20DividendsManagerFactory' + ); + ethFactoryMock = ImportMock.mockClass( + ethFactoryModule, + 'EthDividendsManagerFactory' + ); + factoriesMockedSetup = mockFactories(); + factoriesMockedSetup.erc20DividendsManagerFactory = erc20FactoryMock.getMockInstance(); + factoriesMockedSetup.ethDividendsManagerFactory = ethFactoryMock.getMockInstance(); + contextMock.set('factories', factoriesMockedSetup); }); afterEach(() => { @@ -199,5 +227,51 @@ describe('SetDividendsWallet', () => { ).toEqual(true); expect(addTransactionSpy.callCount).toEqual(1); }); + + test('should successfully refresh ERC20 dividends factory', async () => { + const refreshStub = erc20FactoryMock.mock( + 'refresh', + Promise.resolve(undefined) + ); + const resolverValue = setDividendsWalletModule.createSetDividendWalletResolver( + DividendType.Erc20, + factoriesMockedSetup, + params.symbol + )(); + expect( + refreshStub.getCall(0).calledWithExactly( + Erc20DividendsManager.generateId({ + securityTokenId: SecurityToken.generateId({ + symbol: params.symbol, + }), + dividendType: DividendType.Erc20, + }) + ) + ).toEqual(true); + expect(await resolverValue).toEqual(undefined); + expect(refreshStub.callCount).toEqual(1); + }); + }); + + test('should successfully refresh Eth dividends factory', async () => { + const refreshStub = ethFactoryMock.mock( + 'refresh', + Promise.resolve(undefined) + ); + const resolverValue = setDividendsWalletModule.createSetDividendWalletResolver( + DividendType.Eth, + factoriesMockedSetup, + params.symbol + )(); + expect( + refreshStub.getCall(0).calledWithExactly( + EthDividendsManager.generateId({ + securityTokenId: SecurityToken.generateId({ symbol: params.symbol }), + dividendType: DividendType.Eth, + }) + ) + ).toEqual(true); + expect(await resolverValue).toEqual(undefined); + expect(refreshStub.callCount).toEqual(1); }); }); From f794f9930eeb643d3cc3383501a67f5a3de5d919 Mon Sep 17 00:00:00 2001 From: Shuffledex Date: Fri, 8 Nov 2019 14:59:36 -0300 Subject: [PATCH 09/10] fix: add feedback fixes requested by Jere --- src/procedures/SetDividendsWallet.ts | 4 +-- .../__tests__/SetDividendsWallet.ts | 26 ++++++++++--------- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/src/procedures/SetDividendsWallet.ts b/src/procedures/SetDividendsWallet.ts index d9d5bbf..88b4122 100644 --- a/src/procedures/SetDividendsWallet.ts +++ b/src/procedures/SetDividendsWallet.ts @@ -19,7 +19,7 @@ import { EthDividendsManager, } from '../entities'; -export const createSetDividendWalletResolver = ( +export const createSetDividendsWalletResolver = ( dividendType: DividendType, factories: Factories, symbol: string @@ -102,7 +102,7 @@ export class SetDividendsWallet extends Procedure< await this.addTransaction(dividendModule.changeWallet, { tag: PolyTransactionTag.SetDividendsWallet, - resolver: createSetDividendWalletResolver( + resolver: createSetDividendsWalletResolver( dividendType, factories, symbol diff --git a/src/procedures/__tests__/SetDividendsWallet.ts b/src/procedures/__tests__/SetDividendsWallet.ts index 1486eea..775b1a7 100644 --- a/src/procedures/__tests__/SetDividendsWallet.ts +++ b/src/procedures/__tests__/SetDividendsWallet.ts @@ -104,14 +104,12 @@ describe('SetDividendsWallet', () => { contextMock.getMockInstance() ); - tokenFactoryMock.set( - 'getSecurityTokenInstanceFromTicker', - stub() - .withArgs({ address: params.symbol }) - .throws() - ); + tokenFactoryMock + .mock('getSecurityTokenInstanceFromTicker') + .withArgs(params.symbol) + .throws(); - expect(target.prepareTransactions()).rejects.toThrow( + await expect(target.prepareTransactions()).rejects.toThrow( new PolymathError({ code: ErrorCode.ProcedureValidationError, message: `There is no Security Token with symbol ${params.symbol}`, @@ -126,7 +124,7 @@ describe('SetDividendsWallet', () => { contextMock.getMockInstance() ); - expect(target.prepareTransactions()).rejects.toThrow( + await expect(target.prepareTransactions()).rejects.toThrow( new PolymathError({ code: ErrorCode.ProcedureValidationError, message: "Dividends of the specified type haven't been enabled", @@ -143,7 +141,7 @@ describe('SetDividendsWallet', () => { wrappersMock.mock('getAttachedModules', Promise.resolve([])); // Real call - expect(target.prepareTransactions()).rejects.toThrowError( + await expect(target.prepareTransactions()).rejects.toThrowError( new PolymathError({ code: ErrorCode.ProcedureValidationError, message: "Dividends of the specified type haven't been enabled", @@ -160,7 +158,7 @@ describe('SetDividendsWallet', () => { wrappersMock.mock('getAttachedModules', Promise.resolve([])); // Real call - expect(target.prepareTransactions()).rejects.toThrowError( + await expect(target.prepareTransactions()).rejects.toThrowError( new PolymathError({ code: ErrorCode.ProcedureValidationError, message: "Dividends of the specified type haven't been enabled", @@ -233,11 +231,13 @@ describe('SetDividendsWallet', () => { 'refresh', Promise.resolve(undefined) ); - const resolverValue = setDividendsWalletModule.createSetDividendWalletResolver( + + const resolverValue = await setDividendsWalletModule.createSetDividendsWalletResolver( DividendType.Erc20, factoriesMockedSetup, params.symbol )(); + expect( refreshStub.getCall(0).calledWithExactly( Erc20DividendsManager.generateId({ @@ -258,11 +258,13 @@ describe('SetDividendsWallet', () => { 'refresh', Promise.resolve(undefined) ); - const resolverValue = setDividendsWalletModule.createSetDividendWalletResolver( + + const resolverValue = await setDividendsWalletModule.createSetDividendsWalletResolver( DividendType.Eth, factoriesMockedSetup, params.symbol )(); + expect( refreshStub.getCall(0).calledWithExactly( EthDividendsManager.generateId({ From 7194afe8cb974b58d575ec2309be354f6a37aaf8 Mon Sep 17 00:00:00 2001 From: semantic-release-bot Date: Fri, 15 Nov 2019 05:40:41 +0000 Subject: [PATCH 10/10] chore(release): 2.0.1-beta.51 [skip ci] ## [2.0.1-beta.51](https://github.com/PolymathNetwork/polymath-sdk/compare/v2.0.1-beta.50@beta...v2.0.1-beta.51@beta) (2019-11-15) ### Bug Fixes * add feedback fixes requested by Jere ([f794f99](https://github.com/PolymathNetwork/polymath-sdk/commit/f794f99)) * add improvements requested by Jere's review ([d3ae9e4](https://github.com/PolymathNetwork/polymath-sdk/commit/d3ae9e4)) * add tests to cover 100% ([dc555ff](https://github.com/PolymathNetwork/polymath-sdk/commit/dc555ff)) * check erc20 and eth add transaction separately ([873eee8](https://github.com/PolymathNetwork/polymath-sdk/commit/873eee8)) * export resolver method ([a8e8fd9](https://github.com/PolymathNetwork/polymath-sdk/commit/a8e8fd9)) * fix mockFactories name import ([5568ee2](https://github.com/PolymathNetwork/polymath-sdk/commit/5568ee2)) * improve createResolver return method ([9bd6e03](https://github.com/PolymathNetwork/polymath-sdk/commit/9bd6e03)) * should throw if there is no valid security token being provided ([e7244c2](https://github.com/PolymathNetwork/polymath-sdk/commit/e7244c2)) --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index ee0758b..c9bbd6e 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@polymathnetwork/sdk", - "version": "2.0.1-beta.50", + "version": "2.0.1-beta.51", "description": "A Javascript SDK for interacting with the Polymath network for the browser and Node.js", "bugs": { "url": "https://github.com/PolymathNetwork/polymath-sdk/issues"