@sapui5/sap.fe.test 1.103.0 → 1.104.1

package/src/sap/fe/test/internal/ConsoleErrorChecker.js

@@ -0,0 +1,241 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define([], function () {
+  "use strict";
+
+  function wrapPatterns(pattern) {
+    if (pattern instanceof RegExp) {
+      return function (message) {
+        return message.match(pattern) !== null;
+      };
+    } else {
+      return function (message) {
+        return message.includes(pattern);
+      };
+    }
+  }
+  /**
+   * List of error message patterns that are always accepted.
+   */
+
+
+  var GLOBALLY_ACCEPTED_ERRORS = ["failed to load JavaScript resource: sap/esh/search/ui/i18n.js" // shell
+  ].map(wrapPatterns);
+
+  var ConsoleErrorChecker = /*#__PURE__*/function () {
+    function ConsoleErrorChecker(window) {
+      var _this = this;
+
+      this.matchers = [];
+      this.messages = [];
+      this.observer = new MutationObserver(function (mutations) {
+        var opaFrame = mutations.reduce(function (iFrame, mutation) {
+          if (iFrame !== null) {
+            return iFrame;
+          }
+
+          for (var _i = 0, _Array$from = Array.from(mutation.addedNodes); _i < _Array$from.length; _i++) {
+            var node = _Array$from[_i];
+
+            if (node instanceof Element) {
+              var element = node.querySelector("#OpaFrame");
+
+              if (element instanceof HTMLIFrameElement && element.contentWindow) {
+                return element;
+              }
+            }
+          }
+
+          return iFrame;
+        }, null);
+
+        if (opaFrame && opaFrame.contentWindow) {
+          _this.prepareWindow(opaFrame.contentWindow);
+        }
+      });
+      QUnit.moduleStart(function () {
+        _this.observer.observe(window.document.body, {
+          childList: true
+        });
+      });
+      QUnit.moduleDone(function () {
+        _this.observer.disconnect();
+      });
+      QUnit.testStart(function () {
+        _this.reset();
+      });
+      QUnit.log(function () {
+        _this.handleFailedMessages();
+      });
+      this.karma = window.__karma__; // either go for Karma config option "ui5.config.strictConsoleErrors" or use URL query parameter "strict"
+
+      var search = new URLSearchParams(window.location.search);
+      var urlParam = search.get("strictConsoleErrors");
+
+      if (urlParam !== null) {
+        this.isStrict = urlParam === "true";
+      } else {
+        var _this$karma$config$ui, _this$karma, _this$karma$config$ui2;
+
+        this.isStrict = (_this$karma$config$ui = (_this$karma = this.karma) === null || _this$karma === void 0 ? void 0 : (_this$karma$config$ui2 = _this$karma.config.ui5) === null || _this$karma$config$ui2 === void 0 ? void 0 : _this$karma$config$ui2.config.strictconsoleerrors) !== null && _this$karma$config$ui !== void 0 ? _this$karma$config$ui : false;
+      }
+
+      this.reset();
+    }
+
+    var _proto = ConsoleErrorChecker.prototype;
+
+    _proto.handleFailedMessages = function handleFailedMessages() {
+      var failedMessages = this.messages;
+      this.messages = [];
+
+      if (failedMessages.length > 0) {
+        QUnit.assert.pushResult({
+          result: false,
+          source: "FE Console Log Check",
+          message: "There were ".concat(failedMessages.length, " unexpected console errors"),
+          actual: failedMessages,
+          expected: []
+        });
+      }
+    };
+
+    _proto.reset = function reset() {
+      this.messages = []; // this sets the default to apply if no allowed patterns are set via setAcceptedErrorPatterns().
+
+      if (this.isStrict) {
+        this.matchers = GLOBALLY_ACCEPTED_ERRORS;
+      } else {
+        this.matchers = [function () {
+          return true;
+        }];
+      }
+    };
+
+    _proto.setAcceptedErrorPatterns = function setAcceptedErrorPatterns(patterns) {
+      if (!patterns || patterns.length === 0) {
+        this.matchers = GLOBALLY_ACCEPTED_ERRORS;
+      } else {
+        this.matchers = patterns.map(wrapPatterns).concat(GLOBALLY_ACCEPTED_ERRORS);
+      }
+    };
+
+    _proto.checkAndLog = function checkAndLog(type) {
+      for (var _len = arguments.length, data = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        data[_key - 1] = arguments[_key];
+      }
+
+      // only check the error messages
+      if (type === "error") {
+        var messageText = data[0];
+        var isAllowed = this.matchers.some(function (matcher) {
+          return matcher(messageText);
+        });
+
+        if (!isAllowed) {
+          this.messages.push(messageText);
+        }
+      }
+
+      if (this.karma) {
+        // wrap the data to facilitate parsing in the backend
+        var wrappedData = data.map(function (d) {
+          return [d];
+        });
+        this.karma.log(type, wrappedData);
+      }
+    };
+
+    _proto.prepareWindow = function prepareWindow(window) {
+      var _this2 = this;
+
+      var console = window.console; // capture console.log(), console.debug(), etc.
+
+      var patchConsoleMethod = function (method) {
+        var fnOriginal = console[method];
+
+        console[method] = function () {
+          for (var _len2 = arguments.length, data = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            data[_key2] = arguments[_key2];
+          }
+
+          _this2.checkAndLog.apply(_this2, [method].concat(data));
+
+          return fnOriginal.apply(console, data);
+        };
+      };
+
+      patchConsoleMethod("log");
+      patchConsoleMethod("debug");
+      patchConsoleMethod("info");
+      patchConsoleMethod("warn");
+      patchConsoleMethod("error"); // capture console.assert()
+      // see https://console.spec.whatwg.org/#assert
+
+      console.assert = function () {
+        var condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+        if (condition) {
+          return;
+        }
+
+        var message = "Assertion failed";
+
+        for (var _len3 = arguments.length, data = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+          data[_key3 - 1] = arguments[_key3];
+        }
+
+        if (data.length === 0) {
+          data.push(message);
+        } else {
+          var first = data[0];
+
+          if (typeof first !== "string") {
+            data.unshift(message);
+          } else {
+            first = "".concat(message, ": ").concat(first);
+            data[0] = first;
+          }
+        }
+
+        console.error.apply(console, data);
+      }; // capture errors
+
+
+      function onPromiseRejection(event) {
+        var _event$reason;
+
+        var message = "UNHANDLED PROMISE REJECTION: ".concat(event.reason);
+        this.checkAndLog("error", message, (_event$reason = event.reason) === null || _event$reason === void 0 ? void 0 : _event$reason.stack);
+      }
+
+      function onError(event) {
+        var message = event.message;
+        this.checkAndLog("error", message, event.filename);
+      }
+
+      window.addEventListener("error", onError.bind(this), {
+        passive: true
+      });
+      window.addEventListener("unhandledrejection", onPromiseRejection.bind(this), {
+        passive: true
+      });
+    };
+
+    ConsoleErrorChecker.getInstance = function getInstance(window) {
+      // the global instance is needed to support multiple tests in a row (in Karma)
+      if (!window.sapFEConsoleErrorChecker) {
+        window.sapFEConsoleErrorChecker = new ConsoleErrorChecker(window);
+      }
+
+      return window.sapFEConsoleErrorChecker;
+    };
+
+    return ConsoleErrorChecker;
+  }();
+
+  return ConsoleErrorChecker.getInstance(window);
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["ConsoleErrorChecker.ts"],"names":["wrapPatterns","pattern","RegExp","message","match","includes","GLOBALLY_ACCEPTED_ERRORS","map","ConsoleErrorChecker","window","matchers","messages","observer","MutationObserver","mutations","opaFrame","reduce","iFrame","mutation","Array","from","addedNodes","node","Element","element","querySelector","HTMLIFrameElement","contentWindow","prepareWindow","QUnit","moduleStart","observe","document","body","childList","moduleDone","disconnect","testStart","reset","log","handleFailedMessages","karma","__karma__","search","URLSearchParams","location","urlParam","get","isStrict","config","ui5","strictconsoleerrors","failedMessages","length","assert","pushResult","result","source","actual","expected","setAcceptedErrorPatterns","patterns","concat","checkAndLog","type","data","messageText","isAllowed","some","matcher","push","wrappedData","d","console","patchConsoleMethod","method","fnOriginal","apply","condition","first","unshift","error","onPromiseRejection","event","reason","stack","onError","filename","addEventListener","bind","passive","getInstance","sapFEConsoleErrorChecker"],"mappings":"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","sourceRoot":".","sourcesContent":["import type { BrowserConsoleLogOptions } from \"karma\";\n\ntype MessageMatcherFunction = (message: string) => boolean;\ntype Karma = {\n\tlog: (level: BrowserConsoleLogOptions[\"level\"], ...data: any[]) => void;\n\tconfig: {\n\t\tui5?: {\n\t\t\tconfig: {\n\t\t\t\tstrictconsoleerrors?: boolean; // Karma options are all lowercase at runtime!\n\t\t\t};\n\t\t};\n\t};\n};\n\nfunction wrapPatterns(pattern: RegExp | string): MessageMatcherFunction {\n\tif (pattern instanceof RegExp) {\n\t\treturn (message) => message.match(pattern) !== null;\n\t} else {\n\t\treturn (message) => message.includes(pattern);\n\t}\n}\n\n/**\n * List of error message patterns that are always accepted.\n */\nconst GLOBALLY_ACCEPTED_ERRORS = [\n\t\"failed to load JavaScript resource: sap/esh/search/ui/i18n.js\" // shell\n].map(wrapPatterns);\n\nclass ConsoleErrorChecker {\n\tprivate matchers: MessageMatcherFunction[] = [];\n\tprivate messages: string[] = [];\n\tprivate readonly karma: Karma | undefined;\n\tprivate readonly isStrict: boolean;\n\n\tprivate readonly observer = new MutationObserver((mutations) => {\n\t\tconst opaFrame = mutations.reduce((iFrame: HTMLIFrameElement | null, mutation: MutationRecord) => {\n\t\t\tif (iFrame !== null) {\n\t\t\t\treturn iFrame;\n\t\t\t}\n\n\t\t\tfor (const node of Array.from(mutation.addedNodes)) {\n\t\t\t\tif (node instanceof Element) {\n\t\t\t\t\tconst element = node.querySelector(\"#OpaFrame\");\n\t\t\t\t\tif (element instanceof HTMLIFrameElement && element.contentWindow) {\n\t\t\t\t\t\treturn element;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn iFrame;\n\t\t}, null);\n\n\t\tif (opaFrame && opaFrame.contentWindow) {\n\t\t\tthis.prepareWindow(opaFrame.contentWindow);\n\t\t}\n\t});\n\n\tconstructor(window: Window & { __karma__?: Karma }) {\n\t\tQUnit.moduleStart(() => {\n\t\t\tthis.observer.observe(window.document.body, { childList: true });\n\t\t});\n\n\t\tQUnit.moduleDone(() => {\n\t\t\tthis.observer.disconnect();\n\t\t});\n\n\t\tQUnit.testStart(() => {\n\t\t\tthis.reset();\n\t\t});\n\n\t\tQUnit.log(() => {\n\t\t\tthis.handleFailedMessages();\n\t\t});\n\n\t\tthis.karma = window.__karma__;\n\n\t\t// either go for Karma config option \"ui5.config.strictConsoleErrors\" or use URL query parameter \"strict\"\n\t\tconst search = new URLSearchParams(window.location.search);\n\t\tconst urlParam = search.get(\"strictConsoleErrors\");\n\t\tif (urlParam !== null) {\n\t\t\tthis.isStrict = urlParam === \"true\";\n\t\t} else {\n\t\t\tthis.isStrict = this.karma?.config.ui5?.config.strictconsoleerrors ?? false;\n\t\t}\n\n\t\tthis.reset();\n\t}\n\n\tprivate handleFailedMessages() {\n\t\tconst failedMessages = this.messages;\n\t\tthis.messages = [];\n\n\t\tif (failedMessages.length > 0) {\n\t\t\tQUnit.assert.pushResult({\n\t\t\t\tresult: false,\n\t\t\t\tsource: \"FE Console Log Check\",\n\t\t\t\tmessage: `There were ${failedMessages.length} unexpected console errors`,\n\t\t\t\tactual: failedMessages,\n\t\t\t\texpected: []\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate reset() {\n\t\tthis.messages = [];\n\n\t\t// this sets the default to apply if no allowed patterns are set via setAcceptedErrorPatterns().\n\t\tif (this.isStrict) {\n\t\t\tthis.matchers = GLOBALLY_ACCEPTED_ERRORS;\n\t\t} else {\n\t\t\tthis.matchers = [() => true];\n\t\t}\n\t}\n\n\tsetAcceptedErrorPatterns(patterns?: (RegExp | string)[]) {\n\t\tif (!patterns || patterns.length === 0) {\n\t\t\tthis.matchers = GLOBALLY_ACCEPTED_ERRORS;\n\t\t} else {\n\t\t\tthis.matchers = patterns.map(wrapPatterns).concat(GLOBALLY_ACCEPTED_ERRORS);\n\t\t}\n\t}\n\n\tprivate checkAndLog(type: BrowserConsoleLogOptions[\"level\"], ...data: any[]) {\n\t\t// only check the error messages\n\t\tif (type === \"error\") {\n\t\t\tconst messageText = data[0];\n\t\t\tconst isAllowed = this.matchers.some((matcher) => matcher(messageText));\n\t\t\tif (!isAllowed) {\n\t\t\t\tthis.messages.push(messageText);\n\t\t\t}\n\t\t}\n\n\t\tif (this.karma) {\n\t\t\t// wrap the data to facilitate parsing in the backend\n\t\t\tconst wrappedData = data.map((d) => [d]);\n\t\t\tthis.karma.log(type, wrappedData);\n\t\t}\n\t}\n\n\tprivate prepareWindow(window: Window) {\n\t\tconst console: Console = (window as any).console;\n\n\t\t// capture console.log(), console.debug(), etc.\n\t\tconst patchConsoleMethod = (method: \"log\" | \"info\" | \"warn\" | \"error\" | \"debug\") => {\n\t\t\tconst fnOriginal = console[method];\n\t\t\tconsole[method] = (...data: any[]): void => {\n\t\t\t\tthis.checkAndLog(method, ...data);\n\t\t\t\treturn fnOriginal.apply(console, data);\n\t\t\t};\n\t\t};\n\n\t\tpatchConsoleMethod(\"log\");\n\t\tpatchConsoleMethod(\"debug\");\n\t\tpatchConsoleMethod(\"info\");\n\t\tpatchConsoleMethod(\"warn\");\n\t\tpatchConsoleMethod(\"error\");\n\n\t\t// capture console.assert()\n\t\t// see https://console.spec.whatwg.org/#assert\n\t\tconsole.assert = function (condition = false, ...data: any[]) {\n\t\t\tif (condition) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst message = \"Assertion failed\";\n\t\t\tif (data.length === 0) {\n\t\t\t\tdata.push(message);\n\t\t\t} else {\n\t\t\t\tlet first = data[0];\n\t\t\t\tif (typeof first !== \"string\") {\n\t\t\t\t\tdata.unshift(message);\n\t\t\t\t} else {\n\t\t\t\t\tfirst = `${message}: ${first}`;\n\t\t\t\t\tdata[0] = first;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconsole.error(...data);\n\t\t};\n\n\t\t// capture errors\n\t\tfunction onPromiseRejection(this: ConsoleErrorChecker, event: PromiseRejectionEvent) {\n\t\t\tconst message = `UNHANDLED PROMISE REJECTION: ${event.reason}`;\n\t\t\tthis.checkAndLog(\"error\", message, event.reason?.stack);\n\t\t}\n\n\t\tfunction onError(this: ConsoleErrorChecker, event: ErrorEvent) {\n\t\t\tconst message = event.message;\n\t\t\tthis.checkAndLog(\"error\", message, event.filename);\n\t\t}\n\n\t\twindow.addEventListener(\"error\", onError.bind(this), { passive: true });\n\t\twindow.addEventListener(\"unhandledrejection\", onPromiseRejection.bind(this), { passive: true });\n\t}\n\n\tstatic getInstance(window: Window & { sapFEConsoleErrorChecker?: ConsoleErrorChecker }): ConsoleErrorChecker {\n\t\t// the global instance is needed to support multiple tests in a row (in Karma)\n\t\tif (!window.sapFEConsoleErrorChecker) {\n\t\t\twindow.sapFEConsoleErrorChecker = new ConsoleErrorChecker(window);\n\t\t}\n\t\treturn window.sapFEConsoleErrorChecker;\n\t}\n}\n\nexport default ConsoleErrorChecker.getInstance(window);\n"]}

package/src/sap/fe/test/internal/ConsoleErrorChecker.ts

@@ -0,0 +1,206 @@
+import type { BrowserConsoleLogOptions } from "karma";
+
+type MessageMatcherFunction = (message: string) => boolean;
+type Karma = {
+	log: (level: BrowserConsoleLogOptions["level"], ...data: any[]) => void;
+	config: {
+		ui5?: {
+			config: {
+				strictconsoleerrors?: boolean; // Karma options are all lowercase at runtime!
+			};
+		};
+	};
+};
+
+function wrapPatterns(pattern: RegExp | string): MessageMatcherFunction {
+	if (pattern instanceof RegExp) {
+		return (message) => message.match(pattern) !== null;
+	} else {
+		return (message) => message.includes(pattern);
+	}
+}
+
+/**
+ * List of error message patterns that are always accepted.
+ */
+const GLOBALLY_ACCEPTED_ERRORS = [
+	"failed to load JavaScript resource: sap/esh/search/ui/i18n.js" // shell
+].map(wrapPatterns);
+
+class ConsoleErrorChecker {
+	private matchers: MessageMatcherFunction[] = [];
+	private messages: string[] = [];
+	private readonly karma: Karma | undefined;
+	private readonly isStrict: boolean;
+
+	private readonly observer = new MutationObserver((mutations) => {
+		const opaFrame = mutations.reduce((iFrame: HTMLIFrameElement | null, mutation: MutationRecord) => {
+			if (iFrame !== null) {
+				return iFrame;
+			}
+
+			for (const node of Array.from(mutation.addedNodes)) {
+				if (node instanceof Element) {
+					const element = node.querySelector("#OpaFrame");
+					if (element instanceof HTMLIFrameElement && element.contentWindow) {
+						return element;
+					}
+				}
+			}
+
+			return iFrame;
+		}, null);
+
+		if (opaFrame && opaFrame.contentWindow) {
+			this.prepareWindow(opaFrame.contentWindow);
+		}
+	});
+
+	constructor(window: Window & { __karma__?: Karma }) {
+		QUnit.moduleStart(() => {
+			this.observer.observe(window.document.body, { childList: true });
+		});
+
+		QUnit.moduleDone(() => {
+			this.observer.disconnect();
+		});
+
+		QUnit.testStart(() => {
+			this.reset();
+		});
+
+		QUnit.log(() => {
+			this.handleFailedMessages();
+		});
+
+		this.karma = window.__karma__;
+
+		// either go for Karma config option "ui5.config.strictConsoleErrors" or use URL query parameter "strict"
+		const search = new URLSearchParams(window.location.search);
+		const urlParam = search.get("strictConsoleErrors");
+		if (urlParam !== null) {
+			this.isStrict = urlParam === "true";
+		} else {
+			this.isStrict = this.karma?.config.ui5?.config.strictconsoleerrors ?? false;
+		}
+
+		this.reset();
+	}
+
+	private handleFailedMessages() {
+		const failedMessages = this.messages;
+		this.messages = [];
+
+		if (failedMessages.length > 0) {
+			QUnit.assert.pushResult({
+				result: false,
+				source: "FE Console Log Check",
+				message: `There were ${failedMessages.length} unexpected console errors`,
+				actual: failedMessages,
+				expected: []
+			});
+		}
+	}
+
+	private reset() {
+		this.messages = [];
+
+		// this sets the default to apply if no allowed patterns are set via setAcceptedErrorPatterns().
+		if (this.isStrict) {
+			this.matchers = GLOBALLY_ACCEPTED_ERRORS;
+		} else {
+			this.matchers = [() => true];
+		}
+	}
+
+	setAcceptedErrorPatterns(patterns?: (RegExp | string)[]) {
+		if (!patterns || patterns.length === 0) {
+			this.matchers = GLOBALLY_ACCEPTED_ERRORS;
+		} else {
+			this.matchers = patterns.map(wrapPatterns).concat(GLOBALLY_ACCEPTED_ERRORS);
+		}
+	}
+
+	private checkAndLog(type: BrowserConsoleLogOptions["level"], ...data: any[]) {
+		// only check the error messages
+		if (type === "error") {
+			const messageText = data[0];
+			const isAllowed = this.matchers.some((matcher) => matcher(messageText));
+			if (!isAllowed) {
+				this.messages.push(messageText);
+			}
+		}
+
+		if (this.karma) {
+			// wrap the data to facilitate parsing in the backend
+			const wrappedData = data.map((d) => [d]);
+			this.karma.log(type, wrappedData);
+		}
+	}
+
+	private prepareWindow(window: Window) {
+		const console: Console = (window as any).console;
+
+		// capture console.log(), console.debug(), etc.
+		const patchConsoleMethod = (method: "log" | "info" | "warn" | "error" | "debug") => {
+			const fnOriginal = console[method];
+			console[method] = (...data: any[]): void => {
+				this.checkAndLog(method, ...data);
+				return fnOriginal.apply(console, data);
+			};
+		};
+
+		patchConsoleMethod("log");
+		patchConsoleMethod("debug");
+		patchConsoleMethod("info");
+		patchConsoleMethod("warn");
+		patchConsoleMethod("error");
+
+		// capture console.assert()
+		// see https://console.spec.whatwg.org/#assert
+		console.assert = function (condition = false, ...data: any[]) {
+			if (condition) {
+				return;
+			}
+
+			const message = "Assertion failed";
+			if (data.length === 0) {
+				data.push(message);
+			} else {
+				let first = data[0];
+				if (typeof first !== "string") {
+					data.unshift(message);
+				} else {
+					first = `${message}: ${first}`;
+					data[0] = first;
+				}
+			}
+
+			console.error(...data);
+		};
+
+		// capture errors
+		function onPromiseRejection(this: ConsoleErrorChecker, event: PromiseRejectionEvent) {
+			const message = `UNHANDLED PROMISE REJECTION: ${event.reason}`;
+			this.checkAndLog("error", message, event.reason?.stack);
+		}
+
+		function onError(this: ConsoleErrorChecker, event: ErrorEvent) {
+			const message = event.message;
+			this.checkAndLog("error", message, event.filename);
+		}
+
+		window.addEventListener("error", onError.bind(this), { passive: true });
+		window.addEventListener("unhandledrejection", onPromiseRejection.bind(this), { passive: true });
+	}
+
+	static getInstance(window: Window & { sapFEConsoleErrorChecker?: ConsoleErrorChecker }): ConsoleErrorChecker {
+		// the global instance is needed to support multiple tests in a row (in Karma)
+		if (!window.sapFEConsoleErrorChecker) {
+			window.sapFEConsoleErrorChecker = new ConsoleErrorChecker(window);
+		}
+		return window.sapFEConsoleErrorChecker;
+	}
+}
+
+export default ConsoleErrorChecker.getInstance(window);

package/src/sap/fe/test/internal/FEArrangements.js

@@ -10,13 +10,14 @@ sap.ui.define(
 		"sap/base/util/UriParameters",
 		"sap/fe/test/Utils",
 		"sap/fe/test/Stubs",
-		"sap/fe/test/BaseArrangements"
+		"sap/fe/test/BaseArrangements",
+		"sap/fe/test/internal/ConsoleErrorChecker"
 	],
-	function(Opa5, OpaBuilder, UriParameters, Utils, Stubs, BaseArrangements) {
+	function (Opa5, OpaBuilder, UriParameters, Utils, Stubs, BaseArrangements, ConsoleErrorChecker) {
 		"use strict";
 
 		return BaseArrangements.extend("sap.fe.test.internal.FEArrangements", {
-			constructor: function(mSettings) {
+			constructor: function (mSettings) {
 				BaseArrangements.call(
 					this,
 					Utils.mergeObjects(
@@ -28,7 +29,7 @@ sap.ui.define(
 				);
 			},
 
-			iResetTestData: function(bIgnoreRedeploy) {
+			iResetTestData: function (bIgnoreRedeploy) {
 				var that = this,
 					oUriParams = new UriParameters(window.location.href),
 					sBackendUrl = oUriParams.get("useBackendUrl"),
@@ -40,26 +41,45 @@ sap.ui.define(
 							: "default";
 
 				return OpaBuilder.create(this)
-					.success(function() {
+					.success(function () {
 						var oResetData = that.resetTestData(),
 							oRedeploy = bIgnoreRedeploy ? Promise.resolve() : jQuery.post(sProxyPrefix + "/redeploy?tenant=" + sTenantID);
 
 						Promise.all([oResetData, oRedeploy])
-							.finally(function() {
+							.finally(function () {
 								bSuccess = true;
 							})
-							.catch(function(oError) {
+							.catch(function (oError) {
 								throw oError;
 							});
 
 						return OpaBuilder.create(this)
-							.check(function() {
+							.check(function () {
 								return bSuccess;
 							})
 							.execute();
 					})
 					.description(Utils.formatMessage("Reset test data on tenant '{0}'", sTenantID))
 					.execute();
+			},
+
+			/**
+			 * Fail the test if there are errors logged to the browser console.
+			 *
+			 * @param {Array<RegExp|string>} [aErrors] The allowed error messages. Either use regular expressions or strings. Pass undefined or an empty array to reject all error messages.
+			 * @returns {*}
+			 */
+			iAcceptTheseErrors: function (aErrors) {
+				return OpaBuilder.create(this)
+					.do(function () {
+						ConsoleErrorChecker.setAcceptedErrorPatterns(aErrors);
+					})
+					.description(
+						!aErrors || aErrors.length === 0
+							? "Do not accept error messages"
+							: Utils.formatMessage("Only accept these error message patterns: {0}", aErrors)
+					)
+					.execute();
 			}
 		});
 	}

package/src/sap/fe/test/library.js

@@ -21,7 +21,7 @@ sap.ui.define(["sap/ui/core/Core", "sap/ui/core/library"], function (Core, _libr
     controls: [],
     elements: [],
     // eslint-disable-next-line no-template-curly-in-string
-    version: "1.103.0",
+    version: "1.104.1",
     noLibraryCSS: true
   });
   return thisLib;