jest-matcher-http 1.1.2 → 1.3.0

package/.eslintrc.js

@@ -80,5 +80,11 @@ module.exports = {
     'jest/valid-title': 'error',
     quotes: [2, 'single', { avoidEscape: true }],
     'comma-dangle': [2, 'always-multiline'],
+    'import/no-extraneous-dependencies': [
+      'error',
+      {
+        devDependencies: ['integration_tests/**'],
+      },
+    ],
   },
 };

package/.github/dependabot.yml

@@ -5,11 +5,11 @@ updates:
     schedule:
       interval: "weekly"
     commit-message:
-      prefix: "fix"
+      prefix: "chore"
 
   - package-ecosystem: "npm"
     directory: "/"
     schedule:
       interval: "daily"
     commit-message:
-      prefix: "fix"
+      prefix: "chore"

package/.github/workflows/test_and_publish.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x, 16.x, 18.x]
+        node-version: [16.x, 18.x]
     steps:
     - uses: actions/checkout@v3
     - name: Use Node.js ${{ matrix.node-version }}

package/README.md

@@ -5,7 +5,7 @@
     <img alt="npm latest version" src="https://img.shields.io/npm/v/jest-matcher-http/latest.svg">
   </a>
   <a href="https://github.com/rimesime/jest-matcher-http/actions?query=workflow%3ATest+branch%3Amain">
-    <img alt="Build states" src="https://github.com/semantic-release/semantic-release/workflows/Test/badge.svg">
+    <img alt="Build states" src="https://github.com/rimesime/jest-matcher-http/workflows/Test/badge.svg">
   </a>
   <a href="#badge">
     <img alt="semantic-release: angular" src="https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release">
