t2 run/push: provide node process.versions, passed to pre-compiled mo…

…dule resolution. Fixes gh-843

Signed-off-by: Rick Waldron <waldron.rick@gmail.com>

lib/controller.js

@@ -1005,7 +1005,7 @@ controller.tesselEnvVersions = opts => {
           // Figure out what commit SHA is running on it
           var firmwareVersion = updates.findBuild(builds, 'sha', versionSha).version;
 
-          return tessel.fetchCurrentNodeVersion()
+          return tessel.fetchNodeProcessVersion()
             .then(nodeVersion => {
               log.info(output('CLI', cliVersion));
               log.info(output('Firmware', firmwareVersion));

lib/tessel/deploy.js

@@ -118,6 +118,11 @@ Tessel.prototype.memoryInfo = function() {
  * @return {Promise}
  */
 Tessel.prototype.deploy = function(opts) {
+
+  if (typeof opts.tessel === 'undefined') {
+    opts.tessel = this;
+  }
+
   // Only an _explicit_ `true` will set push mode
   var isPush = opts.push === true;
   var entryPoint = opts.entryPoint;
@@ -129,7 +134,7 @@ Tessel.prototype.deploy = function(opts) {
   return new Promise((resolve, reject) => {
     // Stop running an existing applications
     return this.simpleExec(commands.app.stop())
-      .catch((error) => {
+      .catch(error => {
         // This _must_ be inline
         if (error.length > 0) {
           throw new Error(`Remote command: ${commands.app.stop().join(' ')} failed.`);
@@ -316,6 +321,11 @@ exportables.endOfLookup = function(pushdir) {
 };
 
 exportables.sendBundle = function(tessel, opts) {
+
+  if (typeof opts.tessel === 'undefined') {
+    opts.tessel = tessel;
+  }
+
   return new Promise((resolve, reject) => {
     // Execute the remote untar process command
     tessel.connection.exec(commands.untarStdin(Tessel.REMOTE_RUN_PATH), (err, remoteProcess) => {

lib/tessel/deployment/javascript.js

@@ -379,7 +379,11 @@ exportables.injectBinaryModules = function(globRoot, tempBundlePath, options) {
 };
 
 exportables.preBundle = function(options) {
-  return exportables.resolveBinaryModules(options);
+  return options.tessel.fetchNodeProcessVersions()
+    .then(versions => {
+      options.tessel.versions = versions;
+      return exportables.resolveBinaryModules(options);
+    });
 };
 
 exportables.tarBundle = function(options) {

lib/tessel/version.js

@@ -10,10 +10,15 @@ var Tessel = require('./tessel');
 /*
   Gathers node version.
 */
-Tessel.prototype.fetchCurrentNodeVersion = function() {
+Tessel.prototype.fetchNodeProcessVersion = function() {
   return this.simpleExec(['node', '--version'])
     .then(version => {
       // strip the `v` preceding the version
       return version.trim().substring(1);
     });
 };
+
+Tessel.prototype.fetchNodeProcessVersions = function() {
+  return this.simpleExec(['node', '-p', 'JSON.stringify(process.versions)'])
+    .then(versions => JSON.parse(versions.trim()));
+};

test/.jshintrc

@@ -75,6 +75,7 @@
     "Project": true,
     "Progress": true,
     "Promise": true,
+    "processVersions": true,
     "provision": true,
     "restore": true,
     "reference": true,

test/common/bootstrap.js

@@ -191,3 +191,14 @@ global.extract = function(bundle, callback) {
 
   parser.end(bundle);
 };
+
+global.processVersions = {
+  http_parser: '2.5.2',
+  node: '4.4.3',
+  v8: '4.5.103.35',
+  uv: '1.8.0',
+  zlib: '1.2.8',
+  ares: '1.10.1-DEV',
+  modules: '46',
+  openssl: '1.0.2d',
+};

test/unit/controller.js

@@ -378,7 +378,7 @@ exports['controller.tesselEnvVersions'] = {
       return Promise.resolve('9a85c84f5a03c715908921baaaa9e7397985bc7f');
     });
 
-    this.fetchCurrentNodeVersion = this.sandbox.stub(Tessel.prototype, 'fetchCurrentNodeVersion', () => {
+    this.fetchNodeProcessVersion = this.sandbox.stub(Tessel.prototype, 'fetchNodeProcessVersion', () => {
       return Promise.resolve('4.2.1');
     });
 
@@ -420,7 +420,7 @@ exports['controller.tesselEnvVersions'] = {
         // Get the firmware version
         test.equal(this.fetchCurrentBuildInfo.callCount, 1);
         // Execute `node --version` command on tessel
-        test.equal(this.fetchCurrentNodeVersion.callCount, 1);
+        test.equal(this.fetchNodeProcessVersion.callCount, 1);
         // Make sure we have some output
         test.equal(this.info.callCount, 3);
 
@@ -450,8 +450,8 @@ exports['controller.tesselEnvVersions'] = {
       return Promise.resolve('9a85c84f5a03c715908921baaaa9e7397985bc7f');
     });
 
-    this.fetchCurrentNodeVersion.restore();
-    this.fetchCurrentNodeVersion = this.sandbox.stub(Tessel.prototype, 'fetchCurrentNodeVersion', () => {
+    this.fetchNodeProcessVersion.restore();
+    this.fetchNodeProcessVersion = this.sandbox.stub(Tessel.prototype, 'fetchNodeProcessVersion', () => {
       return Promise.reject();
     });
 
@@ -464,7 +464,7 @@ exports['controller.tesselEnvVersions'] = {
         // Get the firmware version
         test.equal(this.fetchCurrentBuildInfo.callCount, 1);
         // Execute `node --version` command on tessel
-        test.equal(this.fetchCurrentNodeVersion.callCount, 1);
+        test.equal(this.fetchNodeProcessVersion.callCount, 1);
         // Make sure we have some output
         test.equal(this.info.callCount, 3);
 
@@ -494,8 +494,8 @@ exports['controller.tesselEnvVersions'] = {
       return Promise.reject();
     });
 
-    this.fetchCurrentNodeVersion.restore();
-    this.fetchCurrentNodeVersion = this.sandbox.stub(Tessel.prototype, 'fetchCurrentNodeVersion', () => {
+    this.fetchNodeProcessVersion.restore();
+    this.fetchNodeProcessVersion = this.sandbox.stub(Tessel.prototype, 'fetchNodeProcessVersion', () => {
       return Promise.resolve('4.2.1');
     });
 
@@ -508,7 +508,7 @@ exports['controller.tesselEnvVersions'] = {
         // Get the firmware version
         test.equal(this.fetchCurrentBuildInfo.callCount, 1);
         // Execute `node --version` command on tessel
-        test.equal(this.fetchCurrentNodeVersion.callCount, 0);
+        test.equal(this.fetchNodeProcessVersion.callCount, 0);
         // Make sure we have some output
         test.equal(this.info.callCount, 3);
 

test/unit/deploy.js

@@ -119,8 +119,8 @@ exports['Tessel.prototype.deploy'] = {
     this.push = sandbox.spy(deploy, 'push');
     this.createShellScript = sandbox.spy(deploy, 'createShellScript');
 
-    this.injectBinaryModules = sandbox.stub(deployment.js, 'injectBinaryModules', () => Promise.resolve());
-    this.resolveBinaryModules = sandbox.stub(deployment.js, 'resolveBinaryModules', () => Promise.resolve());
+    this.injectBinaryModules = sandbox.stub(deployment.js, 'injectBinaryModules').returns(Promise.resolve());
+    this.resolveBinaryModules = sandbox.stub(deployment.js, 'resolveBinaryModules').returns(Promise.resolve());
     this.tarBundle = sandbox.stub(deployment.js, 'tarBundle', function() {
       return new Promise(function(resolve) {
         resolve(jsCodeReference);
@@ -133,6 +133,8 @@ exports['Tessel.prototype.deploy'] = {
     this.tessel = TesselSimulator();
     this.end = sandbox.spy(this.tessel._rps.stdin, 'end');
 
+    this.fetchNodeProcessVersions = sandbox.stub(this.tessel, 'fetchNodeProcessVersions').returns(Promise.resolve(processVersions));
+
     this.pWrite = sandbox.stub(Preferences, 'write').returns(Promise.resolve());
 
 
@@ -382,7 +384,7 @@ exports['Tessel.prototype.deploy'] = {
             test.equal(err, undefined, 'We hit a catch statement that we should not have.');
           });
       });
-  }
+  },
 };
 
 exports['Tessel.prototype.restart'] = {

test/unit/deployment/javascript.js

@@ -38,6 +38,8 @@ exports['Deployment: JavaScript'] = {
     this.tessel = TesselSimulator();
     this.end = sandbox.spy(this.tessel._rps.stdin, 'end');
 
+    this.fetchNodeProcessVersions = sandbox.stub(this.tessel, 'fetchNodeProcessVersions').returns(Promise.resolve(processVersions));
+
     this.pWrite = sandbox.stub(Preferences, 'write').returns(Promise.resolve());
 
     this.spinnerStart = sandbox.stub(log.spinner, 'start');
@@ -1800,6 +1802,8 @@ exports['deploy.findProject'] = {
 exports['deploy.sendBundle, error handling'] = {
   setUp: function(done) {
     this.tessel = TesselSimulator();
+    this.fetchNodeProcessVersions = sandbox.stub(this.tessel, 'fetchNodeProcessVersions').returns(Promise.resolve(processVersions));
+
     this.pathResolve = sandbox.stub(path, 'resolve');
     this.failure = 'FAIL';
     done();
@@ -1863,6 +1867,75 @@ exports['deploy.sendBundle, error handling'] = {
   },
 };
 
+
+exports['deployment.js.preBundle'] = {
+  setUp: function(done) {
+    this.tessel = TesselSimulator();
+
+    this.info = sandbox.stub(log, 'info');
+    this.exec = sandbox.stub(this.tessel.connection, 'exec', (command, callback) => {
+      callback(null, this.tessel._rps);
+    });
+
+    this.receive = sandbox.stub(this.tessel, 'receive', (rps, callback) => {
+      rps.emit('close');
+      callback();
+    });
+
+    this.fetchNodeProcessVersions = sandbox.stub(this.tessel, 'fetchNodeProcessVersions').returns(Promise.resolve(processVersions));
+
+    this.findProject = sandbox.stub(deploy, 'findProject').returns(Promise.resolve({
+      pushdir: '',
+      entryPoint: ''
+    }));
+    this.resolveBinaryModules = sandbox.stub(deployment.js, 'resolveBinaryModules').returns(Promise.resolve());
+    this.tarBundle = sandbox.stub(deployment.js, 'tarBundle').returns(Promise.resolve(new Buffer([0x00])));
+    this.pathResolve = sandbox.stub(path, 'resolve');
+
+
+    this.preBundle = sandbox.spy(deployment.js, 'preBundle');
+    done();
+  },
+
+  tearDown: function(done) {
+    this.tessel.mockClose();
+    sandbox.restore();
+    done();
+  },
+
+  preBundleReceivesTessel(test) {
+    test.expect(1);
+
+    deploy.sendBundle(this.tessel, {
+      target: '/',
+      entryPoint: 'foo.js',
+      lang: deployment.js
+    }).then(() => {
+      test.equal(this.preBundle.lastCall.args[0].tessel, this.tessel);
+      test.done();
+    });
+  },
+
+  preBundleCallsfetchNodeProcessVersionsAndForwardsResult(test) {
+    test.expect(4);
+
+    deploy.sendBundle(this.tessel, {
+      target: '/',
+      entryPoint: 'foo.js',
+      lang: deployment.js
+    }).then(() => {
+      test.equal(this.fetchNodeProcessVersions.callCount, 1);
+      test.equal(this.resolveBinaryModules.callCount, 1);
+
+      var args = this.resolveBinaryModules.lastCall.args[0];
+
+      test.equal(args.tessel, this.tessel);
+      test.equal(args.tessel.versions, processVersions);
+      test.done();
+    });
+  },
+};
+
 exports['deployment.js.resolveBinaryModules'] = {
   setUp: function(done) {
 

test/unit/version.js

@@ -1,7 +1,7 @@
 // Test dependencies are required and exposed in common/bootstrap.js
 require('../common/bootstrap');
 
-exports['Tessel.prototype.fetchCurrentNodeVersion'] = {
+exports['version *'] = {
   setUp: function(done) {
     this.sandbox = sinon.sandbox.create();
     this.warn = this.sandbox.stub(log, 'warn', function() {});
@@ -12,10 +12,6 @@ exports['Tessel.prototype.fetchCurrentNodeVersion'] = {
 
     this.tessel = TesselSimulator();
 
-    this.simpleExec = this.sandbox.stub(Tessel.prototype, 'simpleExec', () => {
-      return Promise.resolve('v4.2.1');
-    });
-
     done();
   },
 
@@ -26,10 +22,12 @@ exports['Tessel.prototype.fetchCurrentNodeVersion'] = {
     done();
   },
 
-  properVersionReturned: function(test) {
+  'Tessel.prototype.fetchNodeProcessVersion': function(test) {
     test.expect(3);
 
-    this.tessel.fetchCurrentNodeVersion()
+    this.simpleExec = this.sandbox.stub(this.tessel, 'simpleExec').returns(Promise.resolve('v4.2.1'));
+
+    this.tessel.fetchNodeProcessVersion()
       .then(version => {
         test.equal(this.simpleExec.callCount, 1);
         test.equal(this.simpleExec.calledWith(['node', '--version']), true);
@@ -40,5 +38,22 @@ exports['Tessel.prototype.fetchCurrentNodeVersion'] = {
         test.ok(false, `properVersionReturned failed: ${error.toString()}`);
         test.done();
       });
+  },
+
+  'Tessel.prototype.fetchNodeProcessVersions': function(test) {
+    test.expect(3);
+    this.simpleExec = this.sandbox.stub(this.tessel, 'simpleExec').returns(Promise.resolve(JSON.stringify(processVersions)));
+
+    this.tessel.fetchNodeProcessVersions()
+      .then(version => {
+        test.equal(this.simpleExec.callCount, 1);
+        test.equal(this.simpleExec.calledWith(['node', '-p', 'JSON.stringify(process.versions)']), true);
+        test.deepEqual(version, processVersions);
+        test.done();
+      })
+      .catch(error => {
+        test.ok(false, `properVersionReturned failed: ${error.toString()}`);
+        test.done();
+      });
   }
 };