hmpo-model 3.1.0 → 4.0.0

package/.circleci/config.yml

@@ -0,0 +1,21 @@
+# This config is equivalent to both the '.circleci/extended/orb-free.yml' and the base '.circleci/config.yml'
+version: 2.1
+
+# Orbs are reusable packages of CircleCI configuration that you may share across projects, enabling you to create encapsulated, parameterized commands, jobs, and executors that can be used across multiple projects.
+# See: https://circleci.com/docs/2.0/orb-intro/
+orbs:
+  node: circleci/node@4.7
+
+# Invoke jobs via workflows
+# See: https://circleci.com/docs/2.0/configuration-reference/#workflows
+workflows:
+  sample: # This is the name of the workflow, feel free to change it to better match your workflow.
+    # Inside the workflow, you define the jobs you want to run.
+    jobs:
+      - node/test:
+          # This is the node version to use for the `cimg/node` tag
+          # Relevant tags can be found on the CircleCI Developer Hub
+          # https://circleci.com/developer/images/image/cimg/node
+          version: '16.10'
+          # If you are using yarn, change the line below from "npm" to "yarn"
+          pkg-manager: npm

package/README.md

@@ -2,88 +2,134 @@
 * localModel - Simple model for data persistance
 * remoteModel - Simple model for interacting with http/rest apis.
 
+## Upgrading
+
+The deprecated `request` library has been replaced with `got`. The API is very similar, and some args are translated, like auth, and proxy.
+The new `got` library doesn't automativally use the proxy environment variables so you would need to use something like `global-agent` in your
+app if you need to specify proxies by environment arguments.
+
+The `request` method no longer takes a body. This should be inserted as `json`, `body`, or `form` into the `requestConfig` method.
+
 ## Local Model Usage
-### get
+### `get(name)`
 * gets a model property via a key
 
-### set
+### `set(name, value)` or `set({ name: value })`
 * sets a property on the model to a value and dispatches events
 
-### unset
+### `unset(name)`
 * unsets a property
 
-### reset
+### `reset([options])`
 * resets a model
 * suppresses `change` event notifications if `options.silent` is set
 
-### increment
+### `increment(name)`
 * Increments a property
 
-### toJSON
+### `toJSON()`
 * returns a JSON representation of the data in the model
 
 ## Remote Model Usage
 
 Normally this would be used as an abstract class and extended with your own implementation.
 
-Implementations would normally define at least a `url` method to define the target of API calls.
-
-There are three methods for API interaction corresponding to GET, POST, and DELETE http methods:
-
-### `fetch`
+Implementations would normally define at least a `url():url` method to define the target of API calls.
 
+Example implimentation:
 ```javascript
-var model = new Model();
-model.fetch(function (err, data, responseTime) {
+class MyModel extends HmpoModel {
+    url() {
+        return super.url('https://my.example.com/url')
+    }
+
+    auth() {
+        return super.auth('username:password');
+    }
+
+    requestConfig(config) {
+        config.proxy = 'http://proxy.example.com:3128'
+        return super.requestConfig(config);
+    }
+
+    // add data to JSON post body
+    prepare(callback) {
+        super.prepare((err, data) => {
+            if (err) return callback(err);
+            data.foo = 'bar';
+            callback(null, data);
+        });
+    }
+
+    // transform returned data
+    parse(data) {
+        data.additionalItem = true;
+        return super.parse(data);
+    }
+}
+
+const model = new MyModel();
+model.set('boo', 'baz');
+model.save((err, data, responseTime) => {
+    if (err) return console.error(err);
     console.log(data);
 });
 ```
 
-### `save`
+There are three methods for API interaction corresponding to GET, POST, and DELETE http methods:
+
+### `fetch([args, ][callback])`
+
+`fetch` performs a `GET` request on the url
 
 ```javascript
-var model = new Model();
-model.set({
-    property: 'properties are sent as JSON request body by default'
-});
-model.save(function (err, data, responseTime) {
+const model = new Model();
+model.fetch((err, data, responseTime) => {
     console.log(data);
 });
 ```
+#### Request
+- Request args for the `got` library, can be set by overriding the `requestConfig({}):{}` method.
+
+- The `url` can be configured either by setting a default in the model options or `requestConfig()` data, or by overriding the `url(default, args):url` method.
+
+- `proxy`, `timeout`, and basic `auth` can be set in the same way, using model options, setting in `requestConfig()`, or by overriding a method.
+- Specifying a `proxy` will set up a proxy tunneling `agent` for the request.
+- Specifying a numeric `timeout` will set the same timeout for all `got` timeout values.
+- Basic `auth` can be a colon separated string, or a `{username, password}` or `{user, pass}` object.
+
+#### Response
+- The returned body will be expected to be in JSON format.
+- If `statusCode < 400` the JSON response will be set to the model.
+This behaviour can be changed by overriding the `parse(data):data` method.
+- If `statusCode >= 400` the data will be passed to the `parseError(statusCode, data):error` method, and the `fetch` callback will be called with the returned error.
+- If response statuses need to be treated differently than the above, the `parseResponse(statusCode, data, cb)` method can be overridden.
+- If the response body is not going to be JSON, the `handleResponse(response, cb)` method can be overridden.
+
+### `save([args, ][callback])`
 
