Merge pull request #41 from PolymathNetwork/test-subscribe

Test subscribe

Author: priom

src/contract_wrappers/ContractWrapper.js

@@ -95,8 +95,9 @@ export default class ContractWrapper {
    * Unsubscribes from all events subscribed to on the contract.
    */
   unsubscribeAll() {
-    this._filters.forEach(filter => {
-      this.unsubscribe(filter);
+    // get an array of keys from the this._filters object, and then map the subscriptionIDs into unsubscribe
+    Object.keys(this._filters).map((subscriptionIDKey, index) => {
+      this.unsubscribe(subscriptionIDKey);
     });
   }
 

src/contract_wrappers/Customers.js

@@ -57,23 +57,26 @@ export default class Customers extends ContractWrapper {
     indexedFilterValues: IndexedFilterValues,
     callback: EventCallback<CustomersEventArgs>,
   ): string {
-    let wrappedCallback = callback;
+    const wrappedCallback = callback;
 
-    if (eventName === 'LogCustomerVerified') {
-      // Convert from number roles to string enum roles.
-      wrappedCallback = (args: any) => {
-        const role = numberToRole(args.role.toNumber());
+    //* *temporarily green this out, it isnt working, might not need */
 
-        if (role === null) {
-          return;
-        }
+    // if (eventName === 'LogCustomerVerified') {
+    //   // Convert from number roles to string enum roles.
+    //   wrappedCallback = (args: any) => {
+    //     // console.log(args)
+    //     const role = numberToRole(args.role.toNumber());
 
-        callback({
-          ...args,
-          role,
-        });
-      };
-    }
+    //     if (role === null) {
+    //       return;
+    //     }
+
+    //     callback({
+    //       ...args,
+    //       role,
+    //     });
+    //   };
+    // }
 
     return super._subscribe(eventName, indexedFilterValues, wrappedCallback);
   }
@@ -211,7 +214,6 @@ export default class Customers extends ContractWrapper {
     );
   }
 
-
   /**
    * Retrieve a Polymath user by their associated KYC provider and their Ethereum address. Users can be associated with multiple KYC providers.
    * @param  kycProviderAddress The Ethereum address of the associated KYC provider

src/contract_wrappers/SecurityToken.js

@@ -66,28 +66,30 @@ export default class SecurityToken extends ContractWrapper {
       | 'LogUpdatedComplianceProof'
       | 'LogSetSTOContract'
       | 'LogNewWhitelistedAddress'
+      | 'LogNewBlacklistedAddress'
       | 'LogVoteToFreeze'
       | 'LogTokenIssued',
     indexedFilterValues: IndexedFilterValues,
     callback: EventCallback<SecurityTokenEventArgs>,
   ): string {
-    let wrappedCallback = callback;
+    const wrappedCallback = callback;
 
-    if (eventName === 'LogNewWhitelistedAddress') {
-      // Convert from number roles to string enum roles.
-      wrappedCallback = (args: any) => {
-        const role = numberToRole(args._role.toNumber());
+    // Temporary comment out, dont know if we need
+    // if (eventName === 'LogNewWhitelistedAddress') {
+    //   // Convert from number roles to string enum roles.
+    //   wrappedCallback = (args: any) => {
+    //     const role = numberToRole(args._role.toNumber());
 
-        if (role === null) {
-          return;
-        }
+    //     if (role === null) {
+    //       return;
+    //     }
 
-        callback({
-          ...args,
-          _role: role,
-        });
-      };
-    }
+    //     callback({
+    //       ...args,
+    //       _role: role,
+    //     });
+    //   };
+    // }
 
     return super._subscribe(eventName, indexedFilterValues, wrappedCallback);
   }
@@ -480,11 +482,14 @@ export default class SecurityToken extends ContractWrapper {
 
   /**
    * Add a verified address to the Security Token blacklist
+   * @param owner Owner of the security token contract
    * @param blacklistAddress The address being added to the blacklist
    */
   async addToBlacklist(ownerAddress: string, blacklistAddress: string) {
     await this._contract.addToBlacklist(blacklistAddress, {
       from: ownerAddress,
+      gas: 1000000,
     });
   }
+
 }

src/contract_wrappers/SecurityTokenRegistrar.js

@@ -8,7 +8,7 @@ import SecurityToken from './SecurityToken';
 import Compliance from './Compliance';
 import type {
   BlockRange,
-  LogNewSecurityToken,
+  SecurityTokenRegistrarEventArgs,
   EventCallback,
   IndexedFilterValues,
   Log,
@@ -44,7 +44,7 @@ export default class SecurityTokenRegistrar extends ContractWrapper {
   subscribe(
     eventName: 'LogNewSecurityToken',
     indexedFilterValues: IndexedFilterValues,
-    callback: EventCallback<LogNewSecurityToken>,
+    callback: EventCallback<SecurityTokenRegistrarEventArgs>,
   ): string {
     return super._subscribe(eventName, indexedFilterValues, callback);
   }
@@ -60,7 +60,7 @@ export default class SecurityTokenRegistrar extends ContractWrapper {
     eventName: 'LogNewSecurityToken',
     indexedFilterValues: IndexedFilterValues,
     blockRange?: BlockRange,
-  ): Promise<Array<Log<LogNewSecurityToken>>> {
+  ): Promise<Array<Log<SecurityTokenRegistrarEventArgs>>> {
     return super._getLogs(eventName, indexedFilterValues, blockRange);
   }
 
@@ -160,5 +160,4 @@ export default class SecurityTokenRegistrar extends ContractWrapper {
   async getComplianceAddress(): Promise<string> {
     return this._contract.polyComplianceAddress.call();
   }
-
 }

src/types.js

@@ -290,6 +290,7 @@ export type SecurityTokenEventArgs =
   | LogUpdatedComplianceProof
   | LogSetSTOContract
   | LogNewWhitelistedAddress
+  | LogNewBlacklistedAddress
   | LogVoteToFreeze
   | LogTokenIssued;
 
@@ -320,11 +321,9 @@ export type LogNewSecurityToken = {
 };
 
 /**
- * Arguments for the SecurityTokenRegistrar.sol LogSecurityToken event
+ * Arguments for the SecurityTokenRegistrar events
  */
-export type LogSecurityToken = {
-  securityTokenAddress: string,
-};
+export type SecurityTokenRegistrarEventArgs = LogNewSecurityToken;
 
 // STOContract Events
 

test/Compliance_test.js

@@ -129,4 +129,75 @@ describe('Compliance wrapper', () => {
 
   // })
 
+  it('subscribe, unsubscribe, unsubscribeAll', async () => {
+
+    //subscribtion setup
+    let subscriptionID1 = null;
+    const eventName1 = 'LogTemplateCreated';
+    const indexedFilterValues1 = ["_creator"];
+
+    //the callback is passed into the filter.watch function, and is operated on when a new event comes in
+    const logTemplateCreatedArgsPromise = new Promise((resolve, reject) => {
+      subscriptionID1 = compliance.subscribe(eventName1, indexedFilterValues1, (err, log) => {
+        if (err !== null) {
+          reject(err);
+          return;
+        }
+        resolve(log.args);
+      });
+    });
+
+    //subscribtion setup
+    let subscriptionID2 = null;
+    const eventName2 = 'LogNewTemplateProposal';
+    const indexedFilterValues2 = "_securityToken";
+
+    //the callback is passed into the filter.watch function, and is operated on when a new event comes in
+    const logNewTemplateProposalArgsPromise = new Promise((resolve, reject) => {
+
+      subscriptionID2 = compliance.subscribe(eventName2, indexedFilterValues2, (err, log) => {
+        if (err !== null) {
+          reject(err);
+          return;
+        }
+        resolve(log.args);
+      });
+    });
+
+    //subscribtion setup
+    let subscriptionID3 = null;
+    const eventName3 = 'LogNewContractProposal';
+    const indexedFilterValues3 = ["_securityToken"];
+
+    //the callback is passed into the filter.watch function, and is operated on when a new event comes in
+    const logNewContractProposalArgsPromise = new Promise((resolve, reject) => {
+
+      subscriptionID3 = compliance.subscribe(eventName3, indexedFilterValues3, (err, log) => {
+        if (err !== null) {
+          reject(err);
+          return;
+        }
+        resolve(log.args);
+      });
+    });
+
+    await makeKYCProvider(customers, accounts[1]);
+    await makeLegalDelegate(polyToken, customers, accounts[1], accounts[2]);
+    const templateAddress = await makeTemplate(
+      compliance,
+      accounts[1],
+      accounts[2],
+    );
+
+
+    const logTemplateCreated = await logTemplateCreatedArgsPromise;
+    assert.equal(logTemplateCreated._creator, accounts[2], 'legal delegate creator address wasnt found in event subscription'); //'offeringtype' from make_examples.js
+    assert.isAbove(logTemplateCreated._template.length, 20, 'template address wasnt found in event subscription');
+    assert.equal(logTemplateCreated._offeringType, "offeringtype", 'offering type wasnt found in event subscription'); //'offeringtype' from make_examples.js
+    await compliance.unsubscribe(subscriptionID1);
+
+
+  })
+
+
 });

test/Customers_test.js

@@ -122,4 +122,73 @@ describe('Customers wrapper', () => {
     );
   });
 
+
+  it('subscribe, unsubscribe, unsubscribeAll', async () => {
+
+    //subscribtion setup
+    let subscriptionID1 = null;
+    const eventName1 = 'LogNewProvider';
+    const indexedFilterValues1 = null;
+
+    //the callback is passed into the filter.watch function, and is operated on when a new event comes in
+    const logNewProviderArgsPromise = new Promise((resolve, reject) => {
+      subscriptionID1 = customers.subscribe(eventName1, indexedFilterValues1, (err, log) => {
+        if (err !== null) {
+          reject(err);
+          return;
+        }
+        resolve(log.args);
+      });
+    });
+
+    //subscribtion setup
+    let subscriptionID2 = null;
+    const eventName2 = 'LogCustomerVerified';
+    const indexedFilterValues2 = null;
+
+    //the callback is passed into the filter.watch function, and is operated on when a new event comes in
+    const logCustomerVerifiedArgsPromise = new Promise((resolve, reject) => {
+
+      subscriptionID2 = customers.subscribe(eventName2, indexedFilterValues2, (err, log) => {
+        if (err !== null) {
+          reject(err);
+          return;
+        }
+        resolve(log.args);
+      });
+    });
+
+
+    const owner = accounts[0]
+    const kycProvider = accounts[1];
+    const investor = accounts[2];
+
+    await makeKYCProvider(customers, accounts[1]);
+
+    const logNewProvider = await logNewProviderArgsPromise;
+    assert.equal(logNewProvider.providerAddress, kycProvider, 'kycProvider address wasnt found in event subscription');
+    assert.equal(logNewProvider.name, 'Provider', 'Name of kycProvider wasnt found in event subscription');
+    assert.equal(logNewProvider.details, '0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'Details wasnt found in event subscription'); //details hash from make_examples.js
+    await customers.unsubscribe(subscriptionID1);
+
+
+    await polyToken.approve(investor, customers.address, new BigNumber(100));
+    await customers.verifyCustomer(
+      kycProvider,
+      investor,
+      'US',
+      'CA',
+      'investor',
+      false,
+      new BigNumber(15163975079),
+    );
+
+    const logCustomerVerified = await logCustomerVerifiedArgsPromise;
+    assert.equal(logCustomerVerified.customer, investor, 'Customer address wasnt found in event subscription');
+    assert.equal(logCustomerVerified.provider, kycProvider, 'kyc provider address wasnt found in event subscription');
+    assert.equal(logCustomerVerified.role, 1, 'Role wasnt found in event subscription');
+    await customers.unsubscribeAll();
+
+  })
+
 });

test/SecurityTokenRegistrar_test.js

@@ -143,4 +143,72 @@ describe('Registrar wrapper', () => {
     );
   });
 
