feat: adding more module factory methods with tests

Author: Victor Wiebe

src/contract_wrappers/modules/__tests__/module_factory_wrapper.test.ts

@@ -1,17 +1,23 @@
 // ModuleFactoryWrapper test
-import { mock, instance, reset, when, verify } from 'ts-mockito';
+import {mock, instance, reset, when, verify, objectContaining} from 'ts-mockito';
 import {
   ModuleFactoryContract,
   BigNumber,
   Web3Wrapper,
   EtherDividendCheckpointEvents,
 } from '@polymathnetwork/abi-wrappers';
-import { MockedCallMethod, MockedSendMethod } from '../../../test_utils/mocked_methods';
+import {getMockedPolyResponse, MockedCallMethod, MockedSendMethod} from '../../../test_utils/mocked_methods';
 import ContractFactory from '../../../factories/contractFactory';
-import { bytes32ToString, stringToBytes32, weiToValue } from '../../../utils/convert';
+import {
+  bytes32ToString,
+  parseModuleTypeValue,
+  stringArrayToBytes32Array,
+  stringToBytes32,
+  weiToValue
+} from '../../../utils/convert';
 import ModuleFactoryWrapper from '../module_factory_wrapper';
 import ContractWrapper from '../../contract_wrapper';
-import { FULL_DECIMALS } from '../../../types';
+import {FULL_DECIMALS, ModuleType} from '../../../types';
 
 describe('ModuleFactoryWrapper', () => {
   let target: ModuleFactoryWrapper;
@@ -40,6 +46,27 @@ describe('ModuleFactoryWrapper', () => {
     });
   });
 
