Merge branch 'beta' into test/reclaim-funds-procedure

src/procedures/__tests__/AssignSecurityTokenRole.ts

@@ -8,7 +8,13 @@ import * as tokenFactoryModule from '../../testUtils/MockedTokenFactoryModule';
 import { AssignSecurityTokenRole } from '../../procedures/AssignSecurityTokenRole';
 import { Procedure } from '../Procedure';
 import { PolymathError } from '../../PolymathError';
-import { ErrorCode, Feature, PolyTransactionTag, SecurityTokenRole } from '../../types';
+import {
+  ErrorCode,
+  Feature,
+  PolyTransactionTag,
+  ProcedureType,
+  SecurityTokenRole,
+} from '../../types';
 import * as securityTokenFactoryModule from '../../entities/factories/SecurityTokenFactory';
 import { mockFactories } from '../../testUtils/mockFactories';
 
@@ -79,7 +85,7 @@ describe('AssignSecurityTokenRole', () => {
   describe('Types', () => {
     test('should extend procedure and have AssignSecurityTokenRole type', async () => {
       expect(target instanceof Procedure).toBe(true);
-      expect(target.type).toBe('AssignSecurityTokenRole');
+      expect(target.type).toBe(ProcedureType.AssignSecurityTokenRole);
     });
   });
 

src/procedures/__tests__/AssignStoRole.ts

@@ -7,7 +7,7 @@ import * as tokenFactoryModule from '../../testUtils/MockedTokenFactoryModule';
 import { AssignStoRole } from '../../procedures/AssignStoRole';
 import { Procedure } from '../Procedure';
 import { PolymathError } from '../../PolymathError';
-import { ErrorCode, PolyTransactionTag, StoRole } from '../../types';
+import { ErrorCode, PolyTransactionTag, ProcedureType, StoRole } from '../../types';
 
 const params = {
   symbol: 'TEST1',
@@ -46,7 +46,7 @@ describe('AssignStoRole', () => {
   describe('Types', () => {
     test('should extend procedure and have AssignStoRole type', async () => {
       expect(target instanceof Procedure).toBe(true);
-      expect(target.type).toBe('AssignStoRole');
+      expect(target.type).toBe(ProcedureType.AssignStoRole);
     });
   });
 

src/procedures/__tests__/EnableDividendManagers.ts

@@ -8,7 +8,7 @@ import * as tokenFactoryModule from '../../testUtils/MockedTokenFactoryModule';
 import { EnableDividendManagers } from '../../procedures/EnableDividendManagers';
 import { Procedure } from '../Procedure';
 import { PolymathError } from '../../PolymathError';
-import { ErrorCode, PolyTransactionTag } from '../../types';
+import { ErrorCode, PolyTransactionTag, ProcedureType } from '../../types';
 
 const params = {
   symbol: 'TEST1',
@@ -57,7 +57,7 @@ describe('EnableDividendManagers', () => {
   describe('Types', () => {
     test('should extend procedure and have EnableDividendManagers type', async () => {
       expect(target instanceof Procedure).toBe(true);
-      expect(target.type).toBe('EnableDividendManagers');
+      expect(target.type).toBe(ProcedureType.EnableDividendManagers);
     });
   });
 

src/procedures/__tests__/EnableGeneralPermissionManager.ts

@@ -8,7 +8,7 @@ import * as tokenFactoryModule from '../../testUtils/MockedTokenFactoryModule';
 import { EnableGeneralPermissionManager } from '../../procedures/EnableGeneralPermissionManager';
 import { Procedure } from '../Procedure';
 import { PolymathError } from '../../PolymathError';
-import { ErrorCode, PolyTransactionTag } from '../../types';
+import { ErrorCode, PolyTransactionTag, ProcedureType } from '../../types';
 
 const params = {
   symbol: 'TEST1',
@@ -56,7 +56,7 @@ describe('EnableGeneralPermissionManager', () => {
   describe('Types', () => {
     test('should extend procedure and have EnableGeneralPermissionManager type', async () => {
       expect(target instanceof Procedure).toBe(true);
-      expect(target.type).toBe('EnableGeneralPermissionManager');
+      expect(target.type).toBe(ProcedureType.EnableGeneralPermissionManager);
     });
   });
 

src/procedures/__tests__/EnableGeneralTransferManager.ts

@@ -0,0 +1,96 @@
+import { ImportMock, MockManager } from 'ts-mock-imports';
+import { spy, restore } from 'sinon';
+import { BigNumber } from '@polymathnetwork/contract-wrappers';
+import * as contractWrappersModule from '@polymathnetwork/contract-wrappers';
+import * as contextModule from '../../Context';
+import * as wrappersModule from '../../PolymathBase';
+import * as tokenFactoryModule from '../../testUtils/MockedTokenFactoryModule';
+import { EnableGeneralTransferManager } from '../../procedures/EnableGeneralTransferManager';
+import { Procedure } from '../Procedure';
+import { PolymathError } from '../../PolymathError';
+import { ErrorCode, PolyTransactionTag, ProcedureType } from '../../types';
+
+const params = {
+  symbol: 'TEST1',
+  address: '0x4444444444444444444444444444444444444444',
+};
+const securityTokenAddress = '0x2222222222222222222222222222222222222222';
+const moduleFactoryAddress = '0x3333333333333333333333333333333333333333';
+
+describe('EnableGeneralTransferManager', () => {
+  let target: EnableGeneralTransferManager;
+  let contextMock: MockManager<contextModule.Context>;
+  let wrappersMock: MockManager<wrappersModule.PolymathBase>;
+  let tokenFactoryMock: MockManager<tokenFactoryModule.MockedTokenFactoryModule>;
+  let etherDividendsMock: MockManager<contractWrappersModule.EtherDividendCheckpoint_3_0_0>;
+  let securityTokenMock: MockManager<contractWrappersModule.SecurityToken_3_0_0>;
+
+  beforeAll(() => {
+    // Mock the context, wrappers, and tokenFactory to test EnableGeneralTransferManagers
+    contextMock = ImportMock.mockClass(contextModule, 'Context');
+    wrappersMock = ImportMock.mockClass(wrappersModule, 'PolymathBase');
+    tokenFactoryMock = ImportMock.mockClass(tokenFactoryModule, 'MockedTokenFactoryModule');
+    contextMock.set('contractWrappers', wrappersMock.getMockInstance());
+    wrappersMock.set('tokenFactory', tokenFactoryMock.getMockInstance());
+
+    securityTokenMock = ImportMock.mockClass(contractWrappersModule, 'SecurityToken_3_0_0');
+    securityTokenMock.mock('address', Promise.resolve(securityTokenAddress));
+
+    etherDividendsMock = ImportMock.mockClass(
+      contractWrappersModule,
+      'EtherDividendCheckpoint_3_0_0'
+    );
+    wrappersMock.mock('getModuleFactoryAddress', Promise.resolve(moduleFactoryAddress));
+    tokenFactoryMock.mock(
+      'getSecurityTokenInstanceFromTicker',
+      securityTokenMock.getMockInstance()
+    );
+
+    // Instantiate EnableGeneralTransferManagers
+    target = new EnableGeneralTransferManager(params, contextMock.getMockInstance());
+  });
+  afterEach(() => {
+    restore();
+  });
+
+  describe('Types', () => {
+    test('should extend procedure and have EnableGeneralTransferManager type', async () => {
+      expect(target instanceof Procedure).toBe(true);
+      expect(target.type).toBe(ProcedureType.EnableGeneralTransferManager);
+    });
+  });
+
+  describe('EnableGeneralTransferManager', () => {
+    test('should add a transaction to the queue to enable general transfer manager', async () => {
+      const addTransactionSpy = spy(target, 'addTransaction');
+      securityTokenMock.mock('addModuleWithLabel', Promise.resolve('AddModuleWithLabel'));
+
+      // Real call
+      await target.prepareTransactions();
+
+      // Verifications
+      expect(
+        addTransactionSpy
+          .getCall(0)
+          .calledWithExactly(securityTokenMock.getMockInstance().addModuleWithLabel, {
+            tag: PolyTransactionTag.EnableGeneralTransferManager,
+          })
+      ).toEqual(true);
+      expect(addTransactionSpy.callCount).toEqual(1);
+    });
+
+    test('should throw if there is no valid security token supplied', async () => {
+      tokenFactoryMock
+        .mock('getSecurityTokenInstanceFromTicker')
+        .withArgs(params.symbol)
+        .throws();
+
+      await expect(target.prepareTransactions()).rejects.toThrow(
+        new PolymathError({
+          code: ErrorCode.ProcedureValidationError,
+          message: `There is no Security Token with symbol ${params.symbol}`,
+        })
+      );
+    });
+  });
+});

src/procedures/__tests__/PauseSto.ts

@@ -100,6 +100,7 @@ describe('PauseSto', () => {
     // Instantiate PauseSto
     target = new PauseSto(cappedParams, contextMock.getMockInstance());
   });
+
   afterEach(() => {
     restore();
   });