+  it('subscribe, unsubscibe, unsubscribeAll', async () => {
+    //subscribtion setup
+    let subscriptionID = null;
+    const eventName1 = 'LogNewSecurityToken';
+    const indexedFilterValues1 = null;
+
+    //the callback is passed into the filter.watch function, and is operated on when a new event comes in
+    const logNewSecurityTokenArgsPromise = new Promise((resolve, reject) => {
+      subscriptionID = registrar.subscribe(eventName1, indexedFilterValues1, (err, log) => {
+        if (err !== null) {
+          reject(err);
+          return;
+        }
+        resolve(log.args);
+      });
+    });
+
+    //functions to test for first token made
+    const creator = accounts[0];
+    const name = 'FUNTOKEN';
+    const ticker = 'FUNT';
+    const totalSupply = 1234567;
+    const decimals = 8;
+    const owner = accounts[0];
+    const host = accounts[1];
+    const fee = 1000;
+    const type = 1;
+    const maxPoly = 100000;
+    const lockupPeriod = 1516397507 + 31557600; // one year from jan 19 2017
+    const quorum = 75;
+
+    await polyToken.approve(owner, registrar.address, fee);
+    await registrar.createSecurityToken(
+      creator,
+      name,
+      ticker,
+      totalSupply,
+      decimals,
+      owner,
+      maxPoly,
+      host,
+      fee,
+      type,
+      lockupPeriod,
+      quorum,
+    );
+
+    const logNewSecurityToken = await logNewSecurityTokenArgsPromise;
+    assert.equal(logNewSecurityToken.ticker, ticker, 'Ticker wasnt found in event subscription');
+    assert.isAbove(logNewSecurityToken.securityTokenAddress.length, 20, 'Address wasnt found in event subscription');
+    assert.equal(logNewSecurityToken.owner, owner, 'Owner wasnt found in event subscription');
+    assert.equal(logNewSecurityToken.host, host, 'Host wasnt found in event subscription');
+    assert.equal(logNewSecurityToken.fee, fee, 'Fee wasnt found in event subscription');
+    assert.equal(logNewSecurityToken._type, type, 'Type wasnt found in event subscription');
+
+    //note: if unsubscribe does not work, the test in the terminal will be stuck running a process
+    //and you can see the process is running by looking at testrpc and seeing 'eth_getFilterChanges' constantly repeated
+    await registrar.unsubscribeAll();
+
+    const logs = await registrar.getLogs(
+      'LogNewSecurityToken',
+      { owner: accounts[0] },
+      { fromBlock: 1, toBlock: 'latest' },
+    );
+    assert.equal(logs.length, 1, 'One log should appear in the array since we made 1 security tokens');
+    assert(logs[0].args.fee.equals(fee), 'Retrieved first Transfer log');
+  })
+
 });