(test): Refactor smart request module

test/functional/index.js

@@ -2,6 +2,7 @@
 
 require('./lib/startup');
 
+const _ = require('lodash');
 const assert = require('assert');
 const exec = require('child_process').exec;
 
@@ -26,6 +27,9 @@ describe('Func', function() {
         server.pid = body.pid;
         return new Promise(function(resolve, reject) {
           exec('lsof -p ' + Number(server.pid), function(err, result) {
+            if (_.isNil(err) === false) {
+              reject(err);
+            }
             assert.equal(err, null);
             server.fdlist = result.replace(/ +/g, ' ');
             resolve();
@@ -66,14 +70,20 @@ describe('Func', function() {
   after(function(done) {
     const check = (server) => {
       return new Promise(function(resolve, reject) {
-        exec('lsof -p ' + parseInt(server.pid, 10), function(err, result) {
+        exec(`lsof -p ${parseInt(server.pid, 10)}`, function(err, result) {
           if (err) {
             reject();
           } else {
-            result = result.split('\n').filter(function(q) {
+            result = result.split('\n').filter(function(query) {
-              if (q.match(/TCP .*->.* \(ESTABLISHED\)/)) return false;
+              if (query.match(/TCP .*->.* \(ESTABLISHED\)/)) {
-              if (q.match(/\/libcrypt-[^\/]+\.so/)) return false;
+                return false;
-              if (q.match(/\/node_modules\/crypt3\/build\/Release/)) return false;
+              }
+              if (query.match(/\/libcrypt-[^\/]+\.so/)) {
+                return false;
+              }
+              if (query.match(/\/node_modules\/crypt3\/build\/Release/)) {
+                return false;
+              }
               return true;
             }).join('\n').replace(/ +/g, ' ');
             assert.equal(server.fdlist, result);

test/functional/lib/server.js

@@ -12,7 +12,7 @@ class Server {
 
   constructor(url) {
     this.url = url.replace(/\/$/, '');
-    this.userAgent = 'node/v0.10.8 linux x64';
+    this.userAgent = 'node/v8.1.2 linux x64';
     this.authstr = buildAuthHeader('test', 'test');
   }
 
@@ -120,7 +120,7 @@ class Server {
 
   putTarballIncomplete(name, filename, data, size, cb) {
     let promise = this.request({
-      uri: '/'+encodeURIComponent(name)+'/-/'+encodeURIComponent(filename)+'/whatever',
+      uri: `/${encodeURIComponent(name)}/-/${encodeURIComponent(filename)}/whatever`,
       method: 'PUT',
       headers: {
         'content-type': 'application/octet-stream',
@@ -158,10 +158,11 @@ class Server {
   }
 
   whoami() {
-    return this.request({uri: '/-/whoami'})
+    return this.request({
-      .status(200)
+      uri: '/-/whoami'
-      .then(function(x) {
+    }).status(200)
-        return x.username;
+      .then(function(body) {
+        return body.username;
       });
   }
 

test/functional/lib/smart_request.js

@@ -2,53 +2,35 @@
 
 const assert = require('assert');
 const request = require('request');
-const sym = Symbol('smart_request_data');
+const requestData = Symbol('smart_request_data');
+const _ = require('lodash');
 
-function smart_request(options) {
+class PromiseAssert extends Promise {
-  let self = {};
-  self[sym] = {};
-  self[sym].error = Error();
-  Error.captureStackTrace(self[sym].error, smart_request);
 
-  let result = new Promise(function(resolve, reject) {
+  constructor(options) {
-    self[sym].request = request(options, function(err, res, body) {
+    super(options);
-      if (err) return reject(err);
-      self[sym].response = res;
-      resolve(body);
-    });
-  });
-
-  return extend(self, result);
   }
 
-function extend(self, promise) {
+  status(expected) {
-  promise[sym] = self[sym];
+    const selfData = this[requestData];
-  Object.setPrototypeOf(promise, extensions);
-  return promise;
-}
 
-var extensions = Object.create(Promise.prototype);
+    return injectResponse(this, this.then(function(body) {
-
-extensions.status = function(expected) {
-  let self_data = this[sym];
-
-  return extend(this, this.then(function(body) {
       try {
-      assert.equal(self_data.response.statusCode, expected);
+        assert.equal(selfData.response.statusCode, expected);
       } catch(err) {
-      self_data.error.message = err.message;
+        selfData.error.message = err.message;
-      throw self_data.error;
+        throw selfData.error;
       }
       return body;
     }));
-};
+  }
 
-extensions.body_ok = function(expected) {
+  body_ok(expected) {
-  let self_data = this[sym];
+    const self_data = this[requestData];
 
-  return extend(this, this.then(function(body) {
+    return injectResponse(this, this.then(function(body) {
       try {
-      if (Object.prototype.toString.call(expected) === '[object RegExp]') {
+        if (_.isRegExp(expected)) {
           assert(body.ok.match(expected), '\'' + body.ok + '\' doesn\'t match ' + expected);
         } else {
           assert.equal(body.ok, expected);
@@ -60,14 +42,15 @@ extensions.body_ok = function(expected) {
       }
       return body;
     }));
-};
+  }
 
-extensions.body_error = function(expected) {
-  let self_data = this[sym];
 
-  return extend(this, this.then(function(body) {
+  body_error(expected) {
+    const self_data = this[requestData];
+
+    return injectResponse(this, this.then(function(body) {
       try {
-      if (Object.prototype.toString.call(expected) === '[object RegExp]') {
+        if (_.isRegExp(expected)) {
           assert(body.error.match(expected), body.error + ' doesn\'t match ' + expected);
         } else {
           assert.equal(body.error, expected);
@@ -79,26 +62,55 @@ extensions.body_error = function(expected) {
       }
       return body;
     }));
-};
+  }
 
-extensions.request = function(cb) {
+  request(callback) {
-  cb(this[sym].request);
+    callback(this[requestData].request);
     return this;
-};
+  }
 
-extensions.response = function(cb) {
+  response(cb) {
-  let self_data = this[sym];
+    const selfData = this[requestData];
 
-  return extend(this, this.then(function(body) {
+    return injectResponse(this, this.then(function(body) {
-    cb(self_data.response);
+      cb(selfData.response);
       return body;
     }));
-};
+  }
 
-extensions.send = function(data) {
+  send(data) {
-  this[sym].request.end(data);
+    this[requestData].request.end(data);
     return this;
-};
+  }
 
-module.exports = smart_request;
+}
+
+function injectResponse(smartObject, promise) {
+  promise[requestData] = smartObject[requestData];
+  return promise;
+}
+
+function smartRequest(options) {
+  const smartObject = {};
+
+  smartObject[requestData] = {};
+  smartObject[requestData].error = Error();
+  Error.captureStackTrace(smartObject[requestData].error, smartRequest);
+
+  const result = new PromiseAssert(function(resolve, reject) {
+    smartObject[requestData].request = request(options, function(err, res, body) {
+      if (err) {
+        return reject(err);
+      }
+
+      // store the response on symbol
+      smartObject[requestData].response = res;
+      resolve(body);
+    });
+  });
+
+  return injectResponse(smartObject, result);
+}
+
+module.exports = smartRequest;