@@ -20,7 +20,11 @@ Logs received body and headers if response is not as expected.
 Supported http libraries:
 - [superagent](https://www.npmjs.com/package/superagent)/[supertest](https://www.npmjs.com/package/supertest)
 - [axios](https://www.npmjs.com/package/axios)
-- (more to come)
+- [needle](https://www.npmjs.com/package/needle)
+
+Supported content types:
+- application/json
+- text/plain
 
 # Installation & Configuration
 

package/integration_tests/axios.int.test.js

@@ -1,66 +1,68 @@
 'use strict';
 
-const express = require('express');
-const http = require('http');
 const axios = require('axios');
 
-describe('axios', () => {
-  let server;
-  let url;
-
-  const body = { name: 'john' };
-  const headerName = 'Some';
-  const headerValue = 'Header';
+const { runAgainstServer, staticVariables } = require('./localServer.int.helper');
 
-  let response;
-
-  // eslint-disable-next-line jest/no-done-callback
-  beforeAll((done) => {
-    // eslint-disable-next-line new-cap
-    const app = new express();
-    app.get('/', (req, res) => {
-      res
-        .status(200)
-        .set(headerName, headerValue)
-        .json(body);
-    });
+describe('axios', () => {
+  let responseJson;
+  let responseText;
+  const {
+    resultJson,
+    resultText,
+    headerName,
+    headerValue,
+  } = staticVariables;
 
-    server = http.createServer(app);
-    const listener = server.listen(async () => {
-      url = `http://localhost:${listener.address().port}`;
+  beforeAll(async () => {
+    await runAgainstServer(async (url) => {
       const request = axios.create({ baseURL: url });
-      response = await request.get(`${url}/`);
-      server.close(done);
+      responseJson = await request.get('/json');
+      responseText = await request.get('/text');
     });
   });
 
   describe('toReturnHttpCode', () => {
     it('should succeed if http code is as expected', async () => {
-      expect(response).toReturnHttpCode(200);
+      expect(responseJson).toReturnHttpCode(200);
+    });
+
+    it('should fail if http code is not as expected for application/json responses', async () => {
+      let caughtError;
+      try {
+        expect(responseJson).toReturnHttpCode(500);
+      } catch (error) {
+        caughtError = error;
+      }
+
+      expect(caughtError.message).toContain('expected http status code 200 to equal 500\n');
+      expect(caughtError.message).toContain(`${JSON.stringify(resultJson, null, 2)}\n`);
+      expect(caughtError.message).toContain(`"${headerName.toLowerCase()}": "${headerValue}"`);
     });
 
-    it('should fail if http code is not as expected', async () => {
+    it('should fail if http code is not as expected for plain/text responses', async () => {
       let caughtError;
       try {
-        expect(response).toReturnHttpCode(500);
+        expect(responseText).toReturnHttpCode(500);
       } catch (error) {
         caughtError = error;
       }
 
       expect(caughtError.message).toContain('expected http status code 200 to equal 500\n');
+      expect(caughtError.message).toContain(`${JSON.stringify(resultText, null, 2)}\n`);
       expect(caughtError.message).toContain(`"${headerName.toLowerCase()}": "${headerValue}"`);
     });
   });
 
   describe('toReturnHttpHeader', () => {
     it('should succeed if http header is as expected', async () => {
-      expect(response).toReturnHttpHeader(headerName, headerValue);
+      expect(responseJson).toReturnHttpHeader(headerName, headerValue);
     });
 
     it('should fail if http header is not as expected', async () => {
       let caughtError;
       try {
-        expect(response).toReturnHttpHeader(headerName, '');
+        expect(responseJson).toReturnHttpHeader(headerName, '');
       } catch (error) {
         caughtError = error;
       }
@@ -69,7 +71,7 @@ describe('axios', () => {
         `expected http header "${headerName.toLowerCase()}" with value ""\n`
               + '\n'
               + 'server responded with body:\n'
-              + `${JSON.stringify(body, null, 2)}\n`
+              + `${JSON.stringify(resultJson, null, 2)}\n`
               + '\n'
               + 'server responded with headers:\n',
       );

package/integration_tests/localServer.int.helper.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const express = require('express');
+const http = require('http');
+const { createHttpTerminator } = require('http-terminator');
+const Signal = require('signal-promise');
+
+const resultJson = { name: 'john' };
+const resultText = 'Text';
+const headerName = 'Some';
+const headerValue = 'Header';
+
+/**
+ * Start a simple http server and invoke the given function as
+ * soon as the server is ready.
+ *
+ * @param {Function} func - The (async) function
+ * that is called when http server is ready.
+ */
+async function runAgainstServer(func) {
+  // eslint-disable-next-line new-cap
+  const app = new express();
+  app.get('/json', (req, res) => {
+    res
+      .status(200)
+      .set('Content-Type', 'application/json')
+      .set(headerName, headerValue)
+      .json(resultJson);
+  });
+  app.get('/text', (req, res) => {
+    res
+      .status(200)
+      .set('Content-Type', 'text/plain')
+      .set(headerName, headerValue)
+      .send(resultText);
+  });
+  const server = http.createServer(app);
+  const httpTerminator = createHttpTerminator({ server });
+  const barrier = new Signal();
+  const listener = server.listen(async () => {
+    await func(`http://localhost:${listener.address().port}`);
+    await httpTerminator.terminate();
+    barrier.notify();
+  });
+
+  await barrier.wait();
+}
+
+module.exports = {
+  runAgainstServer,
+  staticVariables: {
+    resultJson,
+    resultText,
+    headerName,
+    headerValue,
+  },
+};

package/integration_tests/needle.int.test.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const needle = require('needle');
+
+const { runAgainstServer, staticVariables } = require('./localServer.int.helper');
+
+describe('needle', () => {
+  let responseJson;
+  let responseText;
+  const {
+    resultJson,
+    resultText,
+    headerName,
+    headerValue,
+  } = staticVariables;
+
+  beforeAll(async () => {
+    await runAgainstServer(async (url) => {
+      responseJson = await needle('get', `${url}/json`);
+      responseText = await needle('get', `${url}/text`);
+    });
+  });
+
+  describe('toReturnHttpCode', () => {
+    it('should succeed if http code is as expected', async () => {
+      expect(responseJson).toReturnHttpCode(200);
+    });
+
+    it('should fail if http code is not as expected for application/json responses', async () => {
+      let caughtError;
+      try {
+        expect(responseJson).toReturnHttpCode(500);
+      } catch (error) {
+        caughtError = error;
+      }
+
+      expect(caughtError.message).toContain('expected http status code 200 to equal 500\n');
+      expect(caughtError.message).toContain(`${JSON.stringify(resultJson, null, 2)}\n`);
+      expect(caughtError.message).toContain(`"${headerName.toLowerCase()}": "${headerValue}"`);
+    });
+
+    it('should fail if http code is not as expected for plain/text responses', async () => {
+      let caughtError;
+      try {
+        expect(responseText).toReturnHttpCode(500);
+      } catch (error) {
+        caughtError = error;
+      }
+
+      expect(caughtError.message).toContain('expected http status code 200 to equal 500\n');
+      expect(caughtError.message).toContain(`${JSON.stringify(resultText, null, 2)}\n`);
+      expect(caughtError.message).toContain(`"${headerName.toLowerCase()}": "${headerValue}"`);
+    });
+  });
+
+  describe('toReturnHttpHeader', () => {
+    it('should succeed if http header is as expected', async () => {
+      expect(responseJson).toReturnHttpHeader(headerName, headerValue);
+    });
+
+    it('should fail if http header is not as expected', async () => {
+      let caughtError;
+      try {
+        expect(responseJson).toReturnHttpHeader(headerName, '');
+      } catch (error) {
+        caughtError = error;
+      }
+
+      expect(caughtError.message).toContain(
+        `expected http header "${headerName.toLowerCase()}" with value ""\n`
+              + '\n'
+              + 'server responded with body:\n'
+              + `${JSON.stringify(resultJson, null, 2)}\n`
+              + '\n'
+              + 'server responded with headers:\n',
+      );
+      expect(caughtError.message).toContain(`"${headerName.toLowerCase()}": "${headerValue}"`);
+    });
+  });
+});

package/integration_tests/superagent.int.test.js

@@ -1,65 +1,67 @@
 'use strict';
 
-const express = require('express');
-const http = require('http');
 const superagent = require('superagent');
 
-describe('superagent', () => {
-  let server;
-  let url;
-
-  const body = { name: 'john' };
-  const headerName = 'Some';
-  const headerValue = 'Header';
+const { runAgainstServer, staticVariables } = require('./localServer.int.helper');
 
-  let response;
-
-  // eslint-disable-next-line jest/no-done-callback
-  beforeAll((done) => {
-    // eslint-disable-next-line new-cap
-    const app = new express();
-    app.get('/', (req, res) => {
-      res
-        .status(200)
-        .set(headerName, headerValue)
-        .json(body);
-    });
+describe('superagent', () => {
+  let responseJson;
+  let responseText;
+  const {
+    resultJson,
+    resultText,
+    headerName,
+    headerValue,
+  } = staticVariables;
 
-    server = http.createServer(app);
-    const listener = server.listen(async () => {
-      url = `http://localhost:${listener.address().port}`;
-      response = await superagent.get(`${url}/`);
-      server.close(done);
+  beforeAll(async () => {
+    await runAgainstServer(async (url) => {
+      responseJson = await superagent.get(`${url}/json`);
+      responseText = await superagent.get(`${url}/text`);
     });
   });
 
   describe('toReturnHttpCode', () => {
     it('should succeed if http code is as expected', async () => {
-      expect(response).toReturnHttpCode(200);
+      expect(responseJson).toReturnHttpCode(200);
+    });
+
+    it('should fail if http code is not as expected for application/json responses', async () => {
+      let caughtError;
+      try {
+        expect(responseJson).toReturnHttpCode(500);
+      } catch (error) {
+        caughtError = error;
+      }
+
+      expect(caughtError.message).toContain('expected http status code 200 to equal 500\n');
+      expect(caughtError.message).toContain(`${JSON.stringify(resultJson, null, 2)}\n`);
+      expect(caughtError.message).toContain(`"${headerName.toLowerCase()}": "${headerValue}"`);
     });
 
-    it('should fail if http code is not as expected', async () => {
+    it('should fail if http code is not as expected for plain/text responses', async () => {
       let caughtError;
       try {
-        expect(response).toReturnHttpCode(500);
+        expect(responseText).toReturnHttpCode(500);
       } catch (error) {
         caughtError = error;
       }
 
       expect(caughtError.message).toContain('expected http status code 200 to equal 500\n');
+      expect(caughtError.message).toContain(`${JSON.stringify(resultText, null, 2)}\n`);
       expect(caughtError.message).toContain(`"${headerName.toLowerCase()}": "${headerValue}"`);
     });
   });
 
   describe('toReturnHttpHeader', () => {
     it('should succeed if http header is as expected', async () => {
-      expect(response).toReturnHttpHeader(headerName, headerValue);
+      expect(responseJson).toReturnHttpHeader(headerName, headerValue);
     });
 
     it('should fail if http header is not as expected', async () => {
       let caughtError;
       try {
-        expect(response).toReturnHttpHeader(headerName, '');
+        expect(responseJson).toReturnHttpHeader(headerName, '');
       } catch (error) {
         caughtError = error;
       }
@@ -68,7 +70,7 @@ describe('superagent', () => {
         `expected http header "${headerName.toLowerCase()}" with value ""\n`
               + '\n'
               + 'server responded with body:\n'
-              + `${JSON.stringify(body, null, 2)}\n`
+              + `${JSON.stringify(resultJson, null, 2)}\n`
               + '\n'
               + 'server responded with headers:\n',
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-matcher-http",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "description": "Additional Jest matchers for HTTP responses.",
   "main": "src/index.js",
   "scripts": {
@@ -41,8 +41,11 @@
     "eslint-plugin-jest": "^27.1.6",
     "eslint-plugin-jsdoc": "^39.6.4",
     "express": "^4.18.2",
+    "http-terminator": "^3.2.0",
     "jest": "^29.3.1",
+    "needle": "^3.2.0",
     "semantic-release": "^19.0.5",
+    "signal-promise": "^1.0.3",
     "superagent": "^8.0.5"
   },
   "dependencies": {

package/src/matchers.js

@@ -1,17 +1,41 @@
 'use strict';
 
+/**
+ * Extract the result from the response.
+ *
+ * @param {object} response - The response of the request.
+ * @returns {object} The result.
+ * @throws {Error} If no result could be extracted.
+ */
+function extractResult(response) {
+  if (response.data) {
+    return response.data;
+  }
+
+  if (response.text && response.text !== JSON.stringify(response.body)) {
+    return response.text;
+  }
+
+  if (response.body) {
+    return response.body;
+  }
+
+  throw new Error('jest-matcher-http does not support this library');
+}
+
 /**
  * Expect a http request to return given http status code.
  * Log response body and headers otherwise.
  *
- * @param {{status: number, body: any, headers: any}} response - The response of the request.
+ * @param {object} response - The response of the request.
  * @param {number} expectedHttpStatusCode - The expected http status code.
  * @returns {{message: Function, pass: boolean}} The expect result according to jest.
  * @see {@link https://jestjs.io/docs/expect#expectextendmatchers}
  */
 function toReturnHttpCode(response, expectedHttpStatusCode) {
-  const body = response.body ?? response.data;
-  const { status, headers } = response;
+  const result = extractResult(response);
+  const status = response.status ?? response.statusCode;
+  const { headers } = response;
 
   const pass = status === expectedHttpStatusCode;
 
@@ -22,7 +46,7 @@ function toReturnHttpCode(response, expectedHttpStatusCode) {
   return {
     pass,
     message: () => `expected http status code ${status} to equal ${expectedHttpStatusCode}\n\n`
-      + `server responded with body:\n${JSON.stringify(body, null, 2)}\n\n`
+      + `server responded with body:\n${JSON.stringify(result, null, 2)}\n\n`
       + `server responded with headers:\n${JSON.stringify(headers, null, 2)}`,
   };
 }
@@ -31,14 +55,14 @@ function toReturnHttpCode(response, expectedHttpStatusCode) {
  * Expect a http request to return the given http header.
  * Log response body and headers otherwise.
  *
- * @param {{body: any, headers: any}} response - The response of the request.
+ * @param {object} response - The response of the request.
  * @param {string} headerField - The expected http header field.
  * @param {string} headerValue - The expected http header value.
  * @returns {{message: Function, pass: boolean}} The expect result according to jest.
  * @see {@link https://jestjs.io/docs/expect#expectextendmatchers}
  */
 function toReturnHttpHeader(response, headerField, headerValue) {
-  const body = response.body ?? response.data;
+  const result = extractResult(response);
   const { headers } = response;
   const headerFieldLowerCase = headerField.toLowerCase();
 
@@ -51,7 +75,7 @@ function toReturnHttpHeader(response, headerField, headerValue) {
   return {
     pass,
     message: () => `expected http header "${headerFieldLowerCase}" with value "${headerValue}"\n\n`
-      + `server responded with body:\n${JSON.stringify(body, null, 2)}\n\n`
+      + `server responded with body:\n${JSON.stringify(result, null, 2)}\n\n`
       + `server responded with headers:\n${JSON.stringify(headers, null, 2)}`,
   };
 }

package/src/matchers.unit.test.js

@@ -2,7 +2,7 @@
 
 describe('matchers', () => {
   describe('toReturnHttpCode', () => {
-    it('should succeed if http code is as expected', async () => {
+    it('should succeed if http code is as expected - status', async () => {
       const response = {
         status: 200,
         body: {},
@@ -12,6 +12,36 @@ describe('matchers', () => {
       expect(response).toReturnHttpCode(response.status);
     });
 
+    it('should succeed if http code is as expected - statusCode', async () => {
+      const response = {
+        statusCode: 200,
+        body: {},
+        headers: {},
+      };
+
+      expect(response).toReturnHttpCode(response.statusCode);
+    });
+
+    it('should succeed if data instead of body provided', async () => {
+      const response = {
+        status: 200,
+        data: {},
+        headers: {},
+      };
+
+      expect(response).toReturnHttpCode(response.status);
+    });
+
+    it('should succeed if result is in text', async () => {
+      const response = {
+        status: 200,
+        text: 'result',
+        headers: {},
+      };
+
+      expect(response).toReturnHttpCode(response.status);
+    });
+
     it('should fail if http code is not as expected', async () => {
       const response = {
         status: 200,
@@ -36,6 +66,22 @@ describe('matchers', () => {
           + '{}',
       );
     });
+
+    it('should throw if result is not supported', async () => {
+      const response = {
+        status: 200,
+        headers: {},
+      };
+
+      let caughtError;
+      try {
+        expect(response).toReturnHttpCode(1);
+      } catch (error) {
+        caughtError = error;
+      }
+
+      expect(caughtError.message).toBe('jest-matcher-http does not support this library');
+    });
   });
 
   describe('toReturnHttpHeader', () => {
@@ -51,6 +97,18 @@ describe('matchers', () => {
       expect(response).toReturnHttpHeader('request-id', 'some-uuid');
     });
 
+    it('should succeed if data instead of body provided', async () => {
+      const response = {
+        status: 200,
+        data: {},
+        headers: {
+          'request-id': 'some-uuid',
+        },
+      };
+
+      expect(response).toReturnHttpHeader('request-id', 'some-uuid');
+    });
+
     it('should fail if http header is not as expected', async () => {
       const response = {
         status: 200,