From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- testing/marionette/error.js | 487 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 487 insertions(+) create mode 100644 testing/marionette/error.js (limited to 'testing/marionette/error.js') diff --git a/testing/marionette/error.js b/testing/marionette/error.js new file mode 100644 index 000000000..97cc3fb25 --- /dev/null +++ b/testing/marionette/error.js @@ -0,0 +1,487 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {interfaces: Ci, utils: Cu} = Components; + +const ERRORS = new Set([ + "ElementClickInterceptedError", + "ElementNotAccessibleError", + "ElementNotInteractableError", + "InsecureCertificateError", + "InvalidArgumentError", + "InvalidElementStateError", + "InvalidSelectorError", + "InvalidSessionIDError", + "JavaScriptError", + "MoveTargetOutOfBoundsError", + "NoAlertOpenError", + "NoSuchElementError", + "NoSuchFrameError", + "NoSuchWindowError", + "ScriptTimeoutError", + "SessionNotCreatedError", + "StaleElementReferenceError", + "TimeoutError", + "UnableToSetCookieError", + "UnknownCommandError", + "UnknownError", + "UnsupportedOperationError", + "WebDriverError", +]); + +const BUILTIN_ERRORS = new Set([ + "Error", + "EvalError", + "InternalError", + "RangeError", + "ReferenceError", + "SyntaxError", + "TypeError", + "URIError", +]); + +this.EXPORTED_SYMBOLS = ["error"].concat(Array.from(ERRORS)); + +this.error = {}; + +/** + * Checks if obj is an instance of the Error prototype in a safe manner. + * Prefer using this over using instanceof since the Error prototype + * isn't unique across browsers, and XPCOM nsIException's are special + * snowflakes. + * + * @param {*} val + * Any value that should be undergo the test for errorness. + * @return {boolean} + * True if error, false otherwise. + */ +error.isError = function (val) { + if (val === null || typeof val != "object") { + return false; + } else if (val instanceof Ci.nsIException) { + return true; + } else { + // DOMRectList errors on string comparison + try { + let proto = Object.getPrototypeOf(val); + return BUILTIN_ERRORS.has(proto.toString()); + } catch (e) { + return false; + } + } +}; + +/** + * Checks if obj is an object in the WebDriverError prototypal chain. + */ +error.isWebDriverError = function (obj) { + return error.isError(obj) && + ("name" in obj && ERRORS.has(obj.name)); +}; + +/** + * Wraps any error as a WebDriverError. If the given error is already in + * the WebDriverError prototype chain, this function returns it + * unmodified. + */ +error.wrap = function (err) { + if (error.isWebDriverError(err)) { + return err; + } + return new WebDriverError(err); +}; + +/** + * Unhandled error reporter. Dumps the error and its stacktrace to console, + * and reports error to the Browser Console. + */ +error.report = function (err) { + let msg = "Marionette threw an error: " + error.stringify(err); + dump(msg + "\n"); + if (Cu.reportError) { + Cu.reportError(msg); + } +}; + +/** + * Prettifies an instance of Error and its stacktrace to a string. + */ +error.stringify = function (err) { + try { + let s = err.toString(); + if ("stack" in err) { + s += "\n" + err.stack; + } + return s; + } catch (e) { + return ""; + } +}; + +/** + * Pretty-print values passed to template strings. + * + * Usage: + * + * let bool = {value: true}; + * error.pprint`Expected boolean, got ${bool}`; + * => 'Expected boolean, got [object Object] {"value": true}' + * + * let htmlElement = document.querySelector("input#foo"); + * error.pprint`Expected element ${htmlElement}`; + * => 'Expected element ' + */ +error.pprint = function (ss, ...values) { + function prettyObject (obj) { + let proto = Object.prototype.toString.call(obj); + let s = ""; + try { + s = JSON.stringify(obj); + } catch (e if e instanceof TypeError) { + s = `<${e.message}>`; + } + return proto + " " + s; + } + + function prettyElement (el) { + let ident = []; + if (el.id) { + ident.push(`id="${el.id}"`); + } + if (el.classList.length > 0) { + ident.push(`class="${el.className}"`); + } + + let idents = ""; + if (ident.length > 0) { + idents = " " + ident.join(" "); + } + + return `<${el.localName}${idents}>`; + } + + let res = []; + for (let i = 0; i < ss.length; i++) { + res.push(ss[i]); + if (i < values.length) { + let val = values[i]; + let typ = Object.prototype.toString.call(val); + let s; + try { + if (val && val.nodeType === 1) { + s = prettyElement(val); + } else { + s = prettyObject(val); + } + } catch (e) { + s = typeof val; + } + res.push(s); + } + } + return res.join(""); +}; + +/** + * WebDriverError is the prototypal parent of all WebDriver errors. + * It should not be used directly, as it does not correspond to a real + * error in the specification. + */ +class WebDriverError extends Error { + /** + * @param {(string|Error)=} x + * Optional string describing error situation or Error instance + * to propagate. + */ + constructor (x) { + super(x); + this.name = this.constructor.name; + this.status = "webdriver error"; + + // Error's ctor does not preserve x' stack + if (error.isError(x)) { + this.stack = x.stack; + } + } + + toJSON () { + return { + error: this.status, + message: this.message || "", + stacktrace: this.stack || "", + } + } + + static fromJSON (json) { + if (typeof json.error == "undefined") { + let s = JSON.stringify(json); + throw new TypeError("Undeserialisable error type: " + s); + } + if (!STATUSES.has(json.error)) { + throw new TypeError("Not of WebDriverError descent: " + json.error); + } + + let cls = STATUSES.get(json.error); + let err = new cls(); + if ("message" in json) { + err.message = json.message; + } + if ("stacktrace" in json) { + err.stack = json.stacktrace; + } + return err; + } +} + +class ElementNotAccessibleError extends WebDriverError { + constructor (message) { + super(message); + this.status = "element not accessible"; + } +} + +/** + * An element click could not be completed because the element receiving + * the events is obscuring the element that was requested clicked. + * + * @param {Element=} obscuredEl + * Element obscuring the element receiving the click. Providing this + * is not required, but will produce a nicer error message. + * @param {Map.} coords + * Original click location. Providing this is not required, but + * will produce a nicer error message. + */ +class ElementClickInterceptedError extends WebDriverError { + constructor (obscuredEl = undefined, coords = undefined) { + let msg = ""; + if (obscuredEl && coords) { + const doc = obscuredEl.ownerDocument; + const overlayingEl = doc.elementFromPoint(coords.x, coords.y); + msg = error.pprint`Element ${obscuredEl} is not clickable ` + + `at point (${coords.x},${coords.y}) ` + + error.pprint`because another element ${overlayingEl} ` + + `obscures it`; + } + + super(msg); + this.status = "element click intercepted"; + } +} + +class ElementNotInteractableError extends WebDriverError { + constructor (message) { + super(message); + this.status = "element not interactable"; + } +} + +class InsecureCertificateError extends WebDriverError { + constructor (message) { + super(message); + this.status = "insecure certificate"; + } +} + +class InvalidArgumentError extends WebDriverError { + constructor (message) { + super(message); + this.status = "invalid argument"; + } +} + +class InvalidElementStateError extends WebDriverError { + constructor (message) { + super(message); + this.status = "invalid element state"; + } +} + +class InvalidSelectorError extends WebDriverError { + constructor (message) { + super(message); + this.status = "invalid selector"; + } +} + +class InvalidSessionIDError extends WebDriverError { + constructor (message) { + super(message); + this.status = "invalid session id"; + } +} + +/** + * Creates a richly annotated error for an error situation that occurred + * whilst evaluating injected scripts. + */ +class JavaScriptError extends WebDriverError { + /** + * @param {(string|Error)} x + * An Error object instance or a string describing the error + * situation. + * @param {string=} fnName + * Name of the function to use in the stack trace message. + * @param {string=} file + * Filename of the test file on the client. + * @param {number=} line + * Line number of |file|. + * @param {string=} script + * Script being executed, in text form. + */ + constructor ( + x, + fnName = undefined, + file = undefined, + line = undefined, + script = undefined) { + let msg = String(x); + let trace = ""; + + if (fnName) { + trace += fnName; + if (file) { + trace += ` @${file}`; + if (line) { + trace += `, line ${line}`; + } + } + } + + if (error.isError(x)) { + let jsStack = x.stack.split("\n"); + let match = jsStack[0].match(/:(\d+):\d+$/); + let jsLine = match ? parseInt(match[1]) : 0; + if (script) { + let src = script.split("\n")[jsLine]; + trace += "\n" + + `inline javascript, line ${jsLine}\n` + + `src: "${src}"`; + } + trace += "\nStack:\n" + x.stack; + } + + super(msg); + this.status = "javascript error"; + this.stack = trace; + } +} + +class MoveTargetOutOfBoundsError extends WebDriverError { + constructor (message) { + super(message); + this.status = "move target out of bounds"; + } +} + +class NoAlertOpenError extends WebDriverError { + constructor (message) { + super(message); + this.status = "no such alert"; + } +} + +class NoSuchElementError extends WebDriverError { + constructor (message) { + super(message); + this.status = "no such element"; + } +} + +class NoSuchFrameError extends WebDriverError { + constructor (message) { + super(message); + this.status = "no such frame"; + } +} + +class NoSuchWindowError extends WebDriverError { + constructor (message) { + super(message); + this.status = "no such window"; + } +} + +class ScriptTimeoutError extends WebDriverError { + constructor (message) { + super(message); + this.status = "script timeout"; + } +} + +class SessionNotCreatedError extends WebDriverError { + constructor (message) { + super(message); + this.status = "session not created"; + } +} + +class StaleElementReferenceError extends WebDriverError { + constructor (message) { + super(message); + this.status = "stale element reference"; + } +} + +class TimeoutError extends WebDriverError { + constructor (message) { + super(message); + this.status = "timeout"; + } +} + +class UnableToSetCookieError extends WebDriverError { + constructor (message) { + super(message); + this.status = "unable to set cookie"; + } +} + +class UnknownCommandError extends WebDriverError { + constructor (message) { + super(message); + this.status = "unknown command"; + } +} + +class UnknownError extends WebDriverError { + constructor (message) { + super(message); + this.status = "unknown error"; + } +} + +class UnsupportedOperationError extends WebDriverError { + constructor (message) { + super(message); + this.status = "unsupported operation"; + } +} + +const STATUSES = new Map([ + ["element not accessible", ElementNotAccessibleError], + ["element not interactable", ElementNotInteractableError], + ["element click intercepted", ElementClickInterceptedError], + ["insecure certificate", InsecureCertificateError], + ["invalid argument", InvalidArgumentError], + ["invalid element state", InvalidElementStateError], + ["invalid selector", InvalidSelectorError], + ["invalid session id", InvalidSessionIDError], + ["javascript error", JavaScriptError], + ["move target out of bounds", MoveTargetOutOfBoundsError], + ["no alert open", NoAlertOpenError], + ["no such element", NoSuchElementError], + ["no such frame", NoSuchFrameError], + ["no such window", NoSuchWindowError], + ["script timeout", ScriptTimeoutError], + ["session not created", SessionNotCreatedError], + ["stale element reference", StaleElementReferenceError], + ["timeout", TimeoutError], + ["unable to set cookie", UnableToSetCookieError], + ["unknown command", UnknownCommandError], + ["unknown error", UnknownError], + ["unsupported operation", UnsupportedOperationError], + ["webdriver error", WebDriverError], +]); -- cgit v1.2.3