update test_app tests

lib/tests/run_tests.js

@@ -22,6 +22,7 @@ function getFilesFromDir(filePath, cb) {
 
 module.exports = {
   run: function (filePath) {
+    const start = Date.now();
     process.env.isTest = true;
     let failures = 0;
     if (!filePath) {
@@ -82,11 +83,15 @@ module.exports = {
         process.exit(1);
       }
       if (failures) {
-        console.error(`Total number of failures: ${failures}`.red);
+        console.error(` > Total number of failures: ${failures}`.red.bold);
+      } else {
+        console.log(' > All tests passed'.green.bold);
       }
 
       // Clean contracts folder for next test run
       fs.remove('.embark/contracts', (_err) => {
+        const end = Date.now();
+        console.log('Total time', end - start);
         process.exit(failures);
       });
     });

test_apps/test_app/test/another_storage_spec.js

@@ -1,21 +1,24 @@
-contract("AnotherStorage", function() {
+/*global contract, config, it, embark*/
-  this.timeout(0);
+const assert = require('assert');
-  before(function(done) {
+const AnotherStorage = embark.require('Embark/contracts/AnotherStorage');
-    this.timeout(0);
+const SimpleStorage = embark.require('Embark/contracts/SimpleStorage');
-    var contractsConfig = {
+
+config({
+  contracts: {
     "SimpleStorage": {
       args: [100]
     },
     "AnotherStorage": {
       args: ["$SimpleStorage"]
     }
-    };
+  }
-    EmbarkSpec.deployAll(contractsConfig, () => { done() });
 });
 
+contract("AnotherStorage", function() {
+  this.timeout(0);
+
   it("set SimpleStorage address", async function() {
     let result = await AnotherStorage.methods.simpleStorageAddress().call();
     assert.equal(result.toString(), SimpleStorage.options.address);
   });
-
 });

test_apps/test_app/test/array_references_spec.js

@@ -1,8 +1,11 @@
-contract("SomeContract", function() {
+/*global contract, config, it, embark*/
-  this.timeout(0);
+const assert = require('assert');
-  before(function(done) {
+const SomeContract = embark.require('Embark/contracts/SomeContract');
-    this.timeout(0);
+const SimpleStorage = embark.require('Embark/contracts/SimpleStorage');
-    var contractsConfig = {
+const MyToken2 = embark.require('Embark/contracts/MyToken2');
+
+config({
+  contracts: {
     "SimpleStorage": {
       args: [100]
     },
@@ -20,18 +23,20 @@ contract("SomeContract", function() {
         100
       ]
     }
-    };
+  }
-    EmbarkSpec.deployAll(contractsConfig, () => { done() });
 });
 
+contract("SomeContract", function() {
+  this.timeout(0);
+
   it("set MyToken2 address", async function() {
     let address = await SomeContract.methods.addr_1().call();
-    assert.equal(address, MyToken2.options.address);
+    assert.strictEqual(address, MyToken2.options.address);
   });
 
   it("set SimpleStorage address", async function() {
     let address = await SomeContract.methods.addr_2().call();
-    assert.equal(address, SimpleStorage.options.address);
+    assert.strictEqual(address, SimpleStorage.options.address);
   });
 
 });

test_apps/test_app/test/lib_test_spec.js

@@ -1,7 +1,9 @@
-contract("Test", function() {
+/*global contract, config, it, embark*/
-  before(function(done) {
+const assert = require('assert');
-    this.timeout(0);
+const Test2 = embark.require('Embark/contracts/Test2');
-    var contractsConfig = {
+
+config({
+  contracts: {
     "Test2": {
     },
     "ZAMyLib": {
@@ -9,14 +11,13 @@ contract("Test", function() {
     "ZAMyLib2": {
       "deploy": true
     }
-    };
+  }
-
-    EmbarkSpec.deployAll(contractsConfig, () => { done() });
 });
 
+contract("Test", function() {
   it("should call library correctly", async function() {
     let result = await Test2.methods.testAdd().call();
-    assert.equal(result, 3);
+    assert.strictEqual(parseInt(result, 10), 3);
   });
 
 });

test_apps/test_app/test/plugin_storage_spec.js

@@ -1,23 +1,23 @@
-/*global contract, before, EmbarkSpec, PluginStorage, SimpleStorage, it*/
+/*global contract, config, it, embark*/
 const assert = require('assert');
+const PluginStorage = embark.require('Embark/contracts/PluginStorage');
+const SimpleStorage = embark.require('Embark/contracts/SimpleStorage');
 
-contract("PluginSimpleStorage", function () {
+config({
-  this.timeout(0);
+  contracts: {
-
-  before((done) => {
-    const contractsConfig = {
     "SimpleStorage": {
       args: [100]
     },
     "PluginStorage": {
       args: ["$SimpleStorage"]
     }
-    };
+  }
-    EmbarkSpec.deployAll(contractsConfig, () => {
-      done();
-    });
 });
 
+
+contract("PluginSimpleStorage", function () {
+  this.timeout(0);
+
   it("set SimpleStorage address", async function () {
     let result = await PluginStorage.methods.simpleStorageAddress().call();
     assert.equal(result.toString(), SimpleStorage.options.address);

test_apps/test_app/test/simple_storage_spec.js

@@ -1,31 +1,26 @@
+/*global contract, config, it, embark*/
+const assert = require('assert');
+const SimpleStorage = embark.require('Embark/contracts/SimpleStorage');
 
-contract("SimpleStorage", function() {
+config({
-
+  contracts: {
-  this.timeout(0);
-  before(function(done) {
-    this.timeout(0);
-
-    //config({
-    //  node: "http://localhost:8545"
-    //});
-
-    var contractsConfig = {
     "SimpleStorage": {
       args: [100]
     }
-    };
+  }
-    EmbarkSpec.deployAll(contractsConfig, () => { done() });
 });
 
+contract("SimpleStorage", function () {
+  this.timeout(0);
+
   it("should set constructor value", async function () {
     let result = await SimpleStorage.methods.storedData().call();
-    assert.equal(result, 100);
+    assert.strictEqual(parseInt(result, 10), 100);
   });
 
   it("set storage value", async function () {
     await SimpleStorage.methods.set(150).send();
     let result = await SimpleStorage.methods.get().call();
-    assert.equal(result, 499650);
+    assert.strictEqual(parseInt(result, 10), 499650);
   });
-
 });

test_apps/test_app/test/token_spec.js

@@ -1,86 +1,82 @@
-/*global describe, it, before*/
+/*global describe, config, it, embark*/
+const assert = require('assert');
+const Token = embark.require('Embark/contracts/Token');
+const MyToken = embark.require('Embark/contracts/MyToken');
+const MyToken2 = embark.require('Embark/contracts/MyToken2');
+const AlreadyDeployedToken = embark.require('Embark/contracts/AlreadyDeployedToken');
+const Test = embark.require('Embark/contracts/Test');
 
-describe("Token", function() {
+config({
-
+  contracts: {
-  this.timeout(0);
+    ZAMyLib: {},
-  before(function(done) {
+    SimpleStorage: {
-    this.timeout(0);
-
-    //config({
-    //  node: "http://localhost:8545"
-    //});
-
-    var contractsConfig = {
-      "ZAMyLib": {
-      },
-      "SimpleStorage": {
       args: [100]
     },
-      "AnotherStorage": {
+    AnotherStorage: {
       args: ["$SimpleStorage"]
     },
-      "Token": {
+    Token: {
       deploy: false,
       args: [1000]
     },
-      "MyToken": {
+    MyToken: {
       instanceOf: "Token"
     },
-      "MyToken2": {
+    MyToken2: {
       instanceOf: "Token",
       args: [2000]
     },
-      "AlreadyDeployedToken": {
+    AlreadyDeployedToken: {
-        "address": "0xCAFECAFECAFECAFECAFECAFECAFECAFECAFECAFE",
+      address: "0xCAFECAFECAFECAFECAFECAFECAFECAFECAFECAFE",
       instanceOf: "Token"
     },
-      "Test": {
+    Test: {
-        onDeploy: [
+      onDeploy: ["Test.methods.changeAddress('$MyToken').send()"]
-          "Test.methods.changeAddress('$MyToken').send()"
-        ]
     },
-      "ContractArgs": {
+    ContractArgs: {
-        "args": {
+      args: {
-          "initialValue": 123,
+        initialValue: 123,
-          "_addresses": ["$MyToken2", "$SimpleStorage"]
+        _addresses: ["$MyToken2", "$SimpleStorage"]
       }
     },
-      "SomeContract": {
+    SomeContract: {
-        "args": [
+      args: [
         ["$MyToken2", "$SimpleStorage"],
         100
       ]
     }
-    };
+  }
-    EmbarkSpec.deployAll(contractsConfig, () => { done() });
 });
 
+describe("Token", function () {
+  this.timeout(0);
+
   it("not deploy Token", function () {
-    assert.equal(Token.address, "");
+    assert.strictEqual(Token.address, undefined);
   });
 
-  it("not deploy MyToken and MyToken2", function() {
+  it("should deploy MyToken and MyToken2", function () {
-    assert.notEqual(MyToken.address, "");
+    assert.ok(MyToken.options.address);
-    assert.notEqual(MyToken2.address, "");
+    assert.ok(MyToken2.options.address);
   });
 
   it("set MyToken Balance correctly", async function () {
     let result = await MyToken.methods._supply().call();
-    assert.equal(result, 1000);
+    assert.strictEqual(parseInt(result, 10), 1000);
   });
 
   it("set MyToken2 Balance correctly", async function () {
     let result = await MyToken2.methods._supply().call();
-    assert.equal(result, 2000);
+    assert.strictEqual(parseInt(result, 10), 2000);
   });
 
   it("get right address", function () {
-    assert.equal(AlreadyDeployedToken.address, "0xCAFECAFECAFECAFECAFECAFECAFECAFECAFECAFE");
+    assert.strictEqual(AlreadyDeployedToken.options.address.toLowerCase(),
+      "0xCAFECAFECAFECAFECAFECAFECAFECAFECAFECAFE".toLowerCase());
   });
 
   it("should use onDeploy", async function () {
     let result = await Test.methods.addr().call();
-    assert.equal(result, MyToken.address)
+    assert.strictEqual(result, MyToken.options.address);
   });
-
 });