build only once

lib/contracts/deploy_manager.js

@@ -19,7 +19,11 @@ class DeployManager {
     this.onlyCompile = options.onlyCompile !== undefined ? options.onlyCompile : false;
   }
 
-  deployContracts(done) {
+  deployContracts(compileOnlyIfNeeded, done) {
+    if (typeof compileOnlyIfNeeded === 'function') {
+      done = compileOnlyIfNeeded;
+      compileOnlyIfNeeded = false;
+    }
     let self = this;
 
     if (self.blockchainConfig === {} || self.blockchainConfig.enabled === false) {
@@ -30,6 +34,13 @@ class DeployManager {
 
     async.waterfall([
       function buildContracts(callback) {
+        if (compileOnlyIfNeeded) {
+          if (self.contractsManager.compiledContracts && Object.keys(self.contractsManager.compiledContracts).length) {
+            // Contracts have already been compiled
+            return callback();
+          }
+        }
+        console.log('compiling');
         self.contractsManager.deployOnlyOnConfig = self.deployOnlyOnConfig; // temporary, should refactor
         self.contractsManager.build(() => {
           callback();

lib/tests/run_tests.js

@@ -26,9 +26,6 @@ module.exports = {
     if (!filePath) {
       filePath = 'test/';
     }
-    let configOptions = {
-      gasPrice: 1
-    };
 
     async.waterfall([
       function getFiles(next) {
@@ -48,8 +45,6 @@ module.exports = {
         });
       },
       function setupGlobalNamespace(next) {
-        global.assert = require('assert');
-
         // TODO put default config
         const test = new Test();
         global.embark = test;
@@ -69,7 +64,7 @@ module.exports = {
         process.exit(1);
       }
       // Run the tests.
-      let runner = mocha.run(function(failures) {
+      mocha.run(function(failures) {
         // Clean contracts folder for next test run
         fs.remove('.embark/contracts', (_err) => {
           process.on('exit', function () {
@@ -78,12 +73,6 @@ module.exports = {
           process.exit();
         });
       });
-
-      runner.on('suite', function() {
-        global.assert = require('assert');
-        global.EmbarkSpec = new Test({simulatorOptions: configOptions});
-        global.web3 = global.EmbarkSpec.web3;
-      });
     });
   }
 };

lib/tests/test.js

@@ -1,7 +1,9 @@
+const async = require('async');
 const Engine = require('../core/engine.js');
 const TestLogger = require('./test_logger.js');
 const Web3 = require('web3');
 const utils = require('../utils/utils');
+const constants = require('../constants');
 
 function getSimulator() {
   try {
@@ -32,15 +34,10 @@ class Test {
       this.sim = getSimulator();
       this.web3.setProvider(this.sim.provider(this.simOptions));
     }
-  }
-
-  config(options) {
-    this.options = utils.recursiveMerge(this.options, options);
-    this.simOptions = this.options.simulatorOptions || {};
 
     this.engine = new Engine({
       env: this.options.env || 'test',
-      // TODO: confi will need to detect if this is a obj
+      // TODO: config will need to detect if this is a obj
       embarkConfig: this.options.embarkConfig || 'embark.json',
       interceptLogs: false
     });
@@ -49,12 +46,69 @@ class Test {
       logger: new TestLogger({logLevel: 'debug'})
     });
 
-    if (this.simOptions.node) {
-      this.web3.setProvider(new this.web3.providers.HttpProvider(this.simOptions.node));
-    } else {
-      this.sim = getSimulator();
-      this.web3.setProvider(this.sim.provider(this.simOptions));
-    }
+    this.engine.startService("libraryManager");
+    this.engine.startService("codeRunner");
+    this.engine.startService("web3", {
+      web3: this.web3
+    });
+    this.engine.startService("deployment", {
+      trackContracts: false
+    });
+    this.engine.startService("codeGenerator");
+  }
+
+  config(options, callback) {
+    this.options = utils.recursiveMerge(this.options, options);
+    this.simOptions = this.options.simulatorOptions || {};
+
+    this._deploy(options, (err, accounts) => {
+      if (err) {
+        console.error(err);
+        return callback(err);
+      }
+      callback(null, accounts);
+    });
+  }
+
+  _deploy(config, cb) {
+    const self = this;
+    async.waterfall([
+      function getConfig(callback) {
+        let _versions_default = self.engine.config.contractsConfig.versions;
+        self.engine.config.contractsConfig = {contracts: config.contracts, versions: _versions_default};
+        callback();
+      },
+      function reloadConfig(callback) {
+        self.engine.events.emit(constants.events.contractConfigChanged, self.engine.config.contractsConfig);
+        callback();
+      },
+      function deploy(callback) {
+        self.engine.deployManager.gasLimit = 6000000;
+        self.engine.contractsManager.gasLimit = 6000000;
+        self.engine.deployManager.fatalErrors = true;
+        self.engine.deployManager.deployOnlyOnConfig = true;
+        self.engine.deployManager.deployContracts(true, function(err, _result) {
+          if (err) {
+            callback(err);
+          }
+          callback();
+        });
+      }
+    ], function(err) {
+      if (err) {
+        console.log(__('terminating due to error'));
+        cb(err);
+      }
+      // this should be part of the waterfall and not just something done at the
+      // end
+      self.web3.eth.getAccounts(function(err, accounts) {
+        if (err) {
+          throw new Error(err);
+        }
+        self.web3.eth.defaultAccount = accounts[0];
+        cb(null, accounts);
+      });
+    });
   }
 }
 

lib/tests/test_logger.js

@@ -11,7 +11,7 @@ class TestLogger {
 
   logFunction() {
     this.logs.push(arguments);
-    //console.dir(arguments[0]);
+    console.log(...arguments);
   }
 
   contractsState() {