const { recorder, event } = require("codeceptjs");
|
const Container = require("codeceptjs/lib/container");
|
const { assert } = require("chai");
|
const format = require("util").format;
|
|
const supportedHelpers = ["Playwright"];
|
|
/**
|
* @typedef {boolean|RegExp|RegExp[]} ErrorsFilters
|
*/
|
|
/**
|
* @typedef {Object} ErrorFiltersConfig
|
* @property {ErrorsFilters} [ignore=false] - Should this messages be ignored?
|
* @property {ErrorsFilters} [display=false] - Should this messages be displayed?
|
* @property {ErrorsFilters} [interrupt=false] - Should this messages throw an exception?
|
*/
|
|
/**
|
* @typedef {Object} errorsCollectorConfig
|
* @property {boolean} [collectErrors=true] - Should uncaught errors be collected?
|
* @property {boolean} [collectConsoleErrors=true] - Should console errors be collected?
|
* @property {boolean} [collectConsoleWarning=true] - Should console warnings be collected?
|
* @property {ErrorFiltersConfig} [filter] - Filter config for all cases
|
* @property {ErrorFiltersConfig} [uncaughtErrorFilter] - Filter config for uncaught errors
|
* @property {ErrorFiltersConfig} [consoleErrorFilter] - Filter config for console errors
|
* @property {ErrorFiltersConfig} [consoleWarningFilter] - Filter config for console warnings
|
*/
|
|
const defaultConfig = {
|
collectErrors: true,
|
collectConsoleErrors: true,
|
collectConsoleWarning: true,
|
filter: {
|
ignore: false,
|
display: false,
|
interrupt: false,
|
},
|
uncaughtErrorFilter: {
|
// Ignore not meaningful errors
|
ignore: [/^ResizeObserver loop limit exceeded$/],
|
},
|
};
|
|
const UNCAUGHT_ERROR = "uncaughtError";
|
const CONSOLE_ERROR = "consoleError";
|
const CONSOLE_WARNING = "consoleWarning";
|
|
const IGNORE_ACTION = "ignore";
|
const DISPLAY_ACTION = "display";
|
const INTERRUPT_ACTION = "interrupt";
|
|
/**
|
* Safely get the jsonValue of a JSHandle, handling "Target closed" and other errors.
|
* @param {any} arg - The JSHandle to get the value from
|
* @returns {Promise<any>} - The value, or undefined if target closed, or a fallback string on other errors
|
*/
|
async function safeJsonValue(arg) {
|
try {
|
return await arg.jsonValue();
|
} catch (error) {
|
if (error.message && error.message.includes("Target closed")) return;
|
if (error.message && error.message.includes("Target page, context or browser has been closed")) return;
|
|
console.error(error);
|
}
|
}
|
|
/**
|
* This plugin can monitor three types of errors inside the browser. They are console errors, console warnings and uncaught errors.
|
* Depending on the configuration it could show the problems during the tests and throw exceptions at the scenario level to make the test fail when it is necessary.
|
* @param {errorsCollectorConfig} config
|
*/
|
module.exports = (config) => {
|
const helpers = Container.helpers();
|
// find the first helper which is currently supported
|
const helper = helpers[Object.keys(helpers).find((helper) => supportedHelpers.includes(helper))];
|
|
if (!helper) {
|
console.error(`Errors collector plugin is only supported in ${supportedHelpers.join(", ")}`);
|
return;
|
}
|
|
const options = Object.assign({}, defaultConfig, config);
|
|
for (const key of ["filter", "uncaughtErrorFilter", "consoleErrorFilter", "consoleWarningFilter"]) {
|
options[key] = Object.assign({}, defaultConfig[key], options[key]);
|
}
|
|
function ErrorCollector(page, parent) {
|
this.parent = parent;
|
this.page = page;
|
this.run();
|
}
|
|
ErrorCollector.prototype.testMessage = (filter, message) => {
|
if (typeof filter === "boolean") return filter;
|
if (filter instanceof RegExp) return filter.test(message);
|
if (Array.isArray(filter)) return filter.some((f) => f.test(message));
|
return false;
|
};
|
|
ErrorCollector.prototype.should = function (actionType, messageType, message) {
|
return (
|
this.testMessage(options.filter?.[actionType], message) ||
|
this.testMessage(options[`${messageType}Filter`]?.[actionType], message)
|
);
|
};
|
|
ErrorCollector.prototype.handleMessage = function (type, message) {
|
if (this.should(IGNORE_ACTION, type, message)) return;
|
if (this.should(INTERRUPT_ACTION, type, message)) {
|
this.parent.addError(message);
|
}
|
if (this.should(DISPLAY_ACTION, type, message)) {
|
console.warn(message);
|
}
|
};
|
|
ErrorCollector.prototype.run = function () {
|
const { page } = this;
|
|
page.on("console", async (msg) => {
|
const type = msg.type();
|
let messageType;
|
|
switch (type) {
|
case "error": {
|
messageType = CONSOLE_ERROR;
|
break;
|
}
|
case "warning": {
|
messageType = CONSOLE_WARNING;
|
break;
|
}
|
}
|
if (messageType) {
|
const args = msg.args();
|
|
for (let i = 0; i < args.length; i++) {
|
args[i] = await safeJsonValue(args[i]);
|
if (args[i] === undefined) return; // Target closed, skip processing
|
}
|
|
this.handleMessage(messageType, format(...args));
|
}
|
});
|
|
page.on("pageerror", (exception) => {
|
this.handleMessage(UNCAUGHT_ERROR, exception);
|
});
|
};
|
|
function ErrorCollectors() {
|
this.errors = [];
|
this.collectors = {};
|
}
|
ErrorCollectors.prototype.addError = function (message) {
|
this.errors.push(message);
|
};
|
ErrorCollectors.prototype.isRunningOn = function (page) {
|
return !!this.collectors[page._guid];
|
};
|
ErrorCollectors.prototype.runErrorsCollectorOn = function (page) {
|
this.collectors[page._guid] = new ErrorCollector(page, this);
|
};
|
ErrorCollectors.prototype.reset = function () {
|
this.collectors = {};
|
this.errors = [];
|
};
|
|
const errorCollectors = new ErrorCollectors();
|
|
event.dispatcher.on(event.test.before, async () => {
|
errorCollectors.reset();
|
});
|
|
event.dispatcher.on(event.step.before, async (step) => {
|
if (step.name === "amOnPage") {
|
recorder.add("run collector", async () => {
|
try {
|
if (!errorCollectors.isRunningOn(step.helper.page)) {
|
errorCollectors.runErrorsCollectorOn(step.helper.page);
|
}
|
} catch (err) {
|
console.error(err);
|
}
|
});
|
}
|
});
|
event.dispatcher.on(event.step.after, async () => {
|
recorder.add("check for errors", async () => {
|
for (const err of errorCollectors.errors) {
|
if (err instanceof Error) {
|
assert.fail(err.stack);
|
} else {
|
assert.fail(err);
|
}
|
}
|
});
|
});
|
};
|
|
module.exports.defaultConfig = defaultConfig;
|