+  describe('owner', () => {
+    test('should call to owner', async () => {
+      const expectedResult = '0x0123456789012345678901234567890123456789';
+      // Mocked method
+      const mockedMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.owner).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(mockedMethod.callAsync()).thenResolve(expectedResult);
+
+      // Real call
+      const result = await target.owner();
+      // Result expectation
+      expect(result).toBe(expectedResult);
+      // Verifications
+      verify(mockedContract.owner).once();
+      verify(mockedMethod.callAsync()).once();
+    });
+  });
+
+
   describe('Name', () => {
     test('should get name', async () => {
       // Address expected
@@ -145,6 +172,94 @@ describe('ModuleFactoryWrapper', () => {
     });
   });
 
+  describe('GetTypes', () => {
+    test('should get types', async () => {
+      // Address expected
+      const expectedResult = [new BigNumber(ModuleType.STO), new BigNumber(ModuleType.Dividends)];
+      // Mocked method
+      const mockedMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.getTypes).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(mockedMethod.callAsync()).thenResolve(expectedResult);
+
+      // Real call
+      const result = await target.getTypes();
+      // Result expectation
+      expect(result).toEqual(expectedResult.map(parseModuleTypeValue));
+      // Verifications
+      verify(mockedContract.getTypes).once();
+      verify(mockedMethod.callAsync()).once();
+    });
+  });
+
+  describe('getTags', () => {
+    test('should get tags', async () => {
+      // Address expected
+      const expectedResult = stringArrayToBytes32Array(['Tag1', 'Tag2']);
+      // Mocked method
+      const mockedMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.getTags).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(mockedMethod.callAsync()).thenResolve(expectedResult);
+
+      // Real call
+      const result = await target.getTags();
+      // Result expectation
+      expect(stringArrayToBytes32Array(result)).toEqual(expectedResult);
+      // Verifications
+      verify(mockedContract.getTags).once();
+      verify(mockedMethod.callAsync()).once();
+    });
+  });
+
+  describe('changeSetupCost', () => {
+    test.todo('should fail as changeSetupCost is 0');
+    test('should send the transaction to changeSetupCost', async () => {
+      // Mocked parameters
+      const mockedParams = {
+        setupCost: new BigNumber(100),
+        txData: {},
+        safetyFactor: 10,
+      };
+      const expectedResult = getMockedPolyResponse();
+      // Mocked method
+      const mockedMethod = mock(MockedSendMethod);
+      // Stub the method
+      when(mockedContract.changeSetupCost).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(
+          mockedMethod.sendTransactionAsync(objectContaining(mockedParams.setupCost), mockedParams.txData, mockedParams.safetyFactor),
+      ).thenResolve(expectedResult);
+
+      // Owner Address expected
+      const expectedOwnerResult = '0x5555555555555555555555555555555555555555';
+      // Mocked method
+      const mockedOwnerMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.owner).thenReturn(instance(mockedOwnerMethod));
+      // Stub the request
+      when(mockedOwnerMethod.callAsync()).thenResolve(expectedOwnerResult);
+      // Mock web3 wrapper owner
+      when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
+
+      // Real call
+      const result = await target.changeSetupCost(mockedParams);
+
+      // Result expectation
+      expect(result).toBe(expectedResult);
+      // Verifications
+      verify(mockedContract.owner).once();
+      verify(mockedOwnerMethod.callAsync()).once();
+      verify(mockedContract.changeSetupCost).once();
+      verify(
+          mockedMethod.sendTransactionAsync(objectContaining(mockedParams.setupCost), mockedParams.txData, mockedParams.safetyFactor),
+      ).once();
+      verify(mockedWrapper.getAvailableAddressesAsync()).once();
+    });
+  });
+
   describe('setupCost', () => {
     test('should get setupCost', async () => {
       // Address expected

src/contract_wrappers/modules/module_factory_wrapper.ts

@@ -10,6 +10,7 @@ import {
   Web3Wrapper,
   ContractAbi,
   LogWithDecodedArgs,
+  TxData,
 } from '@polymathnetwork/abi-wrappers';
 import { schemas } from '@0x/json-schemas';
 import assert from '../../utils/assert';
@@ -21,8 +22,11 @@ import {
   Subscribe,
   GetLogs,
   FULL_DECIMALS,
+  ModuleType,
+  TxParams,
 } from '../../types';
-import { weiToValue, bytes32ToString } from '../../utils/convert';
+import { weiToValue, bytes32ToString, bytes32ArrayToStringArray, parseModuleTypeValue } from '../../utils/convert';
+import functionsUtils from '../../utils/functions_utils';
 
 interface OwnershipTransferredSubscribeAsyncParams extends SubscribeAsyncParams {
   eventName: ModuleFactoryEvents.OwnershipTransferred;
@@ -66,6 +70,10 @@ interface ModuleFactorySubscribeAsyncParams extends Subscribe {
   >;
 }
 
+interface ChangeSetupCostParams extends TxParams {
+  setupCost: BigNumber;
+}
+
 /**
  * This class includes the functionality related to interacting with the ModuleFactory contract.
  */
@@ -84,6 +92,13 @@ export default class ModuleFactoryWrapper extends ContractWrapper {
     this.contract = contract;
   }
 
+  /**
+   * Get the owner of the Module Factory
+   */
+  public owner = async () => {
+    return (await this.contract).owner.callAsync();
+  };
+
   /**
    * Get the name of the Module
    */
@@ -120,6 +135,34 @@ export default class ModuleFactoryWrapper extends ContractWrapper {
     return (await this.contract).version.callAsync();
   };
 
+  /**
+   * Get the types
+   */
+  public getTypes = async (): Promise<ModuleType[]> => {
+    return (await (await this.contract).getTypes.callAsync()).map(type => {
+      return parseModuleTypeValue(type);
+    });
+  };
+
+  /**
+   * Get the tags
+   */
+  public getTags = async (): Promise<string[]> => {
+    return bytes32ArrayToStringArray(await (await this.contract).getTags.callAsync());
+  };
+
+  /**
+   * Change the setupCost
+   */
+  public changeSetupCost = async (params: ChangeSetupCostParams) => {
+    await this.checkOnlyOwner(params.txData);
+    return (await this.contract).changeSetupCost.sendTransactionAsync(
+      params.setupCost,
+      params.txData,
+      params.safetyFactor,
+    );
+  };
+
   /**
    * Get setup cost
    */
@@ -192,4 +235,11 @@ export default class ModuleFactoryWrapper extends ContractWrapper {
     );
     return logs;
   };
+
+  private checkOnlyOwner = async (txData: Partial<TxData> | undefined) => {
+    assert.assert(
+      functionsUtils.checksumAddressComparision(await this.owner(), await this.getCallerAddress(txData)),
+      'Msg sender must be owner',
+    );
+  };
 }

src/utils/convert.ts

@@ -1,5 +1,5 @@
 import { ethers, BigNumber } from '@polymathnetwork/abi-wrappers';
-import { Partition, Perm } from '../types';
+import { ModuleType, Partition, Perm } from '../types';
 
 const BASE = new BigNumber(10);
 
@@ -100,4 +100,20 @@ export function parsePermBytes32Value(value: string): Perm {
     default:
       throw new Error('Permission not recognized');
   }
+}
+  export function parseModuleTypeValue(value: BigNumber): ModuleType {
+    switch (value.toNumber()) {
+      case ModuleType.Dividends:
+        return ModuleType.Dividends;
+      case ModuleType.STO:
+        return ModuleType.STO;
+      case ModuleType.TransferManager:
+        return ModuleType.TransferManager;
+      case ModuleType.PermissionManager:
+        return ModuleType.PermissionManager;
+      case ModuleType.Burn:
+        return ModuleType.Burn;
+      default:
+        throw new Error('Module Type not recognized');
+    }
 }