nock 0.56.0 → 0.59.1

package/README.md

@@ -106,7 +106,7 @@ var scope = nock('http://myapp.iriscouch.com')
                 });
 ```
 
-The request body can be a string, a RegExp, or a JSON object.
+The request body can be a string, a RegExp, a JSON object or a function.
 
 ```js
 var scope = nock('http://myapp.iriscouch.com')
@@ -118,6 +118,20 @@ var scope = nock('http://myapp.iriscouch.com')
                 });
 ```
 
+If the request body is a function, return true if it should be considered a match:
+```js
+var scope = nock('http://myapp.iriscouch.com')
+                .post('/users', function(body) {
+                  return body.id === '123ABC';
+                })
+                .reply(201, {
+                  ok: true,
+                  id: '123ABC',
+                  rev: '946B7D1C'
+                });
+
+```
+
 ## Specifying replies
 
 You can specify the return status code for a path on the first argument of reply like this:
@@ -227,6 +241,32 @@ var scope = nock('http://www.headdy.com')
   .reply(200, 'The default headers should come too');
 ```
 
+### Including Content-Length Header Automatically
+
+When using `scope.reply()` to set a response body manually, you can have the
+`Content-Length` header calculated automatically.
+
+```js
+var scope = nock('http://www.headdy.com')
+  .replyContentLength()
+  .get('/')
+  .reply(200, { hello: 'world' });
+```
+
+**NOTE:** this does not work with streams or other advanced means of specifying
+the reply body.
+
+### Including Date Header Automatically
+
+You can automatically append a `Date` header to your mock reply:
+
+```js
+var scope = nock('http://www.headdy.com')
+  .replyDate(new Date(2015, 0, 1)) // defaults to now, must use a Date object
+  .get('/')
+  .reply(200, { hello: 'world' });
+```
+
 ## HTTP Verbs
 
 Nock supports any HTTP verb, and it has convenience methods for the GET, POST, PUT, HEAD, DELETE, PATCH and MERGE HTTP verbs.

package/lib/intercept.js

@@ -371,7 +371,15 @@ function activate() {
       });
 
       if (! matches && allowUnmocked) {
-        return overriddenRequest(options, callback);
+        if (proto === 'https') {
+          var ClientRequest = http.ClientRequest;
+          http.ClientRequest = originalClientRequest;
+          req = overriddenRequest(options, callback);
+          http.ClientRequest = ClientRequest;
+        } else {
+          req = overriddenRequest(options, callback);
+        }
+        return req;
       }
 
       //  NOTE: Since we already overrode the http.ClientRequest we are in fact constructing

package/lib/match_body.js

