Add methods for checking request headers (#7)

* Add requestedWithHeaders method

* Rename requestedWithHeaders to requestedWithExactHeaders

* Add requestedWithHeaders tests

* fix tests and implementation of requestedWithHeaders

* add requestedWithExactHeaders and requestedWithHeaders to README

* Update readme

* Update exact headers match messages

* 1.1.0

* Revert chai truncate change in requestedWith tests

* Add missing test scenario to requestedWithHeaders

* Install linting deps

* Set linting config

* Make linting changes

* Fix bug in requestedWithHeaders method

* Lint new test files

* Fix requestedWith

* Rename requestedWith to requestedWithExactBody

* Update requestedWithExactBody tests

* Finalise headers methods

* Refactor requestedWitHeaders tests

* Update readme

Author: rkclark

README.md

@@ -17,12 +17,14 @@ nockedRequest.on('request', function(req, interceptor, body) {
 you can write code that expresses what you really mean:
 
 ```javascript
-return expect(nock('http://some-url')).to.have.been.requestedWith({ hello: 'world' });
+return expect(nock('http://some-url')).to.have.been.requestedWith({
+  hello: 'world'
+});
 ```
 
-
 ## Installation
-```npm install chai-nock```
+
+`npm install chai-nock`
 
 Then add to your test setup:
 
@@ -35,21 +37,47 @@ chai.use(chaiNock);
 
 ## Assertions
 
-#### requested
+### `requested`
+
+Asserts that a request has been made to the nock.
+
 ```javascript
 expect(nock).to.have.been.requested;
 expect(nock).not.to.have.been.requested;
 ```
 
-#### requestedWith(body)
+#### Example
+
 ```javascript
-expect(nock).to.have.been.requestedWith(body)
-expect(nock).not.to.have.been.requestedWith(body)
+const { expect } = require('chai');
+const nock = require('nock');
+const request = require('request-promise-native');
+
+describe('example', () => {
+  it('should make a request to bbc.co.uk', function() {
+    const requestNock = nock('http://bbc.co.uk')
+      .get('/')
+      .reply(200);
+
+    request({
+      uri: 'http://bbc.co.uk',
+    });
+
+    return expect(requestNock).to.have.been.requested;
+  });
+});
 ```
 
-## Examples
+### `requestedWith(body)`
+
+Asserts that a request has been made to the nock with a body that exactly matches the object provided.
+
+```javascript
+expect(nock).to.have.been.requestedWith(body);
+expect(nock).not.to.have.been.requestedWith(body);
+```
 
-Using Chai's `expect`:
+#### Example
 
 ```javascript
 const { expect } = require('chai');
@@ -75,5 +103,81 @@ describe('example', () => {
 });
 ```
 
+### `requestedWithHeaders(headers)`
+
+Asserts that a request has been made to the nock with headers that exactly match the object provided.
+
+```javascript
+expect(nock).to.have.been.requestedWithHeaders(headers);
+expect(nock).not.to.have.been.requestedWithHeaders(headers);
+```
+
+#### Example
+
+```javascript
+const { expect } = require('chai');
+const nock = require('nock');
+const request = require('request-promise-native');
+
+describe('example', () => {
+  it('should make a request to bbc.co.uk with exactly correct headers', function() {
+    const requestNock = nock('http://bbc.co.uk')
+      .get('/')
+      .reply(200);
+
+    request({
+      json: true,
+      uri: 'http://bbc.co.uk',
+      headers: {
+        myHeader: 'myHeaderValue'
+      }
+    });
+
+    return expect(requestNock).to.have.been.requestedWithHeaders({
+      host: 'bbc.co.uk',
+      accept: 'application/json',
+      myHeader: 'myHeaderValue'
+    });
+  });
+});
+```
+
+_Note: request-promise-native library adds `host` and `accept` headers from the `uri` and `json` options provided so we need to include them in our exact headers object_
+
+### `requestedWithHeadersMatch(headers)`
 
+Asserts that a request has been made to the nock with headers that contain the key/value pairs in the object provided.
 
+```javascript
+expect(nock).to.have.been.requestedWithHeadersMatch(headers);
+expect(nock).not.to.have.been.requestedWithHeadersMatch(headers);
+```
+
+#### Example
+
+```javascript
+const { expect } = require('chai');
+const nock = require('nock');
+const request = require('request-promise-native');
+
+describe('example', () => {
+  it('should make a request to bbc.co.uk the correct myHeader value in the headers', function() {
+    const requestNock = nock('http://bbc.co.uk')
+      .get('/')
+      .reply(200);
+
+    request({
+      json: true,
+      uri: 'http://bbc.co.uk',
+      headers: {
+        myHeader: 'myHeaderValue',
+        otherHeader: 'otherHeaderValue'
+      }
+    });
+
+    return expect(requestNock).to.have.been.requestedWithHeadersMatch({
+      myHeader: 'myHeaderValue'
+    });
+  });
+});
+```

index.js

@@ -1,4 +1,4 @@
-/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-underscore-dangle, func-names */
 
 const equal = require('deep-equal');
 
@@ -9,22 +9,28 @@ module.exports = chai => {
   function promisfyNockInterceptor(nock) {
     return new Promise((resolve, reject) => {
       let body;
+      let headers;
 
       const timeout = setTimeout(() => {
         reject(new Error('The request has not been recieved by Nock'));
       }, MAX_TIMEOUT);
 
-      nock.once('request', (req, interceptor, reqBody) => {
-        try {
-          body = JSON.parse(reqBody);
-        } catch (err) {
-          body = reqBody;
-        }
-      });
+      nock.once(
+        'request',
+        ({ headers: requestHeaders }, interceptor, reqBody) => {
+          try {
+            headers = requestHeaders;
+
+            body = JSON.parse(reqBody);
+          } catch (err) {
+            body = reqBody;
+          }
+        },
+      );
 
       nock.once('replied', () => {
         clearTimeout(timeout);
-        resolve(body);
+        resolve({ body, headers });
       });
 
       nock.on('error', err => {
@@ -44,8 +50,9 @@ module.exports = chai => {
     }
   }
 
-  Assertion.addProperty('requested', () => {
+  Assertion.addProperty('requested', function() {
     isNock(this._obj);
+
     const assert = value => {
       this.assert(
         value,
@@ -60,25 +67,84 @@ module.exports = chai => {
     );
   });
 
-  Assertion.addMethod('requestedWith', arg => {
+  Assertion.addMethod('requestedWith', function(arg) {
+    isNock(this._obj);
+
+    return promisfyNockInterceptor(this._obj).then(
+      ({ body }) => {
+        if (equal(body, arg)) {
+          return this.assert(
+            true,
+            null,
+            'expected Nock to have not been requested with exact body #{exp}',
+            arg,
+          );
+        }
+        return this.assert(
+          false,
+          'expected Nock to have been requested with exact body #{exp}, but was requested with body #{act}',
+          'expected Nock to have not been requested with exact body #{exp}',
+          arg,
+          body,
+        );
+      },
+      () =>
+        this.assert(
+          false,
+          'expected Nock to have been requested, but it was never called',
+        ),
+    );
+  });
+
+  Assertion.addMethod('requestedWithHeaders', function(arg) {
+    isNock(this._obj);
+
+    return promisfyNockInterceptor(this._obj).then(
+      ({ headers }) => {
+        if (equal(headers, arg)) {
+          return this.assert(
+            true,
+            null,
+            'expected Nock to have not been requested with headers #{exp}',
+            arg,
+          );
+        }
+        return this.assert(
+          false,
+          'expected Nock to have been requested with headers #{exp}, but was requested with headers #{act}',
+          'expected Nock to have not been requested with headers #{exp}',
+          arg,
+          headers,
+        );
+      },
+      () =>
+        this.assert(
+          false,
+          'expected Nock to have been requested, but it was never called',
+        ),
+    );
+  });
+
+  Assertion.addMethod('requestedWithHeadersMatch', function(arg) {
     isNock(this._obj);
 
     return promisfyNockInterceptor(this._obj).then(
-      nockRequest => {
-        if (equal(nockRequest, arg)) {
+      ({ headers }) => {
+        const mergedHeaders = Object.assign({}, headers, arg);
+        if (equal(headers, mergedHeaders)) {
           return this.assert(
             true,
             null,
-            'expected Nock to have not been requested with #{exp}',
+            'expected Nock to have not been requested with headers #{exp}',
             arg,
           );
         }
         return this.assert(
           false,
-          'expected Nock to have been requested with #{exp}, but was requested with #{act}',
-          'expected Nock to have not been requested with #{exp}',
+          'expected Nock to have been requested with headers #{exp}, but was requested with headers #{act}',
+          'expected Nock to have not been requested with headers #{exp}',
           arg,
-          nockRequest,
+          headers,
         );
       },
       () =>

package-lock.json

@@ -1,10 +1,11 @@
 {
   "name": "chai-nock",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Extends Chai with assertions for the Nock Http mocking framework",
   "main": "index.js",
   "scripts": {
     "test": "jest test",
+    "test:watch": "jest test --watch",
     "style": "eslint ."
   },
   "keywords": [

package.json

@@ -2,7 +2,7 @@ const { expect, use } = require('chai');
 const nock = require('nock');
 const request = require('request-promise-native');
 
-const chaiNock = require('../');
+const chaiNock = require('..');
 
 use(chaiNock);
 
@@ -85,7 +85,7 @@ describe('requestedWith() assertions', () => {
           .then(() => done.fail('Should have thrown an error'))
           .catch(err => {
             expect(err.message).to.equal(
-              'expected Nock to have been requested with { test: 2 }, but was requested with { test: 1 }',
+              'expected Nock to have been requested with exact body { test: 2 }, but was requested with body { test: 1 }',
             );
             done();
           });
@@ -166,7 +166,7 @@ describe('requestedWith() assertions', () => {
           .then(() => done.fail('Should have thrown an error'))
           .catch(err => {
             expect(err.message).to.equal(
-              'expected Nock to have not been requested with { test: 12345 }',
+              'expected Nock to have not been requested with exact body { test: 12345 }',
             );
             done();
           });