Now testing events in constructors! (#1511)

* Added inTransaction tests.

* Added expectEvent.inConstructor.

* Changed inTransaction, removed decodeLogs.

* Flipped comparison to improve the error message.

* Improved expectEvent tests.

* Migrated tests to use expectEvent.

* Added roles constructor tests.

* Fixed linter errors.

* Made lodash a dev dependency.

* Added more inLogs tests.

* Update expectEvent.test.js

* Removed lodash.

* Moved role constructor tests to public role behavior.

* Revert "Flipped comparison to improve the error message."

This reverts commit 438c57833d.

* Replaced chai-as-promised with shouldFail.

test/helpers/decodeLogs.js

@@ -1,12 +0,0 @@
-const SolidityEvent = require('web3/lib/web3/event.js');
-
-function decodeLogs (logs, contract, address) {
-  return logs.map(log => {
-    const event = new SolidityEvent(null, contract.events[log.topics[0]], address);
-    return event.decode(log);
-  });
-}
-
-module.exports = {
-  decodeLogs,
-};

test/helpers/expectEvent.js

@@ -1,3 +1,5 @@
+const SolidityEvent = require('web3/lib/web3/event.js');
+
 const BigNumber = web3.BigNumber;
 const should = require('chai')
   .use(require('chai-bignumber')(BigNumber))
@@ -16,8 +18,14 @@ function inLogs (logs, eventName, eventArgs = {}) {
   return event;
 }
 
-async function inTransaction (tx, eventName, eventArgs = {}) {
-  const { logs } = await tx;
+async function inConstruction (contract, eventName, eventArgs = {}) {
+  return inTransaction(contract.transactionHash, contract.constructor, eventName, eventArgs);
+}
+
+async function inTransaction (txHash, emitter, eventName, eventArgs = {}) {
+  const receipt = await web3.eth.getTransactionReceipt(txHash);
+  const logs = decodeLogs(receipt.logs, emitter.events);
+
   return inLogs(logs, eventName, eventArgs);
 }
 
@@ -35,7 +43,17 @@ function isBigNumber (object) {
     (object.constructor && object.constructor.name === 'BigNumber');
 }
 
+function decodeLogs (logs, events) {
+  return Array.prototype.concat(...logs.map(log =>
+    log.topics.filter(topic => topic in events).map(topic => {
+      const event = new SolidityEvent(null, events[topic], 0);
+      return event.decode(log);
+    })
+  ));
+}
+
 module.exports = {
   inLogs,
+  inConstruction,
   inTransaction,
 };

test/helpers/test/expectEvent.test.js

@@ -1,5 +1,8 @@
 const expectEvent = require('../expectEvent');
+const shouldFail = require('../shouldFail');
+
 const EventEmitter = artifacts.require('EventEmitter');
+const IndirectEventEmitter = artifacts.require('IndirectEventEmitter');
 
 const BigNumber = web3.BigNumber;
 const should = require('chai')
@@ -8,7 +11,57 @@ const should = require('chai')
 
 describe('expectEvent', function () {
   beforeEach(async function () {
-    this.emitter = await EventEmitter.new();
+    this.constructionValues = {
+      uint: 42,
+      boolean: true,
+      string: 'OpenZeppelin',
+    };
+
+    this.emitter = await EventEmitter.new(
+      this.constructionValues.uint,
+      this.constructionValues.boolean,
+      this.constructionValues.string
+    );
+  });
+
+  describe('inConstructor', function () {
+    context('short uint value', function () {
+      it('accepts emitted events with correct number', async function () {
+        await expectEvent.inConstruction(this.emitter, 'ShortUint',
+          { value: this.constructionValues.uint }
+        );
+      });
+
+      it('throws if an incorrect value is passed', async function () {
+        await shouldFail(expectEvent.inConstruction(this.emitter, 'ShortUint', { value: 23 }));
+      });
+    });
+
+    context('boolean value', function () {
+      it('accepts emitted events with correct value', async function () {
+        await expectEvent.inConstruction(this.emitter, 'Boolean', { value: this.constructionValues.boolean });
+      });
+
+      it('throws if an incorrect value is passed', async function () {
+        await shouldFail(expectEvent.inConstruction(this.emitter, 'Boolean',
+          { value: !this.constructionValues.boolean }
+        ));
+      });
+    });
+
+    context('string value', function () {
+      it('accepts emitted events with correct string', async function () {
+        await expectEvent.inConstruction(this.emitter, 'String', { value: this.constructionValues.string });
+      });
+
+      it('throws if an incorrect string is passed', async function () {
+        await shouldFail(expectEvent.inConstruction(this.emitter, 'String', { value: 'ClosedZeppelin' }));
+      });
+    });
+
+    it('throws if an unemitted event is requested', async function () {
+      await shouldFail(expectEvent.inConstruction(this.emitter, 'UnemittedEvent'));
+    });
   });
 
   describe('inLogs', function () {
@@ -228,5 +281,98 @@ describe('expectEvent', function () {
         should.Throw(() => expectEvent.inLogs(this.logs, 'Boolean', { value: false }));
       });
     });
+
+    describe('with events emitted by an indirectly called contract', function () {
+      beforeEach(async function () {
+        this.secondEmitter = await IndirectEventEmitter.new();
+
+        this.value = 'OpenZeppelin';
+        ({ logs: this.logs } = await this.emitter.emitStringAndEmitIndirectly(this.value, this.secondEmitter.address));
+      });
+
+      it('accepts events emitted by the directly called contract', function () {
+        expectEvent.inLogs(this.logs, 'String', { value: this.value });
+      });
+
+      it('throws when passing events emitted by the indirectly called contract', function () {
+        should.Throw(() => expectEvent.inLogs(this.logs, 'IndirectString', { value: this.value }));
+      });
+    });
+  });
+
+  describe('inTransaction', function () {
+    describe('when emitting from called contract and indirect calls', function () {
+      context('string value', function () {
+        beforeEach(async function () {
+          this.secondEmitter = await IndirectEventEmitter.new();
+
+          this.value = 'OpenZeppelin';
+          const receipt = await this.emitter.emitStringAndEmitIndirectly(this.value, this.secondEmitter.address);
+          this.txHash = receipt.tx;
+        });
+
+        context('with directly called contract', function () {
+          it('accepts emitted events with correct string', async function () {
+            await expectEvent.inTransaction(this.txHash, EventEmitter, 'String', { value: this.value });
+          });
+
+          it('throws if an unemitted event is requested', async function () {
+            await shouldFail(expectEvent.inTransaction(this.txHash, EventEmitter, 'UnemittedEvent',
+              { value: this.value }
+            ));
+          });
+
+          it('throws if an incorrect string is passed', async function () {
+            await shouldFail(expectEvent.inTransaction(this.txHash, EventEmitter, 'String',
+              { value: 'ClosedZeppelin' }
+            ));
+          });
+
+          it('throws if an event emitted from other contract is passed', async function () {
+            await shouldFail(expectEvent.inTransaction(this.txHash, EventEmitter, 'IndirectString',
+              { value: this.value }
+            ));
+          });
+
+          it('throws if an incorrect emitter is passed', async function () {
+            await shouldFail(expectEvent.inTransaction(this.txHash, IndirectEventEmitter, 'String',
+              { value: this.value }
+            ));
+          });
+        });
+
+        context('with indirectly called contract', function () {
+          it('accepts events emitted from other contracts', async function () {
+            await expectEvent.inTransaction(this.txHash, IndirectEventEmitter, 'IndirectString',
+              { value: this.value }
+            );
+          });
+
+          it('throws if an unemitted event is requested', async function () {
+            await shouldFail(expectEvent.inTransaction(this.txHash, IndirectEventEmitter, 'UnemittedEvent',
+              { value: this.value }
+            ));
+          });
+
+          it('throws if an incorrect string is passed', async function () {
+            await shouldFail(expectEvent.inTransaction(this.txHash, IndirectEventEmitter, 'IndirectString',
+              { value: 'ClosedZeppelin' }
+            ));
+          });
+
+          it('throws if an event emitted from other contract is passed', async function () {
+            await shouldFail(expectEvent.inTransaction(this.txHash, IndirectEventEmitter, 'String',
+              { value: this.value }
+            ));
+          });
+
+          it('throws if an incorrect emitter is passed', async function () {
+            await shouldFail(expectEvent.inTransaction(this.txHash, EventEmitter, 'IndirectString',
+              { value: this.value }
+            ));
+          });
+        });
+      });
+    });
   });
 });