crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Made function assertions work with the new wrappers

Browse Source
This commit is contained in:
Alex Towle
2019-11-22 14:14:45 -06:00
committed by Michael Zhu
parent 8685cf9036
commit 1e44a9c942
12 changed files with 298 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
contracts/integrations/test/framework/assertions/function_assertion.ts
View File

@@ -1,11 +1,16 @@
import { ContractFunctionObj, ContractTxFunctionObj } from '@0x/base-contract';
import { TransactionReceiptWithDecodedLogs } from 'ethereum-types';
import { TransactionReceiptWithDecodedLogs, TxData } from 'ethereum-types';
import * as _ from 'lodash';
// tslint:disable:max-classes-per-file
export type GenericContractFunction<T> = (...args: any[]) => ContractFunctionObj<T>;
export interface FunctionArguments<TArgs extends any[]> {
args: TArgs;
txData: Partial<TxData>;
}
export interface FunctionResult {
data?: any;
success: boolean;
@@ -22,9 +27,9 @@ export interface FunctionResult {
* @param after A function that will be run after a call to the contract wrapper
* function.
*/
export interface Condition<TBefore> {
before: (...args: any[]) => Promise<TBefore>;
after: (beforeInfo: TBefore, result: FunctionResult, ...args: any[]) => Promise<any>;
export interface Condition<TArgs extends any[], TBefore> {
before: (args: FunctionArguments<TArgs>) => Promise<TBefore>;
after: (beforeInfo: TBefore, result: FunctionResult, args: FunctionArguments<TArgs>) => Promise<any>;
}
/**
@@ -34,8 +39,8 @@ export interface Condition<TBefore> {
* our `Assertion` implementations will do in practice).
* @param runAsync The function to execute for the assertion.
*/
export interface Assertion {
executeAsync: (...args: any[]) => Promise<any>;
export interface Assertion<TArgs extends any[]> {
executeAsync: (args: FunctionArguments<TArgs>) => Promise<any>;
}
export interface AssertionResult<TBefore = unknown> {
@@ -47,9 +52,9 @@ export interface AssertionResult<TBefore = unknown> {
* This class implements `Assertion` and represents a "Hoare Triple" that can be
* executed.
*/
export class FunctionAssertion<TBefore, ReturnDataType> implements Assertion {
export class FunctionAssertion<TArgs extends any[], TBefore, ReturnDataType> implements Assertion<TArgs> {
// A condition that will be applied to `wrapperFunction`.
public condition: Condition<TBefore>;
public condition: Condition<TArgs, TBefore>;
// The wrapper function that will be wrapped in assertions.
public wrapperFunction: (
@@ -60,11 +65,15 @@ export class FunctionAssertion<TBefore, ReturnDataType> implements Assertion {
wrapperFunction: (
...args: any[] // tslint:disable-line:trailing-comma
) => ContractTxFunctionObj<ReturnDataType> | ContractFunctionObj<ReturnDataType>,
condition: Partial<Condition<TBefore>> = {},
condition: Partial<Condition<TArgs, TBefore>> = {},
) {
this.condition = {
before: _.noop.bind(this),
after: _.noop.bind(this),
before: async (args: FunctionArguments<TArgs>) => {
return ({} as any) as TBefore;
},
after: async (beforeInfo: TBefore, result: FunctionResult, args: FunctionArguments<TArgs>) => {
return ({} as any) as TBefore;
},
...condition,
};
this.wrapperFunction = wrapperFunction;
@@ -74,9 +83,9 @@ export class FunctionAssertion<TBefore, ReturnDataType> implements Assertion {
* Runs the wrapped function and fails if the before or after assertions fail.
* @param ...args The args to the contract wrapper function.
*/
public async executeAsync(...args: any[]): Promise<AssertionResult<TBefore>> {
public async executeAsync(args: FunctionArguments<TArgs>): Promise<AssertionResult<TBefore>> {
// Call the before condition.
const beforeInfo = await this.condition.before(...args);
const beforeInfo = await this.condition.before(args);
// Initialize the callResult so that the default success value is true.
const callResult: FunctionResult = { success: true };
@@ -84,21 +93,27 @@ export class FunctionAssertion<TBefore, ReturnDataType> implements Assertion {
// Try to make the call to the function. If it is successful, pass the
// result and receipt to the after condition.
try {
const functionWithArgs = this.wrapperFunction(...args) as ContractTxFunctionObj<ReturnDataType>;
callResult.data = await functionWithArgs.callAsync();
const functionWithArgs = this.wrapperFunction(...args.args) as ContractTxFunctionObj<ReturnDataType>;
callResult.data = await functionWithArgs.callAsync(args.txData);
console.log(functionWithArgs);
callResult.receipt =
functionWithArgs.awaitTransactionSuccessAsync !== undefined
? await functionWithArgs.awaitTransactionSuccessAsync() // tslint:disable-line:await-promise
? await functionWithArgs.awaitTransactionSuccessAsync(args.txData) // tslint:disable-line:await-promise
: undefined;
// tslint:enable:await-promise
} catch (error) {
console.log('got here');
console.log(error);
callResult.data = error;
callResult.success = false;
callResult.receipt = undefined;
}
// Call the after condition.
const afterInfo = await this.condition.after(beforeInfo, callResult, ...args);
const afterInfo = await this.condition.after(beforeInfo, callResult, args);
return {
beforeInfo,