-The method can also be overwritten by passing options
+`save` performs a `POST` request on the url
 
 ```javascript
-var model = new Model();
+const model = new Model();
 model.set({
-    property: 'this will be sent as a PUT request'
+    property: 'properties are sent as JSON request body by default'
 });
-model.save({ method: 'PUT' }, function (err, data, responseTime) {
+model.save((err, data, responseTime) => {
     console.log(data);
 });
 ```
 
-### `delete`
+- By default the post body will be a JSON encoded object containing all attributes set to the model using, extracted using `model.toJSON()`. This behaviour can be changed by overriding the `prepare(callback(err, data))` method.
+- The response and body will be treated the same way as the `fetch` request above.
 
-```javascript
-var model = new Model();
-model.delete(function (err, data) {
-    console.log(data);
-});
-```
+### `delete([args, ][callback])`
 
-If no `url` method is defined then the model will use the options parameter and [Node's url.format method](https://nodejs.org/api/url.html#url_url_format_urlobj) to construct a URL.
+`delete` performs a `DELETE` request on the url
 
 ```javascript
-var model = new Model();
-
-// make a GET request to http://example.com:3000/foo/bar
-model.fetch({
-    protocol: 'http',
-    hostname: 'example.com',
-    port: 3000,
-    path: '/foo/bar'
-}, function (err, data, responseTime) {
+const model = new Model();
+model.delete((err, data, responseTime) => {
     console.log(data);
 });
 ```

package/lib/local-model.js

@@ -98,7 +98,7 @@ class LocalModel extends EventEmitter {
     }
 
     toJSON() {
-        return _.clone(this.attributes);
+        return Object.assign({}, this.attributes);
     }
 }
 

package/lib/remote-model.js

@@ -1,96 +1,170 @@
 'use strict';
 
+const debug = require('debug')('hmpo:model:remote');
 const LocalModel = require('./local-model');
-const requestLib = require('request');
-const _ = require('underscore');
+const got = require('got');
 const kebabCase = require('lodash.kebabcase');
-const hmpoLogger = require('hmpo-logger');
+const { URL } = require('url');
+
+const DEFAULT_TIMEOUT = 60000;
 
 class RemoteModel extends LocalModel {
     constructor(attributes, options) {
         super(attributes, options);
-
+        this.got = got;
+        this.options.label = this.options.label || kebabCase(this.constructor.name);
         this.setLogger();
     }
 
     setLogger() {
-        this.logger = hmpoLogger.get(`:${kebabCase(this.constructor.name)}`);
+        try {
+            const hmpoLogger = require('hmpo-logger');
+            this.logger = hmpoLogger.get(':' + this.options.label);
+        } catch (e) {
+            console.error('Error setting logger, using console instead!', e);
+            this.logger = { outbound: console.log, trimHtml: html => html };
+        }
     }
 
-    fetch(callback) {
-        let config = this.requestConfig({method: 'GET'});
+    fetch(args, callback) {
+        if (typeof args === 'function') {
+            callback = args;
+            args = undefined;
+        }
+        const config = this.requestConfig({method: 'GET'}, args);
         this.request(config, callback);
     }
 
-    save(callback) {
-        this.prepare((err, data) => {
-
-            if (err) { return callback(err); }
-
-            data = JSON.stringify(data);
-
-            let config = this.requestConfig({
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(data)
-                }
-            });
-
-            this.request(config, data, callback);
-
+    save(args, callback) {
+        if (typeof args === 'function') {
+            callback = args;
+            args = undefined;
+        }
+        this.prepare((err, json) => {
+            if (err) return callback(err);
+            const config = this.requestConfig({method: 'POST', json}, args);
+            this.request(config, callback);
         });
     }
 
-    delete(callback) {
-        let config  = this.requestConfig({method: 'DELETE'});
+    delete(args, callback) {
+        if (typeof args === 'function') {
+            callback = args;
+            args = undefined;
+        }
+        const config  = this.requestConfig({method: 'DELETE'}, args);
         this.request(config, callback);
     }
 
-    requestConfig(config) {
-        let retConfig = _.clone(config);
+    prepare(callback) {
+        debug('prepare');
+        callback(null, this.toJSON());
+    }
 
-        retConfig.uri = this.url();
+    requestConfig(config, args) {
+        const retConfig = Object.assign({}, config);
 
-        let auth = this.auth();
+        retConfig.url = this.url(retConfig.url || retConfig.uri, args);
 
+        retConfig.timeout = this.timeout(retConfig.timeout);
+
+        const auth = this.auth(retConfig.auth);
         if (auth) {
-            retConfig.auth = auth;
+            retConfig.username = auth.username || auth.user;
+            retConfig.password = auth.password || auth.pass;
         }
+        delete retConfig.auth;
 
-        if (this.options.headers) {
-            retConfig.headers = _.defaults(retConfig.headers || {}, this.options.headers);
+        const agent = this.proxy(retConfig.proxy, retConfig.url);
+        if (agent) {
+            retConfig.agent = agent;
         }
+        delete retConfig.proxy;
+
+        const headers = Object.assign({}, this.options.headers, retConfig.headers);
+        if (Object.keys(headers).length) retConfig.headers = headers;
+
+        debug('requestConfig', retConfig);
 
         return retConfig;
     }
 
-    request(settings, body, callback) {
-        if (typeof body === 'function' && arguments.length === 2) {
-            callback = body;
-            body = undefined;
+    url(url = this.options.url) {
+        return url;
+    }
+
+    auth(auth = this.options.auth) {
+        if (typeof auth === 'string') {
+            const splitAuth = auth.split(':');
+            auth = {
+                username: splitAuth.shift(),
+                password: splitAuth.join(':')
+            };
+        }
+        return auth;
+    }
+
+    timeout(timeout = this.options.timeout || DEFAULT_TIMEOUT) {
+        if (typeof timeout === 'number') {
+            timeout = {
+                lookup: timeout,
+                connect: timeout,
+                secureConnect: timeout,
+                socket: timeout,
+                send: timeout,
+                response: timeout
+            };
         }
+        return timeout;
+    }
 
-        // This is cloned and set so that the post body is not kept around in memory
-        // settings is a shallow object, so the requestSettings is entirely made up of copied properties
-        let requestSettings = _.clone(settings);
-        requestSettings.body = body;
+    proxy(proxy = this.options.proxy, url) {
+        if (!proxy || !url) return;
 
-        let startTime = process.hrtime();
+        if (typeof proxy === 'string') proxy = { proxy };
 
-        let _callback = (err, data, statusCode) => {
+        const isHttps = (new URL(url).protocol === 'https:');
 
-            // This uses node's "high resolution time" to determine response time.
-            // The calculation is to translate seconds & nanoseconds into a number of format 1.234 seconds
-            let endTime = process.hrtime(startTime);
-            let responseTime = Number((endTime[0]*1000 + endTime[1]/1000000).toFixed(3));
+        if (isHttps) {
+            const { HttpsProxyAgent } = require('hpagent');
+            return {
+                https: new HttpsProxyAgent(Object.assign({
+                    keepAlive: false,
+                    maxSockets: 1,
+                    maxFreeSockets: 1,
+                }, proxy))
+            };
+        } else {
+            const { HttpProxyAgent } = require('hpagent');
+            return {
+                http: new HttpProxyAgent(Object.assign({
+                    keepAlive: false,
+                    maxSockets: 1,
+                    maxFreeSockets: 1,
+                }, proxy))
+            };
+        }
+    }
 
+    request(settings, callback) {
+        this.hookSync({settings});
+        this.logSync({settings});
+        this.emit('sync', settings);
+
+        let responseTime;
+        const startTime = process.hrtime.bigint();
+        const setResponseTime = () => {
+            const endTime = process.hrtime.bigint();
+            responseTime = Number((Number(endTime - startTime) / 1000000).toFixed(3));
+        };
+
+        const _callback = (err, data, statusCode) => {
             if (err) {
                 this.hookFail({settings, statusCode, responseTime, err, data});
                 this.logError({settings, statusCode, responseTime, err, data});
                 this.emit('fail', err, data, settings, statusCode, responseTime);
             } else {
-                this.hookSuccess({settings, statusCode, responseTime});
+                this.hookSuccess({data, settings, statusCode, responseTime});
                 this.logSuccess({settings, statusCode, responseTime});
                 this.emit('success', data, settings, statusCode, responseTime);
             }
@@ -99,25 +173,27 @@ class RemoteModel extends LocalModel {
             }
         };
 
-        requestLib(requestSettings, (err, response) => {
-            if (err) {
+        this.got(settings)
+            .catch(err => {
+                debug('request got error', err);
+                setResponseTime();
                 if (err.code === 'ETIMEDOUT') {
                     err.message = 'Connection timed out';
                     err.status = 504;
                 }
-                err.status = err.status || (response && response.statusCode) || 503;
-                return _callback(err, null, err.status);
-            }
-            this.handleResponse(response, _callback);
-        });
-
-        this.hookSync({settings});
-        this.logSync({settings});
-        this.emit('sync', settings);
+                err.status = err.status || (err.response && err.response.statusCode) || 503;
+                return _callback(err, null, err.status, err.response);
+            })
+            .then(response => {
+                debug('request got response', response);
+                setResponseTime();
+                this.handleResponse(response, _callback);
+            });
     }
 
     handleResponse(response, callback) {
-        let data = {};
+        debug('handleResponse', response);
+        let data;
         try {
             data = JSON.parse(response.body || '{}');
         } catch (err) {
@@ -129,53 +205,37 @@ class RemoteModel extends LocalModel {
     }
 
     parseResponse(statusCode, data, callback) {
-        if (statusCode < 400) {
-            try {
-                data = this.parse(data);
-                callback(null, data, statusCode);
-            } catch (err) {
-                callback(err, null, statusCode);
-            }
-        } else {
-            callback(this.parseError(statusCode, data), data, statusCode);
+        debug('parseResponse', statusCode, data);
+
+        if (statusCode >= 400) {
+            const error = this.parseError(statusCode, data);
+            return callback(error, data, statusCode);
         }
-    }
 
-    prepare(callback) {
-        callback(null, this.toJSON());
+        try {
+            data = this.parse(data);
+        } catch (err) {
+            return callback(err, null, statusCode);
+        }
+
+        callback(null, data, statusCode);
     }
 
     parse(data) {
+        debug('parse', data);
+        if (data && typeof data === 'object') this.set(data);
         return data;
     }
 
     parseError(statusCode, data) {
-        return _.extend({ status: statusCode }, data);
-    }
-
-    url() {
-        return this.options.url;
-    }
-
-    auth(credentials) {
-        if (!credentials) return;
-
-        if (typeof credentials === 'string') {
-            let auth = credentials.split(':');
-            credentials = {
-                user: auth.shift(),
-                pass: auth.join(':'),
-                sendImmediately: true
-            };
-        }
-
-        return credentials;
+        debug('parseError, statusCode, data');
+        return Object.assign({ status: statusCode }, data);
     }
 
     logMeta(tokenData) {
         let data = {
             outVerb: tokenData.settings.method,
-            outRequest: tokenData.settings.uri
+            outRequest: tokenData.settings.url
         };
 
         if (tokenData.statusCode) {
@@ -193,7 +253,7 @@ class RemoteModel extends LocalModel {
             data.outErrorBody = this.logger.trimHtml(tokenData.err.body);
         }
 
-        _.extend(data, this.options.logging);
+        Object.assign(data, this.options.logging);
 
         return data;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hmpo-model",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "Simple model for interacting with http/rest apis.",
   "main": "index.js",
   "scripts": {
@@ -25,19 +25,21 @@
   },
   "homepage": "https://github.com/UKHomeOffice/passports-model",
   "dependencies": {
-    "hmpo-logger": "^4.0.2",
+    "debug": "^4.3.3",
+    "got": "^11.8.3",
+    "hpagent": "^0.1.2",
     "lodash.kebabcase": "^4.1.1",
-    "request": "^2.88.2",
-    "underscore": "^1.12.0"
+    "underscore": "^1.13.1"
   },
   "devDependencies": {
-    "chai": "^4.3.0",
-    "eslint": "^7.20.0",
-    "mocha": "^7.2.0",
+    "chai": "^4.3.4",
+    "eslint": "^8.3.0",
+    "hmpo-logger": "^4.1.3",
+    "mocha": "^9.1.3",
     "nyc": "^15.1.0",
     "proxyquire": "^2.0.0",
-    "sinon": "^9.2.4",
-    "sinon-chai": "^3.5.0"
+    "sinon": "^12.0.1",
+    "sinon-chai": "^3.7.0"
   },
   "nyc": {
     "all": true,

package/test/lib/spec.remote-model.js

@@ -1,14 +1,16 @@
 'use strict';
 
-const proxyquire = require('proxyquire');
+const Model = require('../../lib/remote-model');
 const BaseModel = require('../../lib/local-model');
 const _ = require('underscore');
+const logger = require('hmpo-logger');
+
+const { HttpProxyAgent, HttpsProxyAgent } = require('hpagent');
 
 describe('Remote Model', () => {
-    let model, Model, cb, mocks;
+    let model, cb, mocks;
 
     beforeEach(() => {
-        Model = require('../../lib/remote-model');
         model = new Model();
 
         cb = sinon.stub();
@@ -24,39 +26,60 @@ describe('Remote Model', () => {
     });
 
     it('should be an instance of LocalModel', () => {
-        Model = require('../../lib/remote-model');
         model = new Model();
 
         model.should.be.an.instanceOf(BaseModel);
     });
 
     describe('constructor', () => {
+        let Model;
 
-        it('should call setLogger', () => {
-            let Model = require('../../lib/remote-model');
+        beforeEach(() => {
+            Model = require('../../lib/remote-model');
             sinon.stub(Model.prototype, 'setLogger');
+        });
 
+        it('should call setLogger', () => {
             model = new Model();
-
             model.setLogger.should.have.been.calledWithExactly();
         });
 
+        it('should set model label name', () => {
+            model = new Model();
+            model.options.label.should.equal('remote-model');
+        });
+
         afterEach(() => {
             Model.prototype.setLogger.restore();
         });
     });
 
     describe('setLogger', () => {
-        let getStub = sinon.stub();
-        let Model = proxyquire('../../lib/remote-model', {
-            'hmpo-logger': {
-                get: getStub
-            }
+        beforeEach(() => {
+            sinon.stub(logger, 'get').returns('logger');
         });
 
-        model = new Model();
+        afterEach(() => {
+            logger.get.restore();
+        });
+
+        it('should set up a new hmpo-logger', () => {
+            model = new Model();
+
+            logger.get.should.have.been.calledWithExactly(':remote-model');
+            model.logger.should.equal('logger');
+        });
 
-        getStub.should.have.been.calledWithExactly(':remote-model');
+        it('should use console log and a trimHtml pass-through if hmpo-logger is not available', () => {
+            logger.get.throws(new Error());
+
+            model = new Model();
+
+            model.logger.outbound.should.eql(console.log);
+            model.logger.trimHtml.should.be.a('function');
+            const html = {};
+            model.logger.trimHtml(html).should.equal(html);
+        });
     });
 
     describe('fetch', () => {
@@ -77,6 +100,15 @@ describe('Remote Model', () => {
                 method: 'GET'
             });
         });
+
+        it('should pass args onto requestConfig', () => {
+            model.fetch({ foo: 'bar' }, cb);
+
+            model.requestConfig.should.have.been.calledWithExactly({
+                method: 'GET'
+            }, { foo: 'bar' });
+        });
+
         it('should call request', () => {
             model.requestConfig.returns(mocks.config);
 
@@ -102,9 +134,9 @@ describe('Remote Model', () => {
         it('should call prepare', () => {
             model.save(cb);
 
-            model.prepare.should.have.been.called;
-
+            model.prepare.should.have.been.calledWithExactly(sinon.match.func);
         });
+
         it('should call callback with an error', () => {
             let error = new Error('error');
             model.prepare.yields(error);
@@ -112,7 +144,6 @@ describe('Remote Model', () => {
             model.save(cb);
 
             cb.should.have.been.calledWith(error);
-
         });
 
         context('on prepare success', () => {
@@ -128,20 +159,27 @@ describe('Remote Model', () => {
             it('should use requestConfig', () => {
                 model.save(cb);
 
-                model.requestConfig.should.have.been.calledWith({
+                model.requestConfig.should.have.been.calledWithExactly({
                     method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Content-Length': Buffer.byteLength(JSON.stringify(preparedData))
-                    }
-                });
+                    json: preparedData
+                }, undefined);
+            });
+
+            it('should pass args onto requestConfig', () => {
+                model.save({ foo: 'bar' }, cb);
+
+                model.requestConfig.should.have.been.calledWithExactly({
+                    method: 'POST',
+                    json: preparedData
+                }, { foo: 'bar' });
             });
+
             it('should call request', () => {
                 model.requestConfig.returns(mocks.config);
 
                 model.save(cb);
 
-                model.request.should.have.been.calledWith(mocks.config, JSON.stringify(preparedData), cb);
+                model.request.should.have.been.calledWith(mocks.config, cb);
             });
         });
 
@@ -165,6 +203,15 @@ describe('Remote Model', () => {
                 method: 'DELETE'
             });
         });
+
+        it('should pass args onto requestConfig', () => {
+            model.delete({ foo: 'bar' }, cb);
+
+            model.requestConfig.should.have.been.calledWithExactly({
+                method: 'DELETE'
+            }, { foo: 'bar' });
+        });
+
         it('should call request', () => {
             model.requestConfig.returns(mocks.config);
 
@@ -175,50 +222,227 @@ describe('Remote Model', () => {
     });
 
     describe('requestConfig', () => {
-        beforeEach(() => {
-            sinon.stub(model, 'url');
-            sinon.stub(model, 'auth');
+        describe('url', () => {
+            it('should use url from model options', () => {
+                model.options.url = 'https://example.com/options';
+                const config = model.requestConfig({
+                    'method': 'VERB'
+                });
 
-            model.url.returns('http://example.net');
-        });
+                config.url.should.equal('https://example.com/options');
+            });
 
-        afterEach(() => {
-            model.url.restore();
-            model.auth.restore();
+            it('should use url from request config', () => {
+                model.options.url = 'https://example.com/options';
+                const config = model.requestConfig({
+                    'method': 'VERB',
+                    'url': 'https://example.com/config'
+                });
+
+                config.url.should.equal('https://example.com/config');
+            });
+
+            it('should use url returned by overridden url() method', () => {
+                model.options.url = 'https://example.com/options';
+                model.url = sinon.stub().returns('https://example.com/overridden');
+                const config = model.requestConfig({
+                    'method': 'VERB',
+                    'url': 'https://example.com/config'
+                });
+                model.url.should.have.been.calledWithExactly('https://example.com/config', undefined);
+                config.url.should.equal('https://example.com/overridden');
+            });
+
+            it('should pass args onto url method', () => {
+                model.url = sinon.stub().returns('https://example.com/overridden');
+                const config = model.requestConfig({
+                    'method': 'VERB',
+                    'url': 'https://example.com/config'
+                }, { foo: 'bar' });
+                model.url.should.have.been.calledWithExactly('https://example.com/config', { foo: 'bar' });
+                config.url.should.equal('https://example.com/overridden');
+            });
         });
 
+        describe('auth', () => {
+            it('should use auth from model options', () => {
+                model.options.auth = 'options:pass:word';
+                const config = model.requestConfig({
+                    'method': 'VERB'
+                });
 
-        it('should use url', () => {
-            model.requestConfig({
-                'method': 'VERB'
+                config.username.should.equal('options');
+                config.password.should.equal('pass:word');
+                config.should.not.have.property('auth');
+            });
+
+            it('should use auth from config', () => {
+                model.options.auth = 'options:pass:word';
+                const config = model.requestConfig({
+                    'method': 'VERB',
+                    'auth': 'config:pass:word'
+                });
+
+                config.username.should.equal('config');
+                config.password.should.equal('pass:word');
+                config.should.not.have.property('auth');
             });
 
-            model.url.should.have.been.calledWithExactly();
+            it('should use auth from overidden auth() method', () => {
+                model.options.auth = 'options:pass:word';
+                model.auth = sinon.stub().returns({ user: 'overridden', pass: 'pass:word' });
+                const config = model.requestConfig({
+                    'method': 'VERB',
+                    'auth': 'config:pass:word'
+                });
+
+                model.auth.should.have.been.calledWithExactly('config:pass:word');
+                config.username.should.equal('overridden');
+                config.password.should.equal('pass:word');
+                config.should.not.have.property('auth');
+            });
         });
 
-        it('should use auth', () => {
-            model.requestConfig({
-                'method': 'VERB'
+        describe('timeout', () => {
+            it('should use a default timeout', () => {
+                const config = model.requestConfig({
+                    'method': 'VERB'
+                });
+
+                config.should.deep.include({
+                    timeout: {
+                        connect: 60000,
+                        lookup: 60000,
+                        response: 60000,
+                        secureConnect: 60000,
+                        send: 60000,
+                        socket: 60000
+                    }
+                });
+            });
+
+            it('should use timeout from model options', () => {
+                model.options.timeout = 1000;
+                const config = model.requestConfig({
+                    'method': 'VERB'
+                });
+
+                config.should.deep.include({
+                    timeout: {
+                        connect: 1000,
+                        lookup: 1000,
+                        response: 1000,
+                        secureConnect: 1000,
+                        send: 1000,
+                        socket: 1000
+                    }
+                });
             });
 
-            model.auth.should.have.been.calledWithExactly();
+            it('should use timeout from config', () => {
+                model.options.timeout = 1000;
+                const config = model.requestConfig({
+                    'method': 'VERB',
+                    'timeout': 2000
+                });
+
+                config.should.deep.include({
+                    timeout: {
+                        connect: 2000,
+                        lookup: 2000,
+                        response: 2000,
+                        secureConnect: 2000,
+                        send: 2000,
+                        socket: 2000
+                    }
+                });
+            });
+
+            it('should use timeout from specified object', () => {
+                const config = model.requestConfig({
+                    'method': 'VERB',
+                    'timeout': { connect: 3000 }
+                });
+
+                config.should.deep.include({
+                    timeout: {
+                        connect: 3000,
+                    }
+                });
+            });
+
+            it('should use timeout from overidden timeout() method', () => {
+                model.timeout = sinon.stub().returns({ connect: 4000 });
+                const config = model.requestConfig({
+                    'method': 'VERB',
+                    'timeout': 2000
+                });
+
+                model.timeout.should.have.been.calledWithExactly(2000);
+                config.should.deep.include({
+                    timeout: {
+                        connect: 4000,
+                    }
+                });
+            });
         });
 
-        it('should add auth to config if provided', () => {
-            model.auth.returns({
-                user: 'username',
-                pass: 'password'
+        describe('proxy', () => {
+            it('should not set up http proxy if there is no url', () => {
+                const returnedConfig = model.requestConfig({
+                    'method': 'VERB',
+                    'proxy': 'http://proxy.example.com:8000'
+                });
+
+                returnedConfig.should.not.have.property('proxy');
+                returnedConfig.should.not.have.property('agent');
             });
 
-            let returnedConfig = model.requestConfig({
-                'method': 'VERB'
+            it('should set up http proxy if specified', () => {
+                const returnedConfig = model.requestConfig({
+                    'method': 'VERB',
+                    'url': 'http://example.net',
+                    'proxy': 'http://proxy.example.com:8000'
+                });
+
+                sinon.assert.match(returnedConfig, {
+                    agent: {
+                        http: sinon.match.instanceOf(HttpProxyAgent)
+                    }
+                });
             });
 
-            returnedConfig.should.deep.include({
-                auth: {
-                    user: 'username',
-                    pass: 'password'
-                }
+            it('should set up https proxy if specified', () => {
+                const returnedConfig = model.requestConfig({
+                    'method': 'VERB',
+                    'url': 'https://example.net',
+                    'proxy': 'http://proxy.example.com:8000'
+                });
+
+                sinon.assert.match(returnedConfig, {
+                    agent: {
+                        https: sinon.match.instanceOf(HttpsProxyAgent)
+                    }
+                });
+            });
+
+            it('should pass proxy options to the new proxy', () => {
+                const returnedConfig = model.requestConfig({
+                    'method': 'VERB',
+                    'url': 'http://example.net',
+                    'proxy': {
+                        proxy: 'http://proxy.example.com:8000',
+                        keepAlive: true
+                    }
+                });
+
+                sinon.assert.match(returnedConfig, {
+                    agent: {
+                        http: {
+                            keepAlive: true
+                        }
+                    }
+                });
             });
         });
 
@@ -330,14 +554,15 @@ describe('Remote Model', () => {
     });
 
     describe('request', () => {
-        let settings, body, requestSettings;
+        let settings, requestSettings, mocks;
 
         beforeEach(() => {
-            let Model = proxyquire('../../lib/remote-model', {
-                'request': mocks.request
-            });
-
+            mocks = {};
+            mocks.got = sinon.stub().returns(mocks);
+            mocks.then = sinon.stub().returns(mocks);
+            mocks.catch = sinon.stub().returns(mocks);
             model = new Model();
+            model.got = mocks.got;
 
             sinon.stub(model, 'logSync');
             sinon.stub(model, 'logSuccess');
@@ -358,22 +583,11 @@ describe('Remote Model', () => {
             model.emit.restore();
         });
 
-        it('should invoke request with settings including a body', () => {
-            requestSettings.body = body;
-
-            model.request(settings, body, cb);
-
-            mocks.request.should.have.been.called;
-            mocks.request.should.have.been.calledWith(requestSettings);
-        });
-
         it('should invoke request with request settings', () => {
-            requestSettings.body = undefined;
-
             model.request(settings, cb);
 
-            mocks.request.should.have.been.called;
-            mocks.request.should.have.been.calledWith(requestSettings);
+            mocks.got.should.have.been.called;
+            mocks.got.should.have.been.calledWith(requestSettings);
         });
 
         it('should log sync messages', () => {
@@ -405,7 +619,7 @@ describe('Remote Model', () => {
         });
 
         it('should work without a callback', () => {
-            mocks.request.yields(new Error('Random Error'), {});
+            mocks.catch.yields(new Error('Random Error'));
 
             model.request(settings);
 
@@ -424,7 +638,9 @@ describe('Remote Model', () => {
                     'statusCode': 418
                 };
 
-                mocks.request.yields(error, response);
+                error.response = response;
+
+                mocks.catch.yields(error);
             });
 
             it('should log error messages', () => {
@@ -507,7 +723,7 @@ describe('Remote Model', () => {
 
         context('on success', () => {
             beforeEach(() => {
-                mocks.request.yields(null, {
+                mocks.then.yields({
                     'body': JSON.stringify({'data': 'value'}),
                     'statusCode': 200
                 });
@@ -541,6 +757,7 @@ describe('Remote Model', () => {
                 model.request(settings, cb);
 
                 hook.should.have.been.calledWithExactly({
+                    data: {'data': 'value'},
                     statusCode: 200,
                     settings: settings,
                     responseTime: sinon.match.number
@@ -613,6 +830,7 @@ describe('Remote Model', () => {
 
         afterEach(() => {
             model.parse.restore();
+
             model.parseError.restore();
         });
 
@@ -686,6 +904,17 @@ describe('Remote Model', () => {
         it('returns data passed', () => {
             model.parse({ data: 1 }).should.eql({ data: 1 });
         });
+
+        it('sets the parsed data to the model', () => {
+            model.parse({ foo: 'bar' });
+            model.get('foo').should.equal('bar');
+        });
+
+        it('does not set if the data falsey', () => {
+            model.set = sinon.stub();
+            model.parse(null);
+            model.set.should.not.have.been.called;
+        });
     });
 
     describe('parseError', () => {
@@ -715,12 +944,11 @@ describe('Remote Model', () => {
         });
 
         it('should return parsed credentials if credentials is a string', () => {
-            let credentials = model.auth('username:password');
+            let credentials = model.auth('username:pass:word');
 
             credentials.should.deep.equal({
-                user: 'username',
-                pass: 'password',
-                sendImmediately: true
+                username: 'username',
+                password: 'pass:word'
             });
 
         });
@@ -739,21 +967,21 @@ describe('Remote Model', () => {
 
 
     describe('logging', () => {
-        let logger;
+        let mocks;
 
         beforeEach(() => {
-            logger = {
+            mocks = {
                 outbound: sinon.stub(),
                 trimHtml: sinon.stub()
             };
-
-            let Model = proxyquire('../../lib/remote-model', {
-                'hmpo-logger': {
-                    get: () => logger,
-                }
-            });
+            sinon.stub(logger, 'get').returns(mocks);
 
             model = new Model();
+
+        });
+
+        afterEach(() => {
+            logger.get.restore();
         });
 
         describe('logSync', () => {
@@ -761,7 +989,7 @@ describe('Remote Model', () => {
                 let args = {
                     settings: {
                         method: 'VERB',
-                        uri: 'http://example.org'
+                        url: 'http://example.org'
                     }
                 };
 
@@ -772,7 +1000,7 @@ describe('Remote Model', () => {
 
                 model.logSync(args);
 
-                logger.outbound.should.have.been.calledWithExactly(
+                mocks.outbound.should.have.been.calledWithExactly(
                     'Model request sent :outVerb :outRequest',
                     argsAsMeta
                 );
@@ -784,7 +1012,7 @@ describe('Remote Model', () => {
                 let args = {
                     settings: {
                         method: 'VERB',
-                        uri: 'http://example.org'
+                        url: 'http://example.org'
                     },
                     statusCode: 418,
                     responseTime: 1000
@@ -799,7 +1027,7 @@ describe('Remote Model', () => {
 
                 model.logError(args);
 
-                logger.outbound.should.have.been.calledWithExactly(
+                mocks.outbound.should.have.been.calledWithExactly(
                     'Model request failed :outVerb :outRequest :outResponseCode :outError',
                     argsAsMeta
                 );
@@ -811,7 +1039,7 @@ describe('Remote Model', () => {
                 let args = {
                     settings: {
                         method: 'VERB',
-                        uri: 'http://example.org'
+                        url: 'http://example.org'
                     },
                     statusCode: 418,
                     responseTime: 1000
@@ -826,7 +1054,7 @@ describe('Remote Model', () => {
 
                 model.logSuccess(args);
 
-                logger.outbound.should.have.been.calledWithExactly(
+                mocks.outbound.should.have.been.calledWithExactly(
                     'Model request success :outVerb :outRequest :outResponseCode',
                     argsAsMeta
                 );
@@ -841,7 +1069,7 @@ describe('Remote Model', () => {
                 data = {
                     settings: {
                         method: 'VERB',
-                        uri: 'http://example.org'
+                        url: 'http://example.org'
                     },
                     statusCode: 418,
                     responseTime: 3000,
@@ -916,7 +1144,7 @@ describe('Remote Model', () => {
                 });
 
                 it('should be present with error', () => {
-                    logger.trimHtml.returns('Html Body');
+                    mocks.trimHtml.returns('Html Body');
 
                     let result = model.logMeta(data);
 

package/.travis.yml

@@ -1,8 +0,0 @@
-language: node_js
-node_js:
-  - "10"
-  - "12"
-  - "14"
-notifications:
-  email: false
-sudo: false