cypress-fail-on-console-error 2.1.4 → 3.0.0

package/README.md

@@ -1,6 +1,6 @@
 # cypress-fail-on-console-error
 
-This Plugin observes console.error() function from [window object](https://developer.mozilla.org/de/docs/Web/API/Window). It will automatically fail the executed cypress test as soon as the error function is executed once.
+This Plugin observes `console.error()` function from [window object](https://developer.mozilla.org/de/docs/Web/API/Window). Cypress test will fail when the error function gets executed.
 
 ### Installation
 
@@ -10,7 +10,7 @@ npm install cypress-fail-on-console-error --save-dev
 
 ### Usage
 
-`cypress/support/index.ts`
+`cypress/support/index.js`
 
 ```js
 import failOnConsoleError from 'cypress-fail-on-console-error';
@@ -20,10 +20,11 @@ failOnConsoleError();
 
 ### Config (optional)
 
-| Parameter             | Default               | Description                                                                                                               |
-| --------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| `excludeMessages`     | `undefined`           | Exclude console messages from throwing `assertionError` <br /> String parameter will be interpreted as regular expression |
-| `includeConsoleTypes` | `[consoleType.ERROR]` | Include console types for observation                                                                                     |
+| Parameter             | Default               | Description                                                                                                                                                                                                                                   |
+| --------------------- | --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `excludeMessages`     | `undefined`           | Exclude console messages from throwing `AssertionError` <br /> When `console.error()` contains an error object from `new Error()`, then the whole stacktrace can be matched <br /> String parameter will be interpreted as regular expression |
+| `includeConsoleTypes` | `[consoleType.ERROR]` | Include console types for observation                                                                                                                                                                                                         |
+| `cypressLog`          | `false`               | Include debug logs for `errorMessage_excludeMessage_match` and `errorMessage_excluded` to cypress runner                                                                                                                                      |
 
 <br/>
 
@@ -38,6 +39,7 @@ const config = {
         consoleType.WARN,
         consoleType.INFO,
     ],
+    cypressLog: true,
 };
 
 failOnConsoleError(config);

package/dist/index.d.ts

@@ -5,10 +5,9 @@ export default function failOnConsoleError(config?: Config): void;
 export declare const validateConfig: (config: Config) => void;
 export declare const createConfig: (config: Config) => Config;
 export declare const createSpies: (config: Config, console: Console) => Map<ConsoleType, sinon.SinonSpy>;
-export declare const resetSpies: (spies: Map<ConsoleType, sinon.SinonSpy>) => Map<ConsoleType, sinon.SinonSpy>;
-export declare const someSpyCalled: (spies: Map<ConsoleType, sinon.SinonSpy>) => boolean;
-export declare const getIncludedSpy: (spies: Map<ConsoleType, sinon.SinonSpy>, config: Config) => sinon.SinonSpy | undefined;
-export declare const someIncludedCall: (spy: sinon.SinonSpy, config: Config) => boolean;
-export declare const isExcludedMessage: (excludeMessages: string[], message: string) => boolean;
+export declare const getIncludedCall: (spies: Map<ConsoleType, sinon.SinonSpy>, config: Config) => string | undefined;
+export declare const findIncludedCall: (spy: sinon.SinonSpy, config: Config) => string | undefined;
+export declare const isErrorMessageExcluded: (errorMessage: string, excludeMessage: string, cypressLog: boolean) => boolean;
 export declare const callToString: (calls: any[]) => string;
+export declare const cypressLogger: (name: string, message: any) => void;
 export declare const consoleType: typeof ConsoleType;

package/dist/index.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.consoleType = exports.callToString = exports.isExcludedMessage = exports.someIncludedCall = exports.getIncludedSpy = exports.someSpyCalled = exports.resetSpies = exports.createSpies = exports.createConfig = exports.validateConfig = void 0;
+exports.consoleType = exports.cypressLogger = exports.callToString = exports.isErrorMessageExcluded = exports.findIncludedCall = exports.getIncludedCall = exports.createSpies = exports.createConfig = exports.validateConfig = void 0;
 var chai = __importStar(require("chai"));
 var sinon = __importStar(require("sinon"));
 var sinon_chai_1 = __importDefault(require("sinon-chai"));
@@ -38,21 +38,15 @@ function failOnConsoleError(config) {
     var spies;
     (0, exports.validateConfig)(config);
     config = (0, exports.createConfig)(config);
-    Cypress.on('window:before:load', function (win) {
-        spies = (0, exports.createSpies)(config, win.console);
-    });
-    Cypress.on('command:enqueued', function () {
-        if (spies) {
-            spies = (0, exports.resetSpies)(spies);
-        }
+    Cypress.on('window:before:load', function (window) {
+        spies = (0, exports.createSpies)(config, window.console);
     });
     Cypress.on('command:end', function () {
-        if (!spies || !(0, exports.someSpyCalled)(spies)) {
+        if (!spies)
             return;
-        }
-        var spy = (0, exports.getIncludedSpy)(spies, config);
-        if (spy) {
-            chai.expect(spy).to.have.callCount(0);
+        var errorMessage = (0, exports.getIncludedCall)(spies, config);
+        if (errorMessage) {
+            chai.expect(errorMessage, 'console match found').to.be.undefined;
         }
     });
 }
@@ -68,18 +62,19 @@ var validateConfig = function (config) {
     if (config.includeConsoleTypes) {
         chai.expect(config.includeConsoleTypes).not.to.be.empty;
         config.includeConsoleTypes.forEach(function (_includeConsoleType) {
-            return chai.expect((0, ConsoleType_1.someConsoleType)(_includeConsoleType), "includeConsoleTypes '".concat(_includeConsoleType, "' is an unknown ConsoleType")).to.be.true;
+            chai.expect((0, ConsoleType_1.someConsoleType)(_includeConsoleType), "includeConsoleTypes '".concat(_includeConsoleType, "' is an unknown ConsoleType")).to.be.true;
         });
     }
 };
 exports.validateConfig = validateConfig;
 var createConfig = function (config) {
-    var _a;
+    var _a, _b;
     return ({
         excludeMessages: config.excludeMessages,
         includeConsoleTypes: ((_a = config.includeConsoleTypes) === null || _a === void 0 ? void 0 : _a.length)
             ? config.includeConsoleTypes
             : [ConsoleType_1.ConsoleType.ERROR],
+        cypressLog: (_b = config.cypressLog) !== null && _b !== void 0 ? _b : false,
     });
 };
 exports.createConfig = createConfig;
@@ -93,43 +88,69 @@ var createSpies = function (config, console) {
     return spies;
 };
 exports.createSpies = createSpies;
-var resetSpies = function (spies) {
-    spies.forEach(function (_spy) { return _spy.resetHistory(); });
-    return spies;
-};
-exports.resetSpies = resetSpies;
-var someSpyCalled = function (spies) { return Array.from(spies.values()).some(function (value) { return value.called; }); };
-exports.someSpyCalled = someSpyCalled;
-var getIncludedSpy = function (spies, config) {
-    return Array.from(spies.values()).find(function (spy) { return spy.called && (0, exports.someIncludedCall)(spy, config); });
+var getIncludedCall = function (spies, config) {
+    var errorMessage;
+    Array.from(spies.values()).forEach(function (spy) {
+        if (!spy.called)
+            return;
+        var includedCall = (0, exports.findIncludedCall)(spy, config);
+        if (includedCall !== undefined) {
+            errorMessage = includedCall;
+        }
+    });
+    return errorMessage;
 };
-exports.getIncludedSpy = getIncludedSpy;
-var someIncludedCall = function (spy, config) {
-    if (!config.excludeMessages) {
-        return true;
+exports.getIncludedCall = getIncludedCall;
+var findIncludedCall = function (spy, config) {
+    var errorMessages = spy.args.map(function (call) { return (0, exports.callToString)(call); });
+    if (config.excludeMessages === undefined) {
+        return errorMessages[0];
     }
-    return spy.args.some(function (call) {
-        return !(0, exports.isExcludedMessage)(config.excludeMessages, (0, exports.callToString)(call));
+    return errorMessages.find(function (_errorMessage) {
+        var _isErrorMessageExcluded = config.excludeMessages.some(function (_excludeMessage) {
+            return (0, exports.isErrorMessageExcluded)(_errorMessage, _excludeMessage, config.cypressLog);
+        });
+        if (config.cypressLog === true) {
+            (0, exports.cypressLogger)('errorMessage_excluded', {
+                _errorMessage: _errorMessage,
+                _isErrorMessageExcluded: _isErrorMessageExcluded,
+            });
+        }
+        return !_isErrorMessageExcluded;
     });
 };
-exports.someIncludedCall = someIncludedCall;
-var isExcludedMessage = function (excludeMessages, message) {
-    return excludeMessages.some(function (_excludeMessage) {
-        var _a;
-        var hasMatch = ((_a = message.match(_excludeMessage)) === null || _a === void 0 ? void 0 : _a.length) || 0;
-        return hasMatch > 0;
-    });
+exports.findIncludedCall = findIncludedCall;
+var isErrorMessageExcluded = function (errorMessage, excludeMessage, cypressLog) {
+    var _a;
+    var match = (((_a = errorMessage.match(excludeMessage)) === null || _a === void 0 ? void 0 : _a.length) || 0) > 0;
+    if (cypressLog) {
+        (0, exports.cypressLogger)('errorMessage_excludeMessage_match', {
+            errorMessage: errorMessage,
+            excludeMessage: excludeMessage,
+            match: match,
+        });
+    }
+    return match;
 };
-exports.isExcludedMessage = isExcludedMessage;
+exports.isErrorMessageExcluded = isErrorMessageExcluded;
 var callToString = function (calls) {
     return calls
         .reduce(function (previousValue, currentValue) {
-        var _currentValue = typeof currentValue === 'string'
-            ? currentValue
-            : (currentValue === null || currentValue === void 0 ? void 0 : currentValue.message) || JSON.stringify(currentValue);
+        var _a;
+        var _value = (_a = currentValue === null || currentValue === void 0 ? void 0 : currentValue.stack) !== null && _a !== void 0 ? _a : currentValue;
+        var _currentValue = typeof _value !== 'string' ? JSON.stringify(_value) : _value;
         return "".concat(previousValue, " ").concat(_currentValue);
     }, '')
         .trim();
 };
 exports.callToString = callToString;
+var cypressLogger = function (name, message) {
+    Cypress.log({
+        name: name,
+        displayName: name,
+        message: JSON.stringify(message),
+        consoleProps: function () { return message; },
+    });
+};
+exports.cypressLogger = cypressLogger;
 exports.consoleType = ConsoleType_1.ConsoleType;

package/dist/types/Config.d.ts

@@ -2,4 +2,5 @@ import { ConsoleType } from "./ConsoleType";
 export interface Config {
     excludeMessages?: string[];
     includeConsoleTypes?: ConsoleType[];
+    cypressLog?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cypress-fail-on-console-error",
-  "version": "2.1.4",
+  "version": "3.0.0",
   "description": "fail cypress test on console error",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,15 +8,15 @@
     "dist/**/*"
   ],
   "scripts": {
-    "build": "rm -rf dist/ && tsc",
-    "prettier": "prettier --write '**/*'",
+    "build": "npx rimraf dist/ && tsc",
+    "prettier": "prettier --write \"**/*\"",
     "test": "npm run test:ut && npm run test:it",
     "test:ut": "ts-mocha test/unitTest.ts",
     "test:ut:debug": "ts-mocha --inspect-brk test/unitTest.ts",
     "test:it": "ts-mocha test/integrationTest.ts --timeout 60000",
     "test:it:debug": "cypress open",
     "verify": "npm run build && npm run prettier && npm run test",
-    "ci:prettier": "prettier --check '**/*'"
+    "ci:prettier": "prettier --check \"**/*\""
   },
   "repository": {
     "type": "git",
@@ -49,6 +49,7 @@
     "prettier": "2.6.2",
     "prettier-plugin-organize-imports": "2.3.4",
     "ts-mocha": "10.0.0",
-    "typescript": "4.7.2"
+    "typescript": "4.7.3",
+    "rimraf": "3.0.2"
   }
 }