Initial commit

Author: Rush

index.js

@@ -0,0 +1,71 @@
+var nock = require('nock');
+var finalizeEach = require('mocha-finalize-each');
+
+var nockSandbox = module.exports = function(constructorFunction, options) {
+    var nocks = [];
+    var nockFactory = function () {
+        var args = Array.prototype.slice.call(arguments);
+        var nockScope = nock.apply(nock, args);
+        nocks.push(nockScope);
+        return nockScope;
+    };
+
+    nockFactory.begin = function () {
+        nock.disableNetConnect();
+        nock.enableNetConnect(/127\.0\.0\.1|localhost/);
+    };
+
+    if (!(options && options.noAutoBegin)) {
+        nockFactory.begin();
+    }
+
+    nockFactory.cleanAll = function() {
+        nocks.forEach(function(nockScope) {
+            nockScope.interceptors.forEach(function(interceptor) {
+                nock.removeInterceptor(interceptor);
+            });
+        });
+    };
+    nockFactory.done = function() {
+        try {
+            nocks.forEach(function (nockScope) {
+                // will throw if nock is not resolved
+                nockScope.done();
+            });
+        } finally {
+            nockFactory.cleanAll();
+            nock.enableNetConnect();
+        }
+    };
+
+    if(typeof constructorFunction === 'function') {
+        constructorFunction.call(null, nockFactory);
+    }
+
+    return nockFactory;
+};
+
+nockSandbox.createConstructor = function(constructorFunction) {
+    return function() {
+        return module.exports(constructorFunction);
+    };
+};
+
+nockSandbox.setupForMocha = function(mochaContext) {
+    var nocks = nockSandbox(null, { noAutoBegin: true });
+
+    mochaContext.beforeEach(function() {
+       nocks.begin();
+    });
+
+    finalizeEach(mochaContext, function(promise) {
+      return promise.then(function() { return nocks.done(); });
+    });
+
+    mochaContext.afterEach(function() {
+        nocks.cleanAll();
+        nock.enableNetConnect();
+    });
+
+    return nocks;
+};

package.json

@@ -0,0 +1,30 @@
+{
+  "name": "nock-sandbox",
+  "version": "1.0.0",
+  "description": "Clean up nock on demand, for example after each test. Helper function for mocha is provided.",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "keywords": [
+    "nock",
+    "sandbox",
+    "cleanup",
+    "restore",
+    "afterEach",
+    "remove",
+    "mocks",
+    "http"
+  ],
+  "author": "Damian Kaczmarek <rush@tenfold.com>",
+  "license": "MIT",
+  "dependencies": {
+    "mocha-finalize-each": "^1.0.0",
+    "nock": "^9.0.14"
+  },
+  "devDependencies": {
+    "chai": "^4.1.1",
+    "mocha": "^3.5.0",
+    "sinon": "^3.2.1"
+  }
+}

test.js

@@ -0,0 +1,103 @@
+var nockSandbox = require('./');
+var nativeNock = require('nock');
+var expect = require('chai').expect;
+var sinon = require('sinon');
+var finalizeEach = require('mocha-finalize-each');
+
+describe('nock-sandbox', function() {
+    var sinonSandbox;
+    beforeEach(function() {
+        sinonSandbox = sinon.sandbox.create();
+    });
+    afterEach(function() {
+        sinonSandbox.reset();
+    });
+
+    it('should create a nock factory', function() {
+        var nock = nockSandbox();
+        expect(nock).to.be.instanceOf(Function);
+        expect(nock).to.have.property('cleanAll');
+        expect(nock).to.have.property('done');
+        var handle1 = nock('foo');
+        var handle2 = nativeNock('foo');
+        expect(handle1).to.be.instanceOf(handle2.constructor);
+    });
+
+    it('should clean up scope after .done', function() {
+        var nock = nockSandbox();
+        var nockScope = nock('foo');
+        sinon.stub(nockScope, 'done').callsFake(function() {});
+        sinon.stub(nock, 'cleanAll').callsFake(function() {});
+
+        nock.done();
+
+        sinon.assert.calledOnce(nockScope.done);
+        sinon.assert.calledOnce(nock.cleanAll);
+    });
+
+    it('should throw on .done if nock was not used', function() {
+        var nock = nockSandbox();
+        var nockScope = nock('http://foo/bar').get('.').reply(200);
+        expect(function() {
+            nock.done();
+        }).to.throw('Mocks not yet satisfied:');
+    });
+
+    it('should disable netConnect and re-enable it', function() {
+        sinon.stub(nativeNock, 'disableNetConnect').callsFake(function() {})
+        var nock = nockSandbox();
+        sinon.assert.calledOnce(nativeNock.disableNetConnect);
+        sinon.stub(nativeNock, 'enableNetConnect').callsFake(function() {});
+        nock.done();
+        sinon.assert.calledOnce(nativeNock.enableNetConnect);
+    });
+
+    it('should clean up all interceptors after cleanAll', function() {
+        var nock = nockSandbox();
+        var scope = nock('http://localhost:5555');
+        scope.get('/').reply('foo');
+        scope.get('/').reply('bar');
+        expect(scope.interceptors).to.have.length(2);
+        expect(scope.isDone()).to.be.false;
+        nock.cleanAll();
+        expect(scope.isDone()).to.be.true;
+    });
+
+    describe('setupForMocha', function() {
+        var nock = nockSandbox.setupForMocha(this);
+        var beginSpy = sinon.spy(nock, 'begin');
+        var endSpy = sinon.spy(nock, 'done');
+
+        // NOTE: these two tests are dependent on each other
+        it('calls nock.begin before test', function() {
+            sinon.assert.calledOnce(beginSpy);
+        });
+        it('calls nock.begin every test and nock.done', function() {
+            sinon.assert.calledTwice(beginSpy);
+            sinon.assert.calledOnce(endSpy);
+        });        
+    })
+    
+    describe('setupForMocha lets each test fail independently', function() {
+      var nock = nockSandbox.setupForMocha(this);
+      var finalizeError;
+      finalizeEach(this, promise => {
+        return promise.catch(err => {
+          finalizeError = err;
+        });
+      });
+      
+      it('#1 is failing and error recorded', function() {
+        nock('http://foo.com').get('/').reply('foo');
+      });
+      
+      it('#2 is failing and error recorded', function() {
+        nock('http://foo.com').get('/').reply('bar');
+      });
+      
+      afterEach(function() {
+        expect(finalizeError.message).to.contain('Mocks not yet satisfied:');
+      });
+    })
+    
+});