@tryghost/express-test 0.1.0 → 0.4.0

package/lib/agent.js

@@ -37,7 +37,7 @@ class Agent {
     }
 }
 
-['get', 'post', 'put', 'del'].forEach((method) => {
+['get', 'post', 'put', 'patch', 'delete', 'options', 'head'].forEach((method) => {
     Agent.prototype[method] = function (url, options) {
         if (!url) {
             throw new Error('Cannot make a request without supplying a url'); /* eslint-disable-line no-restricted-syntax */

package/lib/expect-request.js

@@ -1,5 +1,7 @@
 const assert = require('assert');
 const {Request, RequestOptions} = require('./request');
+const {snapshotManager} = require('@tryghost/jest-snapshot');
+const {makeMessageFromMatchMessage} = require('./utils');
 
 class ExpectRequest extends Request {
     constructor(...args) {
@@ -7,6 +9,12 @@ class ExpectRequest extends Request {
     }
 
     expect(callback) {
+        if (typeof callback !== 'function') {
+            throw new Error(/* eslint-disable-line no-restricted-syntax */
+                'express-test expect() requires a callback function, did you mean expectStatus or expectHeader?'
+            );
+        }
+
         const wrapperFn = (response, assertion) => {
             try {
                 callback(response);
@@ -47,6 +55,31 @@ class ExpectRequest extends Request {
 
         return this;
     }
+
+    matchBodySnapshot(properties = {}) {
+        let assertion = {
+            fn: this._assertSnapshot,
+            properties: properties,
+            field: 'body'
+        };
+
+        this._addAssertion(assertion);
+
+        return this;
+    }
+
+    matchHeaderSnapshot(properties = {}) {
+        let assertion = {
+            fn: this._assertSnapshot,
+            properties: properties,
+            field: 'headers'
+        };
+
+        this._addAssertion(assertion);
+
+        return this;
+    }
+
     finalize(callback) {
         super.finalize((error, response) => {
             if (error) {
@@ -71,6 +104,7 @@ class ExpectRequest extends Request {
     }
 
     _addAssertion(assertion) {
+        // We create the error here so that we get a useful stack trace
         let error = new assert.AssertionError({
             message: 'Unexpected assertion error',
             expected: assertion.expected,
@@ -96,17 +130,59 @@ class ExpectRequest extends Request {
     _assertHeader(response, assertion) {
         const {expectedField, expectedValue, error} = assertion;
         const actual = response.headers[expectedField];
+
         const expectedHeaderString = `${expectedField}: ${expectedValue}`;
         const actualHeaderString = `${expectedField}: ${actual}`;
 
         error.expected = expectedHeaderString;
         error.actual = actualHeaderString;
 
-        error.message = `Expected header "${expectedHeaderString}" to exist but got ${JSON.stringify(response.headers)} ${error.contextString}`;
+        error.message = `Expected header "${expectedHeaderString}" to exist, got headers: ${JSON.stringify(response.headers)} ${error.contextString}`;
         assert.notStrictEqual(actual, undefined, error);
 
-        error.message = `Expected header "${expectedHeaderString}", got ${actualHeaderString} ${error.contextString}`;
-        assert.equal(expectedHeaderString, actualHeaderString, error);
+        if (expectedValue instanceof RegExp) {
+            error.expected = expectedValue;
+            error.actual = actual;
+            error.message = `Expected header "${expectedField}" to have value matching "${expectedValue}", got "${actual}" ${error.contextString}`;
+            assert.equal(expectedValue.test(actual), true, error);
+        } else {
+            error.message = `Expected header "${expectedHeaderString}", got "${actualHeaderString}" ${error.contextString}`;
+            assert.equal(expectedHeaderString, actualHeaderString, error);
+        }
+    }
+
+    _assertSnapshot(result, assertion) {
+        const {properties, field, error} = assertion;
+
+        if (!result[field]) {
+            error.message = `Unable to match snapshot on undefined field ${field} ${error.contextString}`;
+            error.expected = field;
+            error.actual = 'undefined';
+            assert.notEqual(result[field], undefined, error);
+        }
+
+        const hint = `[${field}]`;
+        const match = snapshotManager.match(result[field], properties, hint);
+
+        Object.keys(properties).forEach((prop) => {
+            const errorMessage = `"response.${field}" is missing the expected property "${prop}"`;
+            error.message = makeMessageFromMatchMessage(match.message(), errorMessage);
+            error.expected = prop;
+            error.actual = 'undefined';
+            error.showDiff = false; // Disable mocha's diff output as it's already present in match.message()
+
+            assert.notEqual(result[field][prop], undefined, error);
+        });
+
+        if (match.pass !== true) {
+            const errorMessage = `"response.${field}" does not match snapshot.`;
+            error.message = makeMessageFromMatchMessage(match.message(), errorMessage);
+            error.expected = match.expected;
+            error.actual = match.actual;
+            error.showDiff = false; // Disable mocha's diff output as it's already present in match.message()
+        }
+
+        assert.equal(match.pass, true, error);
     }
 }
 

package/lib/request.js

@@ -34,13 +34,17 @@ class Request {
     }
 
     then(resolve, reject) {
-        this.finalize((error, response) => {
-            if (error) {
-                return reject(error);
-            }
-
-            return resolve(response);
+        const self = this;
+        this._fullfilledPromise = new Promise((_resolve, _reject) => {
+            self.finalize((error, result) => {
+                if (error) {
+                    return _reject(error);
+                }
+                return _resolve(result);
+            });
         });
+
+        return this._fullfilledPromise.then(resolve, reject);
     }
 
     /*

package/lib/utils.js

@@ -3,3 +3,9 @@ module.exports.isJSON = function isJSON(mime) {
     // but not /json-seq
     return /[/+]json($|[^-\w])/i.test(mime);
 };
+
+module.exports.makeMessageFromMatchMessage = function makeMessageFromMatchMessage(message, errorMessage) {
+    const messageLines = message.split('\n');
+    messageLines.splice(0, 1, errorMessage);
+    return messageLines.join('\n');
+};

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@tryghost/express-test",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "repository": "https://github.com/TryGhost/framework/tree/main/packages/express-test",
   "author": "Ghost Foundation",
   "license": "MIT",
   "main": "index.js",
   "scripts": {
     "dev": "echo \"Implement me!\"",
-    "test": "NODE_ENV=testing c8 mocha './test/**/*.test.js'",
+    "test": "NODE_ENV=testing c8 mocha --require ./test/utils/overrides.js './test/**/*.test.js'",
     "lint": "eslint . --ext .js --cache",
     "posttest": "yarn lint"
   },
@@ -23,11 +23,12 @@
     "express": "^4.17.2",
     "express-session": "^1.17.2",
     "mocha": "9.2.0",
-    "sinon": "13.0.0"
+    "sinon": "13.0.1"
   },
   "dependencies": {
+    "@tryghost/jest-snapshot": "^0.3.0",
     "cookiejar": "^2.1.3",
     "reqresnext": "^1.6.6"
   },
-  "gitHead": "45777c4b5a010293f529f88aea19a81a896ba266"
+  "gitHead": "5304fb34a2b5dd02f96386fceed34124940ce9ec"
 }