From 3cf25d0787448f58930dcd9ec9bf040530278486 Mon Sep 17 00:00:00 2001 From: Fabio Berger Date: Fri, 26 May 2017 17:08:45 +0200 Subject: Postfix test files with `_test` --- test/0x.js.ts | 160 ----------------------------------------------------- test/0x.js_test.ts | 160 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 160 insertions(+), 160 deletions(-) delete mode 100644 test/0x.js.ts create mode 100644 test/0x.js_test.ts (limited to 'test') diff --git a/test/0x.js.ts b/test/0x.js.ts deleted file mode 100644 index d5b2015fb..000000000 --- a/test/0x.js.ts +++ /dev/null @@ -1,160 +0,0 @@ -import {ZeroEx} from '../src/ts/0x.js'; -import * as chai from 'chai'; -import 'mocha'; -import * as BigNumber from 'bignumber.js'; -import ChaiBigNumber = require('chai-bignumber'); -import {constants} from '../src/ts/utils/constants'; - -// Use BigNumber chai add-on -chai.use(ChaiBigNumber()); -const expect = chai.expect; - -describe('ZeroEx library', () => { - describe('#getOrderHash', () => { - const ORDER_HASH = '0x103a5e97dab5dbeb8f385636f86a7d1e458a7ccbe1bd194727f0b2f85ab116c7'; - it('defaults takerAddress to NULL address', () => { - const orderHash = ZeroEx.getOrderHashHex( - constants.NULL_ADDRESS, - constants.NULL_ADDRESS, - '', - constants.NULL_ADDRESS, - constants.NULL_ADDRESS, - constants.NULL_ADDRESS, - new BigNumber(0), - new BigNumber(0), - new BigNumber(0), - new BigNumber(0), - new BigNumber(0), - new BigNumber(0), - ); - expect(orderHash).to.be.equal(ORDER_HASH); - }); - it('calculates the order hash', () => { - const orderHash = ZeroEx.getOrderHashHex( - constants.NULL_ADDRESS, - constants.NULL_ADDRESS, - constants.NULL_ADDRESS, - constants.NULL_ADDRESS, - constants.NULL_ADDRESS, - constants.NULL_ADDRESS, - new BigNumber(0), - new BigNumber(0), - new BigNumber(0), - new BigNumber(0), - new BigNumber(0), - new BigNumber(0), - ); - expect(orderHash).to.be.equal(ORDER_HASH); - }); - }); - describe('#isValidSignature', () => { - // This test data was borrowed from the JSON RPC documentation - // Source: https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign - const data = '0xdeadbeaf'; - const signature = { - v: 27, - r: '0xa3f20717a250c2b0b729b7e5becbff67fdaef7e0699da4de7ca5895b02a170a1', - s: '0x2d887fd3b17bfdce3481f10bea41f45ba9f709d39ce8325427b57afcfc994cee', - }; - const address = '0x9b2055d370f73ec7d8a03e965129118dc8f5bf83'; - describe('should throw if passed a malformed signature', () => { - it('malformed v', () => { - const malformedSignature = { - v: 34, - r: signature.r, - s: signature.s, - }; - expect(() => ZeroEx.isValidSignature(data, malformedSignature, address)).to.throw(); - }); - it('r lacks 0x prefix', () => { - const malformedR = signature.r.replace('0x', ''); - const malformedSignature = { - v: signature.v, - r: malformedR, - s: signature.s, - }; - expect(() => ZeroEx.isValidSignature(data, malformedSignature, address)).to.throw(); - }); - it('r is too short', () => { - const malformedR = signature.r.substr(10); - const malformedSignature = { - v: signature.v, - r: malformedR, - s: signature.s.replace('0', 'z'), - }; - expect(() => ZeroEx.isValidSignature(data, malformedSignature, address)).to.throw(); - }); - it('s is not hex', () => { - const malformedS = signature.s.replace('0', 'z'); - const malformedSignature = { - v: signature.v, - r: signature.r, - s: malformedS, - }; - expect(() => ZeroEx.isValidSignature(data, malformedSignature, address)).to.throw(); - }); - }); - it('should return false if the data doesn\'t pertain to the signature & address', () => { - const isValid = ZeroEx.isValidSignature('0x0', signature, address); - expect(isValid).to.be.false; - }); - it('should return false if the address doesn\'t pertain to the signature & data', () => { - const validUnrelatedAddress = '0x8b0292B11a196601eD2ce54B665CaFEca0347D42'; - const isValid = ZeroEx.isValidSignature(data, signature, validUnrelatedAddress); - expect(isValid).to.be.false; - }); - it('should return false if the signature doesn\'t pertain to the data & address', () => { - const wrongSignature = Object.assign({}, signature, {v: 28}); - const isValid = ZeroEx.isValidSignature(data, wrongSignature, address); - expect(isValid).to.be.false; - }); - it('should return true if the signature does pertain to the data & address', () => { - const isValid = ZeroEx.isValidSignature(data, signature, address); - expect(isValid).to.be.true; - }); - }); - describe('#generateSalt', () => { - it('generates different salts', () => { - const equal = ZeroEx.generatePseudoRandomSalt().eq(ZeroEx.generatePseudoRandomSalt()); - expect(equal).to.be.false; - }); - it('generates salt in range [0..2^256)', () => { - const salt = ZeroEx.generatePseudoRandomSalt(); - expect(salt.greaterThanOrEqualTo(0)).to.be.true; - const twoPow256 = new BigNumber(2).pow(256); - expect(salt.lessThan(twoPow256)).to.be.true; - }); - }); - describe('#isValidOrderHash', () => { - it('returns false if the value is not a hex string', () => { - const isValid = ZeroEx.isValidOrderHash('not a hex'); - expect(isValid).to.be.false; - }); - it('returns false if the length is wrong', () => { - const isValid = ZeroEx.isValidOrderHash('0xdeadbeef'); - expect(isValid).to.be.false; - }); - it('returns true if order hash is correct', () => { - const isValid = ZeroEx.isValidOrderHash('0x' + Array(65).join('0')); - expect(isValid).to.be.true; - }); - }); - describe('#toUnitAmount', () => { - it('Should return the expected unit amount for the decimals passed in', () => { - const baseUnitAmount = new BigNumber(1000000000); - const decimals = 6; - const unitAmount = ZeroEx.toUnitAmount(baseUnitAmount, decimals); - const expectedUnitAmount = new BigNumber(1000); - expect(unitAmount).to.be.bignumber.equal(expectedUnitAmount); - }); - }); - describe('#toBaseUnitAmount', () => { - it('Should return the expected base unit amount for the decimals passed in', () => { - const unitAmount = new BigNumber(1000); - const decimals = 6; - const baseUnitAmount = ZeroEx.toBaseUnitAmount(unitAmount, decimals); - const expectedUnitAmount = new BigNumber(1000000000); - expect(baseUnitAmount).to.be.bignumber.equal(expectedUnitAmount); - }); - }); -}); diff --git a/test/0x.js_test.ts b/test/0x.js_test.ts new file mode 100644 index 000000000..d5b2015fb --- /dev/null +++ b/test/0x.js_test.ts @@ -0,0 +1,160 @@ +import {ZeroEx} from '../src/ts/0x.js'; +import * as chai from 'chai'; +import 'mocha'; +import * as BigNumber from 'bignumber.js'; +import ChaiBigNumber = require('chai-bignumber'); +import {constants} from '../src/ts/utils/constants'; + +// Use BigNumber chai add-on +chai.use(ChaiBigNumber()); +const expect = chai.expect; + +describe('ZeroEx library', () => { + describe('#getOrderHash', () => { + const ORDER_HASH = '0x103a5e97dab5dbeb8f385636f86a7d1e458a7ccbe1bd194727f0b2f85ab116c7'; + it('defaults takerAddress to NULL address', () => { + const orderHash = ZeroEx.getOrderHashHex( + constants.NULL_ADDRESS, + constants.NULL_ADDRESS, + '', + constants.NULL_ADDRESS, + constants.NULL_ADDRESS, + constants.NULL_ADDRESS, + new BigNumber(0), + new BigNumber(0), + new BigNumber(0), + new BigNumber(0), + new BigNumber(0), + new BigNumber(0), + ); + expect(orderHash).to.be.equal(ORDER_HASH); + }); + it('calculates the order hash', () => { + const orderHash = ZeroEx.getOrderHashHex( + constants.NULL_ADDRESS, + constants.NULL_ADDRESS, + constants.NULL_ADDRESS, + constants.NULL_ADDRESS, + constants.NULL_ADDRESS, + constants.NULL_ADDRESS, + new BigNumber(0), + new BigNumber(0), + new BigNumber(0), + new BigNumber(0), + new BigNumber(0), + new BigNumber(0), + ); + expect(orderHash).to.be.equal(ORDER_HASH); + }); + }); + describe('#isValidSignature', () => { + // This test data was borrowed from the JSON RPC documentation + // Source: https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign + const data = '0xdeadbeaf'; + const signature = { + v: 27, + r: '0xa3f20717a250c2b0b729b7e5becbff67fdaef7e0699da4de7ca5895b02a170a1', + s: '0x2d887fd3b17bfdce3481f10bea41f45ba9f709d39ce8325427b57afcfc994cee', + }; + const address = '0x9b2055d370f73ec7d8a03e965129118dc8f5bf83'; + describe('should throw if passed a malformed signature', () => { + it('malformed v', () => { + const malformedSignature = { + v: 34, + r: signature.r, + s: signature.s, + }; + expect(() => ZeroEx.isValidSignature(data, malformedSignature, address)).to.throw(); + }); + it('r lacks 0x prefix', () => { + const malformedR = signature.r.replace('0x', ''); + const malformedSignature = { + v: signature.v, + r: malformedR, + s: signature.s, + }; + expect(() => ZeroEx.isValidSignature(data, malformedSignature, address)).to.throw(); + }); + it('r is too short', () => { + const malformedR = signature.r.substr(10); + const malformedSignature = { + v: signature.v, + r: malformedR, + s: signature.s.replace('0', 'z'), + }; + expect(() => ZeroEx.isValidSignature(data, malformedSignature, address)).to.throw(); + }); + it('s is not hex', () => { + const malformedS = signature.s.replace('0', 'z'); + const malformedSignature = { + v: signature.v, + r: signature.r, + s: malformedS, + }; + expect(() => ZeroEx.isValidSignature(data, malformedSignature, address)).to.throw(); + }); + }); + it('should return false if the data doesn\'t pertain to the signature & address', () => { + const isValid = ZeroEx.isValidSignature('0x0', signature, address); + expect(isValid).to.be.false; + }); + it('should return false if the address doesn\'t pertain to the signature & data', () => { + const validUnrelatedAddress = '0x8b0292B11a196601eD2ce54B665CaFEca0347D42'; + const isValid = ZeroEx.isValidSignature(data, signature, validUnrelatedAddress); + expect(isValid).to.be.false; + }); + it('should return false if the signature doesn\'t pertain to the data & address', () => { + const wrongSignature = Object.assign({}, signature, {v: 28}); + const isValid = ZeroEx.isValidSignature(data, wrongSignature, address); + expect(isValid).to.be.false; + }); + it('should return true if the signature does pertain to the data & address', () => { + const isValid = ZeroEx.isValidSignature(data, signature, address); + expect(isValid).to.be.true; + }); + }); + describe('#generateSalt', () => { + it('generates different salts', () => { + const equal = ZeroEx.generatePseudoRandomSalt().eq(ZeroEx.generatePseudoRandomSalt()); + expect(equal).to.be.false; + }); + it('generates salt in range [0..2^256)', () => { + const salt = ZeroEx.generatePseudoRandomSalt(); + expect(salt.greaterThanOrEqualTo(0)).to.be.true; + const twoPow256 = new BigNumber(2).pow(256); + expect(salt.lessThan(twoPow256)).to.be.true; + }); + }); + describe('#isValidOrderHash', () => { + it('returns false if the value is not a hex string', () => { + const isValid = ZeroEx.isValidOrderHash('not a hex'); + expect(isValid).to.be.false; + }); + it('returns false if the length is wrong', () => { + const isValid = ZeroEx.isValidOrderHash('0xdeadbeef'); + expect(isValid).to.be.false; + }); + it('returns true if order hash is correct', () => { + const isValid = ZeroEx.isValidOrderHash('0x' + Array(65).join('0')); + expect(isValid).to.be.true; + }); + }); + describe('#toUnitAmount', () => { + it('Should return the expected unit amount for the decimals passed in', () => { + const baseUnitAmount = new BigNumber(1000000000); + const decimals = 6; + const unitAmount = ZeroEx.toUnitAmount(baseUnitAmount, decimals); + const expectedUnitAmount = new BigNumber(1000); + expect(unitAmount).to.be.bignumber.equal(expectedUnitAmount); + }); + }); + describe('#toBaseUnitAmount', () => { + it('Should return the expected base unit amount for the decimals passed in', () => { + const unitAmount = new BigNumber(1000); + const decimals = 6; + const baseUnitAmount = ZeroEx.toBaseUnitAmount(unitAmount, decimals); + const expectedUnitAmount = new BigNumber(1000000000); + expect(baseUnitAmount).to.be.bignumber.equal(expectedUnitAmount); + }); + }); +}); -- cgit From 555bac19cb90a83d5a0025e53341f76ff39c4373 Mon Sep 17 00:00:00 2001 From: Fabio Berger Date: Fri, 26 May 2017 17:12:22 +0200 Subject: Setup blockchain snapshotting before/after every test, implemented unit tests for exchangeWrapper.isValidSignature --- test/contract_wrapper_test.ts | 99 ++++++++++++++++++++++++++++++++++++++++++ test/utils/blockchain_clean.ts | 19 ++++++++ test/utils/constants.ts | 5 +++ test/utils/rpc.ts | 48 ++++++++++++++++++++ test/utils/web3_factory.ts | 23 ++++++++++ 5 files changed, 194 insertions(+) create mode 100644 test/contract_wrapper_test.ts create mode 100644 test/utils/blockchain_clean.ts create mode 100644 test/utils/constants.ts create mode 100644 test/utils/rpc.ts create mode 100644 test/utils/web3_factory.ts (limited to 'test') diff --git a/test/contract_wrapper_test.ts b/test/contract_wrapper_test.ts new file mode 100644 index 000000000..65eceb827 --- /dev/null +++ b/test/contract_wrapper_test.ts @@ -0,0 +1,99 @@ +import 'mocha'; +import * as chai from 'chai'; +import chaiAsPromised = require('chai-as-promised'); +import {web3Factory} from './utils/web3_factory'; +import * as Web3 from 'web3'; +import {ExchangeWrapper} from '../src/ts/contract_wrappers/exchange_wrapper'; +import {BlockchainClean} from './utils/blockchain_clean'; +import {Web3Wrapper} from './../src/ts/web3_wrapper'; + +const expect = chai.expect; +chai.use(chaiAsPromised); +const blockchainClean = new BlockchainClean(); + +describe('ExchangeWrapper', () => { + let web3Wrapper: Web3Wrapper; + let exchangeWrapper: ExchangeWrapper; + before(async () => { + const web3 = web3Factory.create(); + web3Wrapper = new Web3Wrapper(web3); + exchangeWrapper = new ExchangeWrapper(web3Wrapper); + }); + beforeEach(async () => { + await blockchainClean.setupAsync(); + }); + afterEach(async () => { + await blockchainClean.restoreAsync(); + }); + describe('#isValidSignatureAsync', () => { + // The Exchange smart contract `isValidSignature` method only validates orderHashes and assumes + // the length of the data is exactly 32 bytes. Thus for these tests, we use data of this size. + const dataHex = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0'; + const signature = { + v: 27, + r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33', + s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254', + }; + const address = '0x5409ed021d9299bf6814279a6a1411a7e866a631'; + describe('should throw if passed a malformed signature', () => { + it('malformed v', async () => { + const malformedSignature = { + v: 34, + r: signature.r, + s: signature.s, + }; + expect(exchangeWrapper.isValidSignatureAsync(dataHex, malformedSignature, address)) + .to.be.rejected; + }); + it('r lacks 0x prefix', () => { + const malformedR = signature.r.replace('0x', ''); + const malformedSignature = { + v: signature.v, + r: malformedR, + s: signature.s, + }; + expect(exchangeWrapper.isValidSignatureAsync(dataHex, malformedSignature, address)) + .to.be.rejected; + }); + it('r is too short', () => { + const malformedR = signature.r.substr(10); + const malformedSignature = { + v: signature.v, + r: malformedR, + s: signature.s.replace('0', 'z'), + }; + expect(exchangeWrapper.isValidSignatureAsync(dataHex, malformedSignature, address)) + .to.be.rejected; + }); + it('s is not hex', () => { + const malformedS = signature.s.replace('0', 'z'); + const malformedSignature = { + v: signature.v, + r: signature.r, + s: malformedS, + }; + expect(exchangeWrapper.isValidSignatureAsync(dataHex, malformedSignature, address)) + .to.be.rejected; + }); + }); + it('should return false if the data doesn\'t pertain to the signature & address', async () => { + const isValid = await exchangeWrapper.isValidSignatureAsync('0x0', signature, address); + expect(isValid).to.be.false; + }); + it('should return false if the address doesn\'t pertain to the signature & dataHex', async () => { + const validUnrelatedAddress = '0x8b0292B11a196601eD2ce54B665CaFEca0347D42'; + const isValid = await exchangeWrapper.isValidSignatureAsync(dataHex, signature, validUnrelatedAddress); + expect(isValid).to.be.false; + }); + it('should return false if the signature doesn\'t pertain to the dataHex & address', async () => { + const wrongSignature = Object.assign({}, signature, {v: 28}); + const isValid = await exchangeWrapper.isValidSignatureAsync(dataHex, wrongSignature, address); + expect(isValid).to.be.false; + }); + it('should return true if the signature does pertain to the dataHex & address', async () => { + const isValid = await exchangeWrapper.isValidSignatureAsync(dataHex, signature, address); + console.log('isValid', isValid); + expect(isValid).to.be.true; + }); + }); +}); diff --git a/test/utils/blockchain_clean.ts b/test/utils/blockchain_clean.ts new file mode 100644 index 000000000..6468dbec7 --- /dev/null +++ b/test/utils/blockchain_clean.ts @@ -0,0 +1,19 @@ +import {RPC} from './rpc'; + +export class BlockchainClean { + private rpc: RPC; + private snapshotId: number; + constructor() { + this.rpc = new RPC(); + } + // TODO: Check if running on TestRPC or on actual node, if actual node, re-deploy contracts instead + public async setupAsync() { + this.snapshotId = await this.rpc.takeSnapshotAsync(); + } + public async restoreAsync() { + const didRevert = await this.rpc.revertSnapshotAsync(this.snapshotId); + if (!didRevert) { + throw new Error(`Snapshot with id #${this.snapshotId} failed to revert`); + } + } +}; diff --git a/test/utils/constants.ts b/test/utils/constants.ts new file mode 100644 index 000000000..aa1967f88 --- /dev/null +++ b/test/utils/constants.ts @@ -0,0 +1,5 @@ +export const constants = { + NULL_ADDRESS: '0x0000000000000000000000000000000000000000', + RPC_HOST: 'localhost', + RPC_PORT: 8545, +}; diff --git a/test/utils/rpc.ts b/test/utils/rpc.ts new file mode 100644 index 000000000..b689a938c --- /dev/null +++ b/test/utils/rpc.ts @@ -0,0 +1,48 @@ +import * as ethUtil from 'ethereumjs-util'; +import * as request from 'request-promise-native'; +import {constants} from './constants'; + +export class RPC { + private host: string; + private port: number; + private id: number; + constructor() { + this.host = constants.RPC_HOST; + this.port = constants.RPC_PORT; + this.id = 0; + } + public async takeSnapshotAsync(): Promise { + const method = 'evm_snapshot'; + const params: any[] = []; + const payload = this.toPayload(method, params); + const snapshotIdHex = await this.sendAsync(payload); + const snapshotId = ethUtil.bufferToInt(ethUtil.toBuffer(snapshotIdHex)); + return snapshotId; + } + public async revertSnapshotAsync(snapshotId: number): Promise { + const method = 'evm_revert'; + const params = [snapshotId]; + const payload = this.toPayload(method, params); + const didRevert = await this.sendAsync(payload); + return didRevert; + } + private toPayload(method: string, params: any[] = []) { + const payload = JSON.stringify({ + id: this.id, + method, + params, + }); + this.id += 1; + return payload; + } + private async sendAsync(payload: string) { + const opts = { + method: 'POST', + uri: `http://${this.host}:${this.port}`, + body: payload, + }; + const bodyString = await request(opts); + const body = JSON.parse(bodyString); + return body.result; + } +} diff --git a/test/utils/web3_factory.ts b/test/utils/web3_factory.ts new file mode 100644 index 000000000..493fbc2df --- /dev/null +++ b/test/utils/web3_factory.ts @@ -0,0 +1,23 @@ +// HACK: web3 injects XMLHttpRequest into the global scope and ProviderEngine checks XMLHttpRequest +// to know whether it is running in a browser or node environment. We need it to be undefined since +// we are not running in a browser env. +// Filed issue: https://github.com/ethereum/web3.js/issues/844 +(global as any).XMLHttpRequest = undefined; +import ProviderEngine = require('web3-provider-engine'); +import RpcSubprovider = require('web3-provider-engine/subproviders/rpc'); +import * as Web3 from 'web3'; +import {constants} from './constants'; + +export const web3Factory = { + create(): Web3 { + const provider = new ProviderEngine(); + const rpcUrl = `http://${constants.RPC_HOST}:${constants.RPC_PORT}`; + provider.addProvider(new RpcSubprovider({ + rpcUrl, + })); + provider.start(); + const web3 = new Web3(); + web3.setProvider(provider); + return web3; + }, +}; -- cgit From a6da9cd07389b317624ad00a3cb73b75820687e1 Mon Sep 17 00:00:00 2001 From: Fabio Berger Date: Fri, 26 May 2017 17:47:00 +0200 Subject: Add missing return types --- test/utils/blockchain_clean.ts | 4 ++-- test/utils/rpc.ts | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'test') diff --git a/test/utils/blockchain_clean.ts b/test/utils/blockchain_clean.ts index 6468dbec7..18b7e3a5b 100644 --- a/test/utils/blockchain_clean.ts +++ b/test/utils/blockchain_clean.ts @@ -7,10 +7,10 @@ export class BlockchainClean { this.rpc = new RPC(); } // TODO: Check if running on TestRPC or on actual node, if actual node, re-deploy contracts instead - public async setupAsync() { + public async setupAsync(): Promise { this.snapshotId = await this.rpc.takeSnapshotAsync(); } - public async restoreAsync() { + public async restoreAsync(): Promise { const didRevert = await this.rpc.revertSnapshotAsync(this.snapshotId); if (!didRevert) { throw new Error(`Snapshot with id #${this.snapshotId} failed to revert`); diff --git a/test/utils/rpc.ts b/test/utils/rpc.ts index b689a938c..e331fa6d4 100644 --- a/test/utils/rpc.ts +++ b/test/utils/rpc.ts @@ -26,7 +26,7 @@ export class RPC { const didRevert = await this.sendAsync(payload); return didRevert; } - private toPayload(method: string, params: any[] = []) { + private toPayload(method: string, params: any[] = []): string { const payload = JSON.stringify({ id: this.id, method, @@ -35,7 +35,7 @@ export class RPC { this.id += 1; return payload; } - private async sendAsync(payload: string) { + private async sendAsync(payload: string): Promise { const opts = { method: 'POST', uri: `http://${this.host}:${this.port}`, -- cgit From aa3ae700b0a971296b84c3c4290031e566005a1f Mon Sep 17 00:00:00 2001 From: Fabio Berger Date: Fri, 26 May 2017 17:49:26 +0200 Subject: remove stray console log --- test/contract_wrapper_test.ts | 1 - 1 file changed, 1 deletion(-) (limited to 'test') diff --git a/test/contract_wrapper_test.ts b/test/contract_wrapper_test.ts index 65eceb827..db8f9d103 100644 --- a/test/contract_wrapper_test.ts +++ b/test/contract_wrapper_test.ts @@ -92,7 +92,6 @@ describe('ExchangeWrapper', () => { }); it('should return true if the signature does pertain to the dataHex & address', async () => { const isValid = await exchangeWrapper.isValidSignatureAsync(dataHex, signature, address); - console.log('isValid', isValid); expect(isValid).to.be.true; }); }); -- cgit From badd4a98e9f604b81cff1d6d52086b63d500bd64 Mon Sep 17 00:00:00 2001 From: Fabio Berger Date: Fri, 26 May 2017 17:51:47 +0200 Subject: import reorder --- test/contract_wrapper_test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'test') diff --git a/test/contract_wrapper_test.ts b/test/contract_wrapper_test.ts index db8f9d103..f332956ad 100644 --- a/test/contract_wrapper_test.ts +++ b/test/contract_wrapper_test.ts @@ -1,8 +1,8 @@ import 'mocha'; import * as chai from 'chai'; import chaiAsPromised = require('chai-as-promised'); -import {web3Factory} from './utils/web3_factory'; import * as Web3 from 'web3'; +import {web3Factory} from './utils/web3_factory'; import {ExchangeWrapper} from '../src/ts/contract_wrappers/exchange_wrapper'; import {BlockchainClean} from './utils/blockchain_clean'; import {Web3Wrapper} from './../src/ts/web3_wrapper'; -- cgit From d5feb5fc792c54bcf4a3a029ddc404e95a5df166 Mon Sep 17 00:00:00 2001 From: Fabio Berger Date: Fri, 26 May 2017 18:01:54 +0200 Subject: rename BlockClean to BlockchainLifecycle and setupAsync to startAsync, restoreAsync to revertAsync --- test/contract_wrapper_test.ts | 8 ++++---- test/utils/blockchain_clean.ts | 19 ------------------- test/utils/blockchain_lifecycle.ts | 19 +++++++++++++++++++ 3 files changed, 23 insertions(+), 23 deletions(-) delete mode 100644 test/utils/blockchain_clean.ts create mode 100644 test/utils/blockchain_lifecycle.ts (limited to 'test') diff --git a/test/contract_wrapper_test.ts b/test/contract_wrapper_test.ts index f332956ad..67dae3a4e 100644 --- a/test/contract_wrapper_test.ts +++ b/test/contract_wrapper_test.ts @@ -4,12 +4,12 @@ import chaiAsPromised = require('chai-as-promised'); import * as Web3 from 'web3'; import {web3Factory} from './utils/web3_factory'; import {ExchangeWrapper} from '../src/ts/contract_wrappers/exchange_wrapper'; -import {BlockchainClean} from './utils/blockchain_clean'; +import {BlockchainLifecycle} from './utils/blockchain_lifecycle'; import {Web3Wrapper} from './../src/ts/web3_wrapper'; const expect = chai.expect; chai.use(chaiAsPromised); -const blockchainClean = new BlockchainClean(); +const blockchainLifecycle = new BlockchainLifecycle(); describe('ExchangeWrapper', () => { let web3Wrapper: Web3Wrapper; @@ -20,10 +20,10 @@ describe('ExchangeWrapper', () => { exchangeWrapper = new ExchangeWrapper(web3Wrapper); }); beforeEach(async () => { - await blockchainClean.setupAsync(); + await blockchainLifecycle.startAsync(); }); afterEach(async () => { - await blockchainClean.restoreAsync(); + await blockchainLifecycle.revertAsync(); }); describe('#isValidSignatureAsync', () => { // The Exchange smart contract `isValidSignature` method only validates orderHashes and assumes diff --git a/test/utils/blockchain_clean.ts b/test/utils/blockchain_clean.ts deleted file mode 100644 index 18b7e3a5b..000000000 --- a/test/utils/blockchain_clean.ts +++ /dev/null @@ -1,19 +0,0 @@ -import {RPC} from './rpc'; - -export class BlockchainClean { - private rpc: RPC; - private snapshotId: number; - constructor() { - this.rpc = new RPC(); - } - // TODO: Check if running on TestRPC or on actual node, if actual node, re-deploy contracts instead - public async setupAsync(): Promise { - this.snapshotId = await this.rpc.takeSnapshotAsync(); - } - public async restoreAsync(): Promise { - const didRevert = await this.rpc.revertSnapshotAsync(this.snapshotId); - if (!didRevert) { - throw new Error(`Snapshot with id #${this.snapshotId} failed to revert`); - } - } -}; diff --git a/test/utils/blockchain_lifecycle.ts b/test/utils/blockchain_lifecycle.ts new file mode 100644 index 000000000..f7342b680 --- /dev/null +++ b/test/utils/blockchain_lifecycle.ts @@ -0,0 +1,19 @@ +import {RPC} from './rpc'; + +export class BlockchainLifecycle { + private rpc: RPC; + private snapshotId: number; + constructor() { + this.rpc = new RPC(); + } + // TODO: Check if running on TestRPC or on actual node, if actual node, re-deploy contracts instead + public async startAsync(): Promise { + this.snapshotId = await this.rpc.takeSnapshotAsync(); + } + public async revertAsync(): Promise { + const didRevert = await this.rpc.revertSnapshotAsync(this.snapshotId); + if (!didRevert) { + throw new Error(`Snapshot with id #${this.snapshotId} failed to revert`); + } + } +}; -- cgit From 4c3c1d049b0d6dd147a56b3ce9e6ccc17686acf1 Mon Sep 17 00:00:00 2001 From: Fabio Berger Date: Fri, 26 May 2017 18:08:50 +0200 Subject: improve comment --- test/utils/blockchain_lifecycle.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'test') diff --git a/test/utils/blockchain_lifecycle.ts b/test/utils/blockchain_lifecycle.ts index f7342b680..68e169ac0 100644 --- a/test/utils/blockchain_lifecycle.ts +++ b/test/utils/blockchain_lifecycle.ts @@ -6,7 +6,8 @@ export class BlockchainLifecycle { constructor() { this.rpc = new RPC(); } - // TODO: Check if running on TestRPC or on actual node, if actual node, re-deploy contracts instead + // TODO: In order to run these tests on an actual node, we should check if we are running against + // TestRPC, if so, use snapshots, otherwise re-deploy contracts before every test public async startAsync(): Promise { this.snapshotId = await this.rpc.takeSnapshotAsync(); } -- cgit