@@ -27,17 +27,13 @@ function matchBody(spec, body) {
 
   // try to transform body to json
   var json;
-  if (typeof spec === 'object') {
+  if (typeof spec === 'object' || typeof spec === 'function') {
     try { json = JSON.parse(body);} catch(err) {}
     if (json !== undefined) {
       body = json;
     }
     else
-      if (
-        (typeof spec === 'object') &&
-        options.headers
-      )
-      {
+      if (options.headers) {
         var contentType = options.headers['Content-Type'] ||
                           options.headers['content-type'];
 
@@ -47,6 +43,10 @@ function matchBody(spec, body) {
       }
   }
 
+  if (typeof spec === "function") {
+    return spec.call(this, body);
+  }
+
   try {
     deepEqual(spec, body);
     return true;

package/lib/recorder.js

@@ -6,6 +6,7 @@ var common = require('./common');
 var intercept = require('./intercept');
 var debug = require('debug')('nock.recorder');
 var _ = require('lodash');
+var Stream = require('stream');
 
 var SEPARATOR = '\n<<<<<<-- cut here -->>>>>>\n';
 var recordingInProgress = false;
@@ -83,6 +84,7 @@ var getBodyFromChunks = function(chunks, headers) {
 };
 
 function generateRequestAndResponseObject(req, bodyChunks, options, res, dataChunks) {
+
   options.path = req.path;
   return {
     scope:    getScope(options),
@@ -197,17 +199,7 @@ function record(rec_options) {
         options = parse(options);
       }
 
-      var dataChunks = [];
-
-      res.on('data', function(data) {
-        debug(thisRecordingId, 'new', proto, 'data chunk');
-        dataChunks.push(data);
-      });
-
-      if (proto === 'https') {
-        options._https_ = true;
-      }
-
+      //  We put our 'end' listener to the front of the listener array.
       res.once('end', function() {
         debug(thisRecordingId, proto, 'intercepted request ended');
 
@@ -248,10 +240,94 @@ function record(rec_options) {
         }
       });
 
+      var dataChunks = [];
+
+      //  Give the actual client a chance to setup its listeners.
+      //  We will use the listener information to figure out
+      //  how we need to feed the intercepted data back to the client.
       if (callback) {
         callback(res, options, callback);
       }
 
+      //  Handle clients that listen to 'readable' by intercepting them
+      //  and feeding them the data manually.
+      var readableListeners = res.listeners('readable');
+      if (!_.isEmpty(readableListeners)) {
+
+        debug('handle readable listeners');
+
+        //  We will replace the client's listeners with our own and manually
+        //  invoke them.
+        _.each(readableListeners, function(listener) {
+          res.removeListener('readable', listener);
+        });
+
+        //  Repleace the actual Stream.Readable prototype 'read' function
+        //  so that we can control what the client listener will be reading.
+        var prototypeRead = Stream.Readable.prototype.read;
+        var currentReadIndex = 0;
+        res.read = function() {
+
+          debug(thisRecordingId, 'client reading data on', proto, dataChunks.length);
+
+          //  Feed the data to the client through from our collected data chunks.
+          if (currentReadIndex < dataChunks.length) {
+            debug('chunk', chunk, 'read');
+            var chunk = dataChunks[currentReadIndex];
+            ++currentReadIndex;
+            return chunk;
+          } else {
+            debug('no more chunks to read');
+            return null;
+          }
+
+        };
+
+        //  Put our own listener instead of the removed client listener.
+        var onReadable = function(data) {
+          debug(thisRecordingId, 'new readable data on', proto);
+          var chunk;
+          //  Use the prototypeRead function to actually read the data.
+          while (null !== (chunk = prototypeRead.call(res))) {
+            debug('read', chunk);
+            dataChunks.push(chunk);
+          }
+          //  Manually invoke the user listeners emulating 'readable' event.
+          _.each(readableListeners, function(listener) {
+            listener();
+          });
+        };
+
+        res.on('readable', onReadable);
+
+      } else {
+
+        //  In all other cases we (for now at least) fall back on intercepting
+        //  'data' events.
+        debug('fall back on our original implementation');
+
+        //  Since we gave client the chance to setup its listeners
+        //  before us, we need to remove them and setup our own.
+        _.each(res.listeners('data'), function(listener) {
+          res.removeListener('data', listener);
+        })
+        _.each(res.listeners('readable'), function(listener) {
+          res.removeListener('readable', listener);
+        })
+
+        var onData = function(data) {
+          debug(thisRecordingId, 'new data chunk on', proto);
+          dataChunks.push(data);
+        };
+        res.on('data', onData);
+      }
+      
+      debug('finished setting up intercepting');
+        
+      if (proto === 'https') {
+        options._https_ = true;
+      }
+
     });
 
     var oldWrite = req.write;

package/lib/scope.js

@@ -30,6 +30,8 @@ function startScope(basePath, options) {
       urlParts = url.parse(basePath),
       port = urlParts.port || ((urlParts.protocol === 'http:') ? 80 : 443),
       persist = false,
+      contentLen = false,
+      date = null,
       basePathname = urlParts.pathname.replace(/\/$/, '');
 
   basePath = urlParts.protocol + '//' + urlParts.hostname + ':' + port;
@@ -75,6 +77,11 @@ function startScope(basePath, options) {
         headers = mixin(scope._defaultReplyHeaders, headers);
       }
 
+      if (date) {
+        headers = headers || {};
+        headers['date'] = date.toUTCString();
+      }
+
       if (headers !== undefined) {
         this.headers = {};
 
@@ -101,6 +108,9 @@ function startScope(basePath, options) {
             if (!this.headers['content-type']) {
               this.headers['content-type'] = 'application/json';
             }
+            if (contentLen) {
+              this.headers['content-length'] = body.length;
+            }
           } catch(err) {
             throw new Error('Error encoding response body into JSON');
           }
@@ -493,6 +503,16 @@ function startScope(basePath, options) {
     return persist;
   }
 
+  function replyContentLength() {
+    contentLen = true;
+    return this;
+  }
+
+  function replyDate(d) {
+    date = d || new Date();
+    return this;
+  }
+
 
   scope = {
       get: get
@@ -513,6 +533,8 @@ function startScope(basePath, options) {
     , persist: _persist
     , shouldPersist: shouldPersist
     , pendingMocks: pendingMocks
+    , replyContentLength: replyContentLength
+    , replyDate: replyDate
   };
 
   return scope;

package/package.json

@@ -7,7 +7,7 @@
     "testing",
     "isolation"
   ],
-  "version": "0.56.0",
+  "version": "0.59.1",
   "author": "Pedro Teixeira <pedro.teixeira@gmail.com>",
   "contributors": [
     {
@@ -116,7 +116,7 @@
     "jshint": "^2.5.6",
     "needle": "^0.7.1",
     "pre-commit": "0.0.9",
-    "request": "*",
+    "request": "2.51.0",
     "restler": "3.2.2",
     "restify": "^2.8.1",
     "superagent": "~0.15.7",

package/tests/test_https_allowunmocked.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var test          = require('tap').test;
+var mikealRequest = require('request');
+
+test('allowUnmock for https', function(t) {
+  var nock = require('../');
+  var scope = nock('https://www.google.com/', {allowUnmocked: true})
+  .get('/pathneverhit')
+  .reply(200, {foo: 'bar'});
+
+  var options = {
+    method: 'GET',
+    uri: 'https://www.google.com'
+  };
+
+  mikealRequest(options, function(err, resp, body) {
+    t.notOk(err, 'should be no error');
+    t.true(typeof body !== 'undefined', 'body should not be undefined');
+    t.true(body.length !== 0, 'body should not be empty');
+    t.end();
+    return console.log(resp.statusCode, 'body length: ', body.length);
+  });
+});

package/tests/test_intercept.js

@@ -340,6 +340,34 @@ test("post with regexp as spec", function(t) {
     req.end();
 });
 
+test("post with function as spec", function(t) {
+    var scope = nock('http://www.google.com')
+        .post('/echo', function(body) {
+          return body === 'key=val';
+        })
+        .reply(200, function(uri, body) {
+            return ['OK', uri, body].join(' ');
+        });
+
+    var req = http.request({
+        host: "www.google.com"
+        , method: 'POST'
+        , path: '/echo'
+        , port: 80
+    }, function(res) {
+        res.on('end', function() {
+            scope.done();
+            t.end();
+        });
+        res.on('data', function(data) {
+            t.equal(data.toString(), 'OK /echo key=val' , 'response should match');
+        });
+    });
+
+    req.write('key=val');
+    req.end();
+});
+
 test("post with chaining on call", function(t) {
   var input = 'key=val';
 
@@ -1035,6 +1063,8 @@ test("reply with JSON", function(t) {
 
     res.setEncoding('utf8');
     t.equal(res.statusCode, 200);
+    t.notOk(res.headers['date']);
+    t.notOk(res.headers['content-length']);
     t.equal(res.headers['content-type'], 'application/json');
     res.on('end', function() {
       t.ok(dataCalled);
@@ -1052,6 +1082,47 @@ test("reply with JSON", function(t) {
 
 });
 
+test("reply with content-length header", function(t){
+  var scope = nock('http://www.jsonreplier.com')
+    .replyContentLength()
+    .get('/')
+    .reply(200, {hello: "world"});
+
+  var req = http.get({
+      host: "www.jsonreplier.com"
+    , path: '/'
+    , port: 80
+  }, function(res) {
+    t.equal(res.headers['content-length'], 17);
+    res.on('end', function() {
+      scope.done();
+      t.end();
+    });
+  });
+});
+
+test("reply with date header", function(t){
+  var date = new Date();
+
+  var scope = nock('http://www.jsonreplier.com')
+    .replyDate(date)
+    .get('/')
+    .reply(200, {hello: "world"});
+
+  var req = http.get({
+    host: "www.jsonreplier.com"
+    , path: '/'
+    , port: 80
+  }, function(res) {
+    console.error(res.headers);
+    t.equal(res.headers['date'], date.toUTCString());
+    res.on('end', function() {
+      scope.done();
+      t.end();
+    });
+  });
+});
+
 test("filter path with function", function(t) {
   var scope = nock('http://www.filterurls.com')
      .filteringPath(function(path) {

package/tests/test_recorder.js

@@ -543,24 +543,88 @@ tap.test('records request headers except user-agent if enable_reqheaders_recordi
 });
 
 tap.test('includes query parameters from superagent', function(t) {
-    nock.restore();
-    nock.recorder.clear();
-    t.equal(nock.recorder.play().length, 0);
+  nock.restore();
+  nock.recorder.clear();
+  t.equal(nock.recorder.play().length, 0);
 
-    nock.recorder.rec({
-        dont_print: true,
-        output_objects: true
+  nock.recorder.rec({
+    dont_print: true,
+    output_objects: true
+  });
+
+  superagent.get('http://google.com')
+    .query({q: 'test search' })
+    .end(function(res) {
+      nock.restore();
+      var ret = nock.recorder.play();
+      t.true(ret.length >= 1);
+      t.equal(ret[0].path, '/?q=test%20search');
+      t.end();
     });
+});
+
+tap.test('works with clients listening for readable', function(t) {
+  nock.restore();
+  nock.recorder.clear();
+  t.equal(nock.recorder.play().length, 0);
+
+  var REQUEST_BODY = 'ABCDEF';
+  var RESPONSE_BODY = '012345';
+
+  //  Create test http server and perform the tests while it's up.
+  var testServer = http.createServer(function (req, res) {
+    res.write(RESPONSE_BODY);
+    res.end();
+  }).listen(8081, function(err) {
+
+    // t.equal(err, undefined);
+
+    var options = { host:'localhost'
+                  , port:testServer.address().port
+                  , path:'/' }
+    ;
+
+    var rec_options = {
+      dont_print: true,
+      output_objects: true
+    };
+
+    nock.recorder.rec(rec_options);
+
+    var req = http.request(options, function(res) {
+      var readableCount = 0;
+      var chunkCount = 0;
+      res.on('readable', function() {
+        ++readableCount;
+        var chunk;
+        while (null !== (chunk = res.read())) {
+          t.equal(chunk.toString(), RESPONSE_BODY);
+          ++chunkCount;
+        }
+      });
+      res.once('end', function() {
+        nock.restore();
+        var ret = nock.recorder.play();
+        t.equal(ret.length, 1);
+        ret = ret[0];
+        t.type(ret, 'object');
+        t.equal(readableCount, 1);
+        t.equal(chunkCount, 1);
+        t.equal(ret.scope, "http://localhost:" + options.port);
+        t.equal(ret.method, "GET");
+        t.equal(ret.body, REQUEST_BODY);
+        t.equal(ret.status, 200);
+        t.equal(ret.response, RESPONSE_BODY);
+        t.end();
+
+        //  Close the test server, we are done with it.
+        testServer.close();
+      });
+    });
+
+    req.end(REQUEST_BODY);
+  });
 
-    superagent.get('http://google.com')
-        .query({q: 'test search' })
-        .end(function(res) {
-            nock.restore();
-            var ret = nock.recorder.play();
-            t.true(ret.length >= 1);
-            t.equal(ret[0].path, '/?q=test%20search');
-            t.end();
-        });
 });
 
 tap.test("teardown", function(t) {
@@ -572,4 +636,4 @@ tap.test("teardown", function(t) {
   }
   t.deepEqual(leaks, [], 'No leaks');
   t.end();
-});
+});

package/tests/test_redirects.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var assert = require('assert');
+var test    = require('tap').test;
+var mikealRequest = require('request');
+var nock    = require('../');
+
+test("follows refirects", function(t) {
+  nock('http://redirecter.com')
+    .get('/YourAccount')
+    .reply(302, undefined, {
+        'Location': 'http://redirecter.com/Login'
+    })
+    .get('/Login')
+    .reply(200, 'Here is the login page');
+
+  mikealRequest('http://redirecter.com/YourAccount', function(err, res, body) {
+    if (err) {
+      throw err;
+    }
+
+    assert.equal(res.statusCode, 200);
+
+    assert.equal(body, 'Here is the login page');
+    t.end();
+  });
+
+});