Update function & expression tests

test/units/expressions.js

@@ -1,24 +1,14 @@
-/* eslint-env node, mocha */
-
-/*const solc = require('solc');
-const getInstrumentedVersion = require('./../lib/instrumentSolidity.js');
-const util = require('./util/util.js');
-const path = require('path');
+const assert = require('assert');
+const util = require('./../util/util.js');
 
 describe('generic expressions', () => {
-  const filePath = path.resolve('./test.sol');
-
   it('should compile after instrumenting a single binary expression', () => {
-    const contract = util.getCode('expressions/single-binary-expression.sol');
-    const info = getInstrumentedVersion(contract, filePath);
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('expressions/single-binary-expression');
+    util.report(info.solcOutput.errors);
   });
 
   it('should compile after instrumenting a new expression', () => {
-    const contract = util.getCode('expressions/new-expression.sol');
-    const info = getInstrumentedVersion(contract, filePath);
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('expressions/new-expression');
+    util.report(info.solcOutput.errors);
+  });
 });
-});*/

test/units/function.js

@@ -1,186 +1,159 @@
-/*const solc = require('solc');
-const getInstrumentedVersion = require('./../lib/instrumentSolidity.js');
-const util = require('./util/util.js');
-const path = require('path');
-const CoverageMap = require('./../lib/coverageMap');
-const vm = require('./util/vm');
 const assert = require('assert');
+const util = require('./../util/util.js');
+
+const ganache = require('ganache-core');
+const Coverage = require('./../../lib/coverage');
 
 describe('function declarations', () => {
-  const filePath = path.resolve('./test.sol');
-  const pathPrefix = './';
+  let coverage;
+  let provider;
+  let collector;
+
+  before(async () => ({ provider, collector } = await util.initializeProvider(ganache)));
+  beforeEach(() => coverage = new Coverage());
+  after((done) => provider.close(done));
 
   it('should compile after instrumenting an ordinary function declaration', () => {
-    const contract = util.getCode('function/function.sol');
-    const info = getInstrumentedVersion(contract, 'test.sol');
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('function/function');
+    util.report(info.solcOutput.errors);
   });
 
   it('should compile after instrumenting an abstract function declaration', () => {
-    const contract = util.getCode('function/abstract.sol');
-    const info = getInstrumentedVersion(contract, 'test.sol');
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('function/abstract');
+    util.report(info.solcOutput.errors);
   });
 
   it('should compile after instrumenting a function declaration with an empty body', () => {
-    const contract = util.getCode('function/empty-body.sol');
-    const info = getInstrumentedVersion(contract, 'test.sol');
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('function/empty-body');
+    util.report(info.solcOutput.errors);
   });
 
   it('should compile after instrumenting lots of declarations in row', () => {
-    const contract = util.getCode('function/multiple.sol');
-    const info = getInstrumentedVersion(contract, 'test.sol');
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('function/multiple');
+    util.report(info.solcOutput.errors);
   });
 
   it('should compile after instrumenting a new->constructor-->method chain', () => {
-    const contract = util.getCode('function/chainable-new.sol');
-    const info = getInstrumentedVersion(contract, 'test.sol');
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('function/chainable-new');
+    util.report(info.solcOutput.errors);
   });
 
   it('should compile after instrumenting a constructor call that chains to a method call', () => {
-    const contract = util.getCode('function/chainable.sol');
-    const info = getInstrumentedVersion(contract, 'test.sol');
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('function/chainable');
+    util.report(info.solcOutput.errors);
   });
 
   it('should compile after instrumenting a function with calldata keyword', () => {
-    const contract = util.getCode('function/calldata.sol');
-    const info = getInstrumentedVersion(contract, 'test.sol');
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('function/calldata');
+    util.report(info.solcOutput.errors);
   });
 
   it('should compile after instrumenting a constructor-->method-->value chain', () => {
-    const contract = util.getCode('function/chainable-value.sol');
-    const info = getInstrumentedVersion(contract, 'test.sol');
-    const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract)));
-    util.report(output.errors);
+    const info = util.instrumentAndCompile('function/chainable-value');
+    util.report(info.solcOutput.errors);
   });
 
-  it('should cover a simple invoked function call', done => {
-    const contract = util.getCode('function/function-call.sol');
-    const info = getInstrumentedVersion(contract, filePath);
-    const coverage = new CoverageMap();
-    coverage.addContract(info, filePath);
+  it('should cover a simple invoked function call', async function() {
+    const contract = await util.bootstrapCoverage('function/function-call', provider, collector);
+    coverage.addContract(contract.instrumented, util.filePath);
+    await contract.instance.a();
+    const mapping = coverage.generate(contract.data, util.pathPrefix);
 
-    vm.execute(info.contract, 'a', []).then(events => {
-      const mapping = coverage.generate(events, pathPrefix);
-      assert.deepEqual(mapping[filePath].l, {
+    assert.deepEqual(mapping[util.filePath].l, {
       7: 1,
     });
-      assert.deepEqual(mapping[filePath].b, {});
-      assert.deepEqual(mapping[filePath].s, {
+    assert.deepEqual(mapping[util.filePath].b, {});
+    assert.deepEqual(mapping[util.filePath].s, {
       1: 1,
     });
-      assert.deepEqual(mapping[filePath].f, {
+    assert.deepEqual(mapping[util.filePath].f, {
       1: 1,
       2: 1,
     });
-      done();
-    }).catch(done);
   });
 
-  it('should cover a modifier used on a function', done => {
-    const contract = util.getCode('function/modifier.sol');
-    const info = getInstrumentedVersion(contract, filePath);
-    const coverage = new CoverageMap();
-    coverage.addContract(info, filePath);
+  it('should cover a modifier used on a function', async function() {
+    const contract = await util.bootstrapCoverage('function/modifier', provider, collector);
+    coverage.addContract(contract.instrumented, util.filePath);
+    await contract.instance.a(0);
+    const mapping = coverage.generate(contract.data, util.pathPrefix);
 
-    vm.execute(info.contract, 'a', [0]).then(events => {
-      const mapping = coverage.generate(events, pathPrefix);
-      assert.deepEqual(mapping[filePath].l, {
+    assert.deepEqual(mapping[util.filePath].l, {
       5: 1, 6: 1, 9: 1,
     });
-      assert.deepEqual(mapping[filePath].b, {});
-      assert.deepEqual(mapping[filePath].s, {
+    assert.deepEqual(mapping[util.filePath].b, {});
+    assert.deepEqual(mapping[util.filePath].s, {
       1: 1
     });
-      assert.deepEqual(mapping[filePath].f, {
+    assert.deepEqual(mapping[util.filePath].f, {
       1: 1,
       2: 1,
     });
-      done();
-    }).catch(done);
   });
 
-  it('should cover a constructor that uses the `constructor` keyword', done  => {
-    const contract = util.getCode('function/constructor-keyword.sol');
-    const info = getInstrumentedVersion(contract, filePath);
-    const coverage = new CoverageMap();
-    coverage.addContract(info, filePath);
+  it('should cover a constructor that uses the `constructor` keyword', async function() {
+    const contract = await util.bootstrapCoverage('function/constructor-keyword', provider, collector);
+    coverage.addContract(contract.instrumented, util.filePath);
+    await contract.instance.a();
+    const mapping = coverage.generate(contract.data, util.pathPrefix);
 
-    vm.execute(info.contract, 'a', []).then(events => {
-      const mapping = coverage.generate(events, pathPrefix);
-      assert.deepEqual(mapping[filePath].l, {
+    assert.deepEqual(mapping[util.filePath].l, {
       6: 1, 11: 1
     });
-      assert.deepEqual(mapping[filePath].b, {});
-      assert.deepEqual(mapping[filePath].s, {
+    assert.deepEqual(mapping[util.filePath].b, {});
+    assert.deepEqual(mapping[util.filePath].s, {
       1: 1, 2: 1
     });
-      assert.deepEqual(mapping[filePath].f, {
+    assert.deepEqual(mapping[util.filePath].f, {
       1: 1,
       2: 1,
     });
-      done();
-    }).catch(done);
   });
 
-  it('should cover a constructor call that chains to a method call', done => {
-    const contract = util.getCode('function/chainable.sol');
-    const info = getInstrumentedVersion(contract, filePath);
-    const coverage = new CoverageMap();
-    coverage.addContract(info, filePath);
   // We try and call a contract at an address where it doesn't exist and the VM
   // throws, but we can verify line / statement / fn coverage is getting mapped.
-    vm.execute(info.contract, 'a', []).then(events => {
-      const mapping = coverage.generate(events, pathPrefix);
-      assert.deepEqual(mapping[filePath].l, {
+  it('should cover a constructor call that chains to a method call', async function() {
+    const contract = await util.bootstrapCoverage('function/chainable', provider, collector);
+    coverage.addContract(contract.instrumented, util.filePath);
+
+    try { await contract.instance.a() } catch(err){}
+
+    const mapping = coverage.generate(contract.data, util.pathPrefix);
+
+    assert.deepEqual(mapping[util.filePath].l, {
       9: 1,
     });
-      assert.deepEqual(mapping[filePath].b, {});
-      assert.deepEqual(mapping[filePath].s, {
+    assert.deepEqual(mapping[util.filePath].b, {});
+    assert.deepEqual(mapping[util.filePath].s, {
       1: 1,
     });
-      assert.deepEqual(mapping[filePath].f, {
+    assert.deepEqual(mapping[util.filePath].f, {
       1: 0,
       2: 1,
     });
-      done();
-    }).catch(done);
   });
 
-  it('should cover a constructor call that chains to a method call', done => {
-    const contract = util.getCode('function/chainable-value.sol');
-    const info = getInstrumentedVersion(contract, filePath);
-    const coverage = new CoverageMap();
-    coverage.addContract(info, filePath);
   // The vm runs out of gas here - but we can verify line / statement / fn
   // coverage is getting mapped.
-    vm.execute(info.contract, 'a', []).then(events => {
-      const mapping = coverage.generate(events, pathPrefix);
-      assert.deepEqual(mapping[filePath].l, {
+  it('should cover a constructor call that chains to a method call', async function() {
+    const contract = await util.bootstrapCoverage('function/chainable-value', provider, collector);
+    coverage.addContract(contract.instrumented, util.filePath);
+
+    try { await contract.instance.a() } catch(err){}
+
+    const mapping = coverage.generate(contract.data, util.pathPrefix);
+
+    assert.deepEqual(mapping[util.filePath].l, {
       10: 1,
     });
-      assert.deepEqual(mapping[filePath].b, {});
-      assert.deepEqual(mapping[filePath].s, {
+    assert.deepEqual(mapping[util.filePath].b, {});
+    assert.deepEqual(mapping[util.filePath].s, {
       1: 1,
     });
-      assert.deepEqual(mapping[filePath].f, {
+    assert.deepEqual(mapping[util.filePath].f, {
       1: 0,
       2: 1,
     });
-      done();
-    }).catch(done);
   });
 });
-*/
+