truffle-assertions - npm Package Compare versions

truffle-assertions

Package Overview

Dependencies

322

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 0.3.1 to 0.4.0

109

index.js

		@@ -1,8 +0,7 @@
		const _ = require('lodash');
		const AssertionError = require('assertion-error');

		/* Creates a new assertion message, containing the passedAssertionMessage and
		* the defaultAssertion message when passedAssertionMessage exists, otherwise
		* just the default.
		*/
		* the defaultAssertion message when passedAssertionMessage exists, otherwise
		* just the default.
		*/
		createAssertionMessage = (passedMessage, defaultMessage) => {
		@@ -41,4 +40,4 @@ let assertionMessage = defaultMessage;
		/* Returns a list of all emitted events in a transaction,
		* using the format of getPrettyEventString
		*/
		* using the format of getPrettyEventString
		*/
		getPrettyEmittedEventsString = (result) => {
		@@ -57,45 +56,73 @@ if (result.logs.length === 0) {

		module.exports = {
		eventEmitted: (result, eventType, filter, message) => {
		/* Filter correct event types */
		const events = _.filter(result.logs, (entry) => {
		return entry.event === eventType;
		});
		//TODO: Move the getPrettyEmittedEventsString to the assertion functions
		assertEventListNotEmpty(events, message, `Event of type ${eventType} was not emitted\n${getPrettyEmittedEventsString(result)}`);
		assertEventEmittedFromTxResult = (result, eventType, filter, message) => {
		/* Filter correct event types */
		const events = result.logs.filter((entry) => {
		return entry.event === eventType;
		});
		//TODO: Move the getPrettyEmittedEventsString to the assertion functions
		assertEventListNotEmpty(events, message, `Event of type ${eventType} was not emitted\n${getPrettyEmittedEventsString(result)}`);

		/* Return if no filter function was provided */
		if (filter === undefined \|\| filter === null) {
		return;
		}
		/* Return if no filter function was provided */
		if (filter === undefined \|\| filter === null) {
		return;
		}

		/* Filter correct arguments */
		let eventArgs = _.map(events, (entry) => {
		return entry.args;
		});
		eventArgs = _.filter(eventArgs, filter);
		assertEventListNotEmpty(eventArgs, message, `Event filter for ${eventType} returned no results\n${getPrettyEmittedEventsString(result)}`);
		},
		eventNotEmitted: (result, eventType, filter, message) => {
		/* Filter correct event types */
		const events = _.filter(result.logs, (entry) => {
		return entry.event === eventType;
		});
		/* Filter correct arguments */
		let eventArgs = events.map((entry) => {
		return entry.args;
		});
		eventArgs = eventArgs.filter(filter);
		assertEventListNotEmpty(eventArgs, message, `Event filter for ${eventType} returned no results\n${getPrettyEmittedEventsString(result)}`);
		}

		/* Only check filtered events if there is no provided filter function */
		if (filter == undefined \|\| filter === null) {
		assertEventListEmpty(events, message, `Event of type ${eventType} was emitted\n${getPrettyEmittedEventsString(result)}`);
		return;
		}
		assertEventNotEmittedFromTxResult = (result, eventType, filter, message) => {
		/* Filter correct event types */
		const events = result.logs.filter((entry) => {
		return entry.event === eventType;
		});

		/* Filter correct arguments */
		let eventArgs = _.map(events, (entry) => {
		return entry.args;
		});
		eventArgs = _.filter(eventArgs, filter);
		assertEventListEmpty(eventArgs, message, `Event filter for ${eventType} returned results\n${getPrettyEmittedEventsString(result)}`);
		/* Only check filtered events if there is no provided filter function */
		if (filter == undefined \|\| filter === null) {
		assertEventListEmpty(events, message, `Event of type ${eventType} was emitted\n${getPrettyEmittedEventsString(result)}`);
		return;
		}

		/* Filter correct arguments */
		let eventArgs = events.map((entry) => {
		return entry.args;
		});
		eventArgs = eventArgs.filter(filter);
		assertEventListEmpty(eventArgs, message, `Event filter for ${eventType} returned results\n${getPrettyEmittedEventsString(result)}`);
		}

		createTransactionResult = (contract, transactionHash) => {
		return new Promise((resolve, reject) => {
		const transactionReceipt = web3.eth.getTransactionReceipt(transactionHash);
		const blockNumber = transactionReceipt.blockNumber;
		const allEvents = contract.allEvents({fromBlock: blockNumber, toBlock: blockNumber});
		allEvents.get((error, logs) => {
		if (error !== null)
		reject(error);
		resolve({
		tx: transactionHash,
		receipt: transactionReceipt,
		logs: logs.filter(log => log.transactionHash === transactionHash)
		});
		})
		});
		}

		module.exports = {
		eventEmitted: (result, eventType, filter, message) => {
		assertEventEmittedFromTxResult(result, eventType, filter, message);
		},
		eventNotEmitted: (result, eventType, filter, message) => {
		assertEventNotEmittedFromTxResult(result, eventType, filter, message);
		},
		prettyPrintEmittedEvents: (result) => {
		console.log(getPrettyEmittedEventsString(result));
		},
		createTransactionResult: (contract, transactionHash) => {
		return createTransactionResult(contract, transactionHash);
		}
		}

package.json

		{
		"name": "truffle-assertions",
		"version": "0.3.1",
		"version": "0.4.0",
		"description": "Additional assertions and utilities for testing Ethereum smart contracts Truffle unit tests",
		@@ -28,4 +28,4 @@ "main": "index.js",
		"assertion-error": "^1.1.0",
		"lodash": "^4.17.5"
		"web3": "^1.0.0-beta.35"
		}
		}

README.md

		@@ -85,3 +85,3 @@ # truffle-assertions

		```
		```javascript
		truffleAssert.prettyPrintEmittedEvents(result);
		@@ -95,1 +95,14 @@ ```
		```

		### truffleAssert.createTransactionResult(contract, transactionHash)

		There can be times where we only have access to a transaction hash, and not to a transaction result object, such as with the deployment of a new contract instance using `Contract.new();`. In these cases we still want to be able to assert that certain events are or aren't emitted.

		`truffle-assertions` offers the possibility to create a transaction result object from a contract instance and a transaction hash, which can then be used in the other functions that the library offers.

		```javascript
		let contractInstance = await Contract.new();
		let result = await truffleAssert.createTransactionResult(contractInstance, contractInstance.transactionHash);

		truffleAssert.eventEmitted(result, 'TestEvent');
		```

Fixed alerts

Improved metrics

Dependency changes