add beforeEach; update tests

src/testRunner.js

@@ -3,8 +3,8 @@ var changeCase = require('change-case');
 
 function runTest(testName, testObject, testCallback, resultsCallback) {
   let runList = [];
-  let specialFunctions = ['beforeAll'];
-  let availableFunctions = testObject._jsonInterface.filter((x) => x.type === 'function').map((x) => x.name);
+  let specialFunctions = ['beforeAll', 'beforeEach'];
+  let availableFunctions = testObject._jsonInterface.reverse().filter((x) => x.type === 'function').map((x) => x.name);
   let testFunctions = testObject._jsonInterface.filter((x) => specialFunctions.indexOf(x.name) < 0 && x.type === 'function');
 
   if (availableFunctions.indexOf("beforeAll") >= 0) {

tests/examples_1/simple_storage.sol

+pragma solidity ^0.4.7;
+contract SimpleStorage {
+  uint public storedData;
+
+  function SimpleStorage() public {
+    storedData = 100;
+  }
+
+  function set(uint x) public {
+    storedData = x;
+  }
+
+  function get() public view returns (uint retVal) {
+    return storedData;
+  }
+
+}

tests/examples_1/simple_storage_test.sol

+pragma solidity ^0.4.7;
+import "./tests.sol";
+import "./simple_storage.sol";
+
+contract MyTest {
+  SimpleStorage foo;
+
+  function beforeAll() {
+    foo = new SimpleStorage();
+  }
+
+  function initialValueShouldBe100() public constant returns (bool) {
+    //return Assert.equal(foo.get(), 100, "initial value is not correct");
+    return foo.get() == 100;
+  }
+
+  function initialValueShouldBe200() public constant returns (bool) {
+    //return Assert.equal(foo.get(), 200, "initial value is not correct");
+    return foo.get() == 200;
+  }
+
+}
+

tests/examples_2/simple_storage.sol

+pragma solidity ^0.4.7;
+contract SimpleStorage {
+  uint public storedData;
+
+  function SimpleStorage() public {
+    storedData = 100;
+  }
+
+  function set(uint x) public {
+    storedData = x;
+  }
+
+  function get() public view returns (uint retVal) {
+    return storedData;
+  }
+
+}

tests/examples_2/simple_storage_test.sol

+pragma solidity ^0.4.7;
+import "./tests.sol";
+import "./simple_storage.sol";
+
+contract MyTest {
+  SimpleStorage foo;
+  uint i = 0;
+
+  function beforeEach() {
+    foo = new SimpleStorage();
+    if (i == 1) {
+      foo.set(200);
+    }
+    i += 1;
+  }
+
+  function initialValueShouldBe100() public constant returns (bool) {
+    //return Assert.equal(foo.get(), 100, "initial value is not correct");
+    return foo.get() == 100;
+  }
+
+  function initialValueShouldBe200() public constant returns (bool) {
+    //return Assert.equal(foo.get(), 200, "initial value is not correct");
+    return foo.get() == 200;
+  }
+
+}
+

tests/testRunner.js

@@ -23,20 +23,16 @@ function compileAndDeploy(filename, callback) {
 }
 
 describe('testRunner', function() {
-  describe("simple test", function() {
-    let filename = 'examples/simple_storage_test.sol'
+  describe("test with beforeAll", function() {
+    let filename = 'tests/examples_1/simple_storage_test.sol'
     let tests = [], results = {};
 
     before(function(done) {
       compileAndDeploy(filename, function(_err, contracts) {
-        var testCallback = function() {
-          console.log("testCallback");
-          console.dir(arguments);
-          tests.push(arguments);
+        var testCallback = function(test) {
+          tests.push(test);
         }
         var resultsCallback = function(_err, _results) {
-          console.log("resultsCallback");
-          console.dir(_results);
           results = _results;
           done();
         }
@@ -48,9 +44,53 @@ describe('testRunner', function() {
       assert.equal(results.passingNum, 1)
     });
 
-    it('should 1 passing test', function() {
+    it('should 1 failing test', function() {
       assert.equal(results.failureNum, 1)
     });
 
+    it('should returns 3 messages', function() {
+      assert.deepEqual(tests, [
+        { type: 'contract', value: 'tests/examples_1/simple_storage_test.sol' },
+        { type: 'testPass', value: 'Initial value should be100' },
+        { type: 'testFailure', value: 'Initial value should be200' }
+      ]);
+    });
+
   });
+
+  describe("test with beforeEach", function() {
+    let filename = 'tests/examples_2/simple_storage_test.sol'
+    let tests = [], results = {};
+
+    before(function(done) {
+      compileAndDeploy(filename, function(_err, contracts) {
+        var testCallback = function(test) {
+          tests.push(test);
+        }
+        var resultsCallback = function(_err, _results) {
+          results = _results;
+          done();
+        }
+        TestRunner.runTest(filename, contracts.MyTest, testCallback, resultsCallback);
+      });
+    });
+
+    it('should 2 passing tests', function() {
+      assert.equal(results.passingNum, 2)
+    });
+
+    it('should 0 failing tests', function() {
+      assert.equal(results.failureNum, 0)
+    });
+
+    it('should returns 3 messages', function() {
+      assert.deepEqual(tests, [
+        { type: 'contract', value: 'tests/examples_2/simple_storage_test.sol' },
+        { type: 'testPass', value: 'Initial value should be100' },
+        { type: 'testPass', value: 'Initial value should be200' }
+      ]);
+    });
+
+  });
+
 });