all tests done on compliance

Author: davekay100

src/contract_wrappers/Compliance.js

@@ -49,7 +49,9 @@ export default class Compliance extends ContractWrapper {
     eventName:
       | 'LogTemplateCreated'
       | 'LogNewTemplateProposal'
-      | 'LogNewContractProposal',
+      | 'LogCancelTemplateProposal'
+      | 'LogNewContractProposal'
+      | 'LogCancelContractProposal',
     indexedFilterValues: IndexedFilterValues,
     callback: EventCallback<ComplianceEventArgs>,
   ): string {
@@ -311,17 +313,23 @@ export default class Compliance extends ContractWrapper {
    * Returns all Template proposals
    * @return An array of addresses
    */
-  async getAllTemplateProposals(securityTokenAddress: string): Promise<Array<string>> {
-    return (await this._contract.getAllTemplateProposals.call(securityTokenAddress));
+  async getAllTemplateProposals(
+    securityTokenAddress: string,
+  ): Promise<Array<string>> {
+    return await this._contract.getAllTemplateProposals.call(
+      securityTokenAddress,
+    );
   }
 
-    /**
+  /**
    * Returns all STO proposal addresses
    * @return An array of addresses
    */
-  async getAllOfferingProposals(securityTokenAddress: string): Promise<Array<string>> {
-    return (await this._contract.getAllOfferingProposals.call(securityTokenAddress));
+  async getAllOfferingProposals(
+    securityTokenAddress: string,
+  ): Promise<Array<string>> {
+    return await this._contract.getAllOfferingProposals.call(
+      securityTokenAddress,
+    );
   }
-
-
 }

src/types.js

@@ -164,6 +164,16 @@ export type LogNewTemplateProposal = {
   _securityToken: string,
   _template: string,
   _delegate: string,
+  _templateProposalIndex
+};
+
+/**
+ * Arguments for the Compliance.sol LogCancelTemplateProposal event
+ */
+export type LogCancelTemplateProposal = {
+  _securityToken: string,
+  _offeringContract: string,
+  _proposalIndex: number,
 };
 
 /**
@@ -172,7 +182,17 @@ export type LogNewTemplateProposal = {
 export type LogNewContractProposal = {
   _securityToken: string,
   _offeringContract: string,
-  _delegate: string,
+  _auditor: string,
+  _offeringProposalIndex: number
+};
+
+/**
+ * Arguments for the Compliance.sol LogCancelContractProposal event
+ */
+export type LogCancelContractProposal = {
+  _securityToken: string,
+  _offeringContract: string,
+  _proposalIndex: number,
 };
 
 /**
@@ -181,7 +201,9 @@ export type LogNewContractProposal = {
 export type ComplianceEventArgs =
   | LogTemplateCreated
   | LogNewTemplateProposal
-  | LogNewContractProposal;
+  | LogCancelTemplateProposal
+  | LogNewContractProposal
+  | LogCancelContractProposal;
 
 // SecurityToken types
 

test/Compliance_test.js

@@ -18,7 +18,7 @@ import {
   makeSelectedTemplateForSecurityToken,
   makeSecurityTokenOffering,
 } from './util/make_examples';
-import { makeWeb3Wrapper } from './util/web3';
+import { makeWeb3Wrapper, makeWeb3 } from './util/web3';
 import { fakeAddress, fakeBytes32 } from './util/fake';
 
 const { assert } = chai;
@@ -97,6 +97,42 @@ describe('Compliance wrapper', () => {
   });
 
   it('proposeTemplate, templateReputation, getTemplateAddressByProposal, cancelTemplateProposal, getAllTemplateProposals', async () => {
+
+
+    //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 subscriptionID4 = null;
+    const eventName4 = 'LogCancelTemplateProposal';
+    const indexedFilterValues4 = ["_securityToken"];
+
+    //the callback is passed into the filter.watch function, and is operated on when a new event comes in
+    const logCancleTemplateProposalArgsPromise = new Promise((resolve, reject) => {
+
+      subscriptionID4 = compliance.subscribe(eventName4, indexedFilterValues4, (err, log) => {
+        if (err !== null) {
+          reject(err);
+          return;
+        }
+        resolve(log.args);
+      });
+    });
+
     await makeKYCProvider(customers, accounts[1], expiryTime);
     await makeLegalDelegate(polyToken, customers, accounts[1], accounts[2], expiryTime);
     const templateAddress = await makeTemplateWithFinalized(
@@ -107,11 +143,17 @@ describe('Compliance wrapper', () => {
 
     );
 
+
     // Propose Template
     await compliance.proposeTemplate(accounts[2], securityToken.address, templateAddress);
     const logs = await compliance.getLogs('LogNewTemplateProposal', {}, { fromBlock: 1 });
     assert.equal(logs[0].args._template, templateAddress, 'Template address does not match the logged version');
 
+
+    let logNewTemplateProposal = await logNewTemplateProposalArgsPromise;
+    assert.equal(logNewTemplateProposal._securityToken, securityToken.address, 'ST address not picked up from LogNewTemplateProposal event') //needs to be renamed from core
+
+
     // Reputation
     let templateReputation = await compliance.getTemplateReputation(templateAddress);
     assert.equal(templateReputation.owner, accounts[2], "TemplateReputation not stored or read properly");
@@ -124,30 +166,72 @@ describe('Compliance wrapper', () => {
     let arrayOfTemplates = await compliance.getAllTemplateProposals(securityToken.address)
     assert.equal(arrayOfTemplates[0], templateAddress, 'Template address does not match the getter function return');
 
-    // Cancel Proposal
+
     await compliance.cancelTemplateProposal(accounts[2], securityToken.address, 0);
 
+    let logCancleTemplateProposal = await logCancleTemplateProposalArgsPromise;
+    assert.equal(logNewTemplateProposal._securityToken, securityToken.address, 'ST address not picked up from LogCancleTemplateProposal event') //needs to be renamed from core
+
     const addressShouldBeZero = await compliance.getTemplateAddressByProposal(securityToken.address, 0)
     assert.equal(addressShouldBeZero, 0, 'Proposal returned the wrong template address');
 
+    await compliance.unsubscribeAll();
 
-
-  });
+   });
 
 
   it('getMinimumVestingPeriod', async () => {
     let minimum = await compliance.getMinimumVestingPeriod();
     assert.equal(minimum, 60 * 60 * 24 * 100, "Does not equal 100 days, when it should")
   })
 
-  //so we need to have a securityToken actually created through STRegistrar
-  //and so me of the stuff has to match up
-  //then we have an actual one in offeringProposals
+  // so we need to have a securityToken actually created through STRegistrar
+  // and so me of the stuff has to match up
+  // then we have an actual one in offeringProposals
   it('setSTO, proposeSTO, cancleSTO, getSTOProposal, getSTOAddressByProposal, getAllOfferingProposals', async () => {
+
+    //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);
+      });
+    });
+
+
+
+    //subscribtion setup
+    let subscriptionID5 = null;
+    const eventName5 = 'LogCancelContractProposal';
+    const indexedFilterValues5 = ["_securityToken"];
+
+    //the callback is passed into the filter.watch function, and is operated on when a new event comes in
+    const logCancleContractProposalArgsPromise = new Promise((resolve, reject) => {
+
+      subscriptionID5 = compliance.subscribe(eventName5, indexedFilterValues5, (err, log) => {
+        if (err !== null) {
+          reject(err);
+          return;
+        }
+        resolve(log.args);
+      });
+    });
+
+
     const owner = accounts[0];
     const legalDelegate = accounts[2];
     const kycProvider = accounts[1];
 
+
     // STO variables
     const auditor = accounts[4];
     const startTime = new BigNumber(
@@ -160,11 +244,12 @@ describe('Compliance wrapper', () => {
 
     await makeKYCProvider(customers, kycProvider);
 
-    await makeLegalDelegate(polyToken, customers, kycProvider, legalDelegate);
+    await makeLegalDelegate(polyToken, customers, accounts[1], accounts[2], expiryTime);
     const templateAddress = await makeTemplateWithFinalized(
       compliance,
       kycProvider,
       legalDelegate,
+      expiryTime,
     );
 
     await makeSelectedTemplateForSecurityToken(
@@ -201,6 +286,10 @@ describe('Compliance wrapper', () => {
       endTime,
     );
 
+
+    let logNewContractProposal = await logNewContractProposalArgsPromise;
+    assert.equal(logNewContractProposal._delegate, auditor, 'legal delegate not picked up from LogNewProposal event') //needs to be renamed from core
+
     //to confirm setSTO, we need to check offerings for the msg.sender addr
     //which is using getOfferingByProposal
     //in setSTO we
@@ -214,96 +303,62 @@ describe('Compliance wrapper', () => {
     let getAllOfferings = await compliance.getAllOfferingProposals(securityToken.address, 0)
     assert.equal(getAllOfferings[0], getSTO.stoContractAddress, "STO array of addresses not read properly");
 
+
     // Cancel Proposal
     await compliance.cancelSTOProposal(auditor, securityToken.address, 0);
 
+    //LOGCANCLESTOPROPOSAL
+    let logCancleContractProposal = await logCancleContractProposalArgsPromise;
+    assert.equal(logNewContractProposal._securityToken, securityToken.address, 'ST address not picked up from LogCancleContractProposal event') //needs to be renamed from core
+
+
+
     const addressShouldBeZero = await compliance.getSTOAddressByProposal(securityToken.address, 0)
-    console.log(addressShouldBeZero)
     assert.equal(addressShouldBeZero, 0, 'Proposal did not return zero, which it should have for being cancelled');
 
+    await compliance.unsubscribe(subscriptionID3);
+    await compliance.unsubscribe(subscriptionID5);
 
 
   })
 
-  it('subscribe, unsubscribe, unsubscribeAll', async () => {
-
-    //LogTemplateCreated
-    //LogNewTemplateProposal
-    //LogCancleTemplateProposal
-    //LogNewContractProposal
-    //LogCancleContractProposal
-
-    it('subscribe, unsubscribe, unsubscribeAll', async () => {
-
-      //subscribtion setup
-      let subscriptionID1 = null;
-      const eventName1 = 'LogTemplateCreated';
-      const indexedFilterValues1 = ["_creator"];
-      const expiryTime = new BigNumber(web3.eth.getBlock('latest').timestamp).plus(10000);
-      //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);
-        });
+  it('LogTemplateCreated event test, subscribe, unsubscribe', async () => {
+
+    //subscribtion setup
+    let subscriptionID1 = null;
+    const eventName1 = 'LogTemplateCreated';
+    const indexedFilterValues1 = ["_creator"];
+    const expiryTime = new BigNumber(web3.eth.getBlock('latest').timestamp).plus(10000);
+    //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], expiryTime);
+    await makeLegalDelegate(polyToken, customers, accounts[1], accounts[2], expiryTime);
+    const templateAddress = await makeTemplate(
+      compliance,
+      accounts[1],
+      accounts[2],
+      expiryTime,
+    );
 
-      await makeKYCProvider(customers, accounts[1], expiryTime);
-      await makeLegalDelegate(polyToken, customers, accounts[1], accounts[2], expiryTime);
-      const templateAddress = await makeTemplate(
-        compliance,
-        accounts[1],
-        accounts[2],
-        expiryTime,
-      );
 
+    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);
 
-      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);
 
+  })
 
-    })
 
 
-  })
 });