Merge branch 'test/push-dividend-payment' of github.com:PolymathNetwo…

…rk/polymath-sdk into test/push-dividend-payment

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"

src/procedures/SetDividendsWallet.ts

@@ -12,25 +12,66 @@ import {
   DividendType,
 } from '../types';
 import { PolymathError } from '../PolymathError';
-import { SecurityToken, Erc20DividendsManager, EthDividendsManager } from '../entities';
+import { Factories } from '../Context';
+import {
+  SecurityToken,
+  Erc20DividendsManager,
+  EthDividendsManager,
+} from '../entities';
 
-export class SetDividendsWallet extends Procedure<SetDividendsWalletProcedureArgs> {
+export const createSetDividendsWalletResolver = (
+  dividendType: DividendType,
+  factories: Factories,
+  symbol: string
+) => async () => {
+  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
+> {
   public type = ProcedureType.SetDividendsWallet;
 
   public async prepareTransactions() {
     const { symbol, dividendType, address } = this.args;
     const { contractWrappers, factories } = this.context;
 
     try {
-      await contractWrappers.tokenFactory.getSecurityTokenInstanceFromTicker(symbol);
+      await contractWrappers.tokenFactory.getSecurityTokenInstanceFromTicker(
+        symbol
+      );
     } catch (err) {
       throw new PolymathError({
         code: ErrorCode.ProcedureValidationError,
         message: `There is no Security Token with symbol ${symbol}`,
       });
     }
 
-    let dividendModule: ERC20DividendCheckpoint | EtherDividendCheckpoint | null = null;
+    let dividendModule:
+      | ERC20DividendCheckpoint
+      | EtherDividendCheckpoint
+      | null = null;
 
     switch (dividendType) {
       case DividendType.Erc20: {
@@ -47,6 +88,9 @@ export class SetDividendsWallet extends Procedure<SetDividendsWalletProcedureArg
         );
         break;
       }
+      default: {
+        break;
+      }
     }
 
     if (!dividendModule) {
@@ -58,26 +102,11 @@ export class SetDividendsWallet extends Procedure<SetDividendsWalletProcedureArg
 
     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,
-              })
-            );
-          }
-        }
-      },
+      resolver: createSetDividendsWalletResolver(
+        dividendType,
+        factories,
+        symbol
+      ),
     })({ wallet: address });
   }
 }

src/procedures/__tests__/AssignSecurityTokenRole.ts

@@ -8,7 +8,12 @@ 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';
 
@@ -24,20 +29,32 @@ describe('AssignSecurityTokenRole', () => {
   let target: AssignSecurityTokenRole;
   let contextMock: MockManager<contextModule.Context>;
   let wrappersMock: MockManager<wrappersModule.PolymathBase>;
-  let tokenFactoryMock: MockManager<tokenFactoryModule.MockedTokenFactoryObject>;
-  let gpmMock: MockManager<contractWrappersModule.GeneralPermissionManager_3_0_0>;
+  let tokenFactoryMock: MockManager<
+    tokenFactoryModule.MockedTokenFactoryObject
+  >;
+  let gpmMock: MockManager<
+    contractWrappersModule.GeneralPermissionManager_3_0_0
+  >;
 
-  let securityTokenFactoryMock: MockManager<securityTokenFactoryModule.SecurityTokenFactory>;
+  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({

src/procedures/__tests__/ControllerTransfer.ts

@@ -26,22 +26,33 @@ describe('ControllerTransfer', () => {
   let target: ControllerTransfer;
   let contextMock: MockManager<contextModule.Context>;
   let wrappersMock: MockManager<wrappersModule.PolymathBase>;
-  let tokenFactoryMock: MockManager<tokenFactoryModule.MockedTokenFactoryObject>;
-  let securityTokenMock: MockManager<contractWrappersModule.SecurityToken_3_0_0>;
+  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.mock('balanceOf', Promise.resolve(params.amount));
     securityTokenMock.mock('controller', Promise.resolve(params.owner));
+
     const ownerPromise = new Promise<string>((resolve, reject) => {
       resolve(params.owner);
     });
-    contextMock.set('currentWallet', new Wallet({ address: () => ownerPromise }));
+    contextMock.set(
+      'currentWallet',
+      new Wallet({ address: () => ownerPromise })
+    );
     tokenFactoryMock.mock(
       'getSecurityTokenInstanceFromTicker',
       securityTokenMock.getMockInstance()

src/procedures/__tests__/CreateCheckpoint.ts

@@ -24,29 +24,44 @@ const params = {
 describe('CreateCheckpoint', () => {
   let target: CreateCheckpoint;
 
-  let securityTokenMock: MockManager<contractWrappersModule.SecurityToken_3_0_0>;
+  let securityTokenMock: MockManager<
+    contractWrappersModule.SecurityToken_3_0_0
+  >;
 
   let contextMock: MockManager<contextModule.Context>;
   let wrappersMock: MockManager<wrappersModule.PolymathBase>;
-  let tokenFactoryMock: MockManager<tokenFactoryModule.MockedTokenFactoryObject>;
+  let tokenFactoryMock: MockManager<
+    tokenFactoryModule.MockedTokenFactoryObject
+  >;
 
   // Mock factories
-  let checkpointFactoryMock: MockManager<checkpointFactoryModule.CheckpointFactory>;
+  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()
     );
     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);
@@ -86,7 +101,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:
@@ -102,7 +119,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: {