diff options
Diffstat (limited to 'testing/marionette/test_error.js')
| -rw-r--r-- | testing/marionette/test_error.js | 421 |
1 files changed, 421 insertions, 0 deletions
diff --git a/testing/marionette/test_error.js b/testing/marionette/test_error.js new file mode 100644 index 000000000..f27212637 --- /dev/null +++ b/testing/marionette/test_error.js @@ -0,0 +1,421 @@ +/* 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/. */ + +const {utils: Cu} = Components; + +Cu.import("chrome://marionette/content/error.js"); + +function notok(condition) { + ok(!(condition)); +} + +add_test(function test_isError() { + notok(error.isError(null)); + notok(error.isError([])); + notok(error.isError(new Date())); + + ok(error.isError(new Components.Exception())); + ok(error.isError(new Error())); + ok(error.isError(new EvalError())); + ok(error.isError(new InternalError())); + ok(error.isError(new RangeError())); + ok(error.isError(new ReferenceError())); + ok(error.isError(new SyntaxError())); + ok(error.isError(new TypeError())); + ok(error.isError(new URIError())); + ok(error.isError(new WebDriverError())); + ok(error.isError(new InvalidArgumentError())); + + run_next_test(); +}); + +add_test(function test_isWebDriverError() { + notok(error.isWebDriverError(new Components.Exception())); + notok(error.isWebDriverError(new Error())); + notok(error.isWebDriverError(new EvalError())); + notok(error.isWebDriverError(new InternalError())); + notok(error.isWebDriverError(new RangeError())); + notok(error.isWebDriverError(new ReferenceError())); + notok(error.isWebDriverError(new SyntaxError())); + notok(error.isWebDriverError(new TypeError())); + notok(error.isWebDriverError(new URIError())); + + ok(error.isWebDriverError(new WebDriverError())); + ok(error.isWebDriverError(new InvalidArgumentError())); + ok(error.isWebDriverError(new JavaScriptError())); + + run_next_test(); +}); + +add_test(function test_wrap() { + // webdriver-derived errors should not be wrapped + equal(error.wrap(new WebDriverError()).name, "WebDriverError"); + ok(error.wrap(new WebDriverError()) instanceof WebDriverError); + equal(error.wrap(new InvalidArgumentError()).name, "InvalidArgumentError"); + ok(error.wrap(new InvalidArgumentError()) instanceof WebDriverError); + ok(error.wrap(new InvalidArgumentError()) instanceof InvalidArgumentError); + + // JS errors should be wrapped in WebDriverError + equal(error.wrap(new Error()).name, "WebDriverError"); + ok(error.wrap(new Error()) instanceof WebDriverError); + equal(error.wrap(new EvalError()).name, "WebDriverError"); + equal(error.wrap(new InternalError()).name, "WebDriverError"); + equal(error.wrap(new RangeError()).name, "WebDriverError"); + equal(error.wrap(new ReferenceError()).name, "WebDriverError"); + equal(error.wrap(new SyntaxError()).name, "WebDriverError"); + equal(error.wrap(new TypeError()).name, "WebDriverError"); + equal(error.wrap(new URIError()).name, "WebDriverError"); + + // wrapped JS errors should retain their type + // as part of the message field + equal(error.wrap(new WebDriverError("foo")).message, "foo"); + equal(error.wrap(new TypeError("foo")).message, "TypeError: foo"); + + run_next_test(); +}); + +add_test(function test_stringify() { + equal("<unprintable error>", error.stringify()); + equal("<unprintable error>", error.stringify("foo")); + equal("[object Object]", error.stringify({})); + equal("[object Object]\nfoo", error.stringify({stack: "foo"})); + equal("Error: foo", error.stringify(new Error("foo")).split("\n")[0]); + equal("WebDriverError: foo", + error.stringify(new WebDriverError("foo")).split("\n")[0]); + equal("InvalidArgumentError: foo", + error.stringify(new InvalidArgumentError("foo")).split("\n")[0]); + + run_next_test(); +}); + +add_test(function test_pprint() { + equal('[object Object] {"foo":"bar"}', error.pprint`${{foo: "bar"}}`); + + equal("[object Number] 42", error.pprint`${42}`); + equal("[object Boolean] true", error.pprint`${true}`); + equal("[object Undefined] undefined", error.pprint`${undefined}`); + equal("[object Null] null", error.pprint`${null}`); + + let complexObj = {toJSON: () => "foo"}; + equal('[object Object] "foo"', error.pprint`${complexObj}`); + + let cyclic = {}; + cyclic.me = cyclic; + equal("[object Object] <cyclic object value>", error.pprint`${cyclic}`); + + let el = { + nodeType: 1, + localName: "input", + id: "foo", + classList: {length: 1}, + className: "bar baz", + }; + equal('<input id="foo" class="bar baz">', error.pprint`${el}`); + + run_next_test(); +}); + +add_test(function test_toJSON() { + let e0 = new WebDriverError(); + let e0s = e0.toJSON(); + equal(e0s.error, "webdriver error"); + equal(e0s.message, ""); + equal(e0s.stacktrace, e0.stack); + + let e1 = new WebDriverError("a"); + let e1s = e1.toJSON(); + equal(e1s.message, e1.message); + equal(e1s.stacktrace, e1.stack); + + let e2 = new JavaScriptError("first", "second", "third", "fourth"); + let e2s = e2.toJSON(); + equal(e2.status, e2s.error); + equal(e2.message, e2s.message); + ok(e2s.stacktrace.match(/second/)); + ok(e2s.stacktrace.match(/third/)); + ok(e2s.stacktrace.match(/fourth/)); + + run_next_test(); +}); + +add_test(function test_fromJSON() { + Assert.throws(() => WebDriverError.fromJSON({error: "foo"}), + /Not of WebDriverError descent/); + Assert.throws(() => WebDriverError.fromJSON({error: "Error"}), + /Not of WebDriverError descent/); + Assert.throws(() => WebDriverError.fromJSON({}), + /Undeserialisable error type/); + Assert.throws(() => WebDriverError.fromJSON(undefined), + /TypeError/); + + // stacks will be different + let e1 = new WebDriverError("1"); + let e1r = WebDriverError.fromJSON({error: "webdriver error", message: "1"}); + ok(e1r instanceof WebDriverError); + equal(e1r.name, e1.name); + equal(e1r.status, e1.status); + equal(e1r.message, e1.message); + + // stacks will be different + let e2 = new InvalidArgumentError("2"); + let e2r = WebDriverError.fromJSON({error: "invalid argument", message: "2"}); + ok(e2r instanceof WebDriverError); + ok(e2r instanceof InvalidArgumentError); + equal(e2r.name, e2.name); + equal(e2r.status, e2.status); + equal(e2r.message, e2.message); + + // test stacks + let e3j = {error: "no such element", message: "3", stacktrace: "4"}; + let e3r = WebDriverError.fromJSON(e3j); + ok(e3r instanceof WebDriverError); + ok(e3r instanceof NoSuchElementError); + equal(e3r.name, "NoSuchElementError"); + equal(e3r.status, e3j.error); + equal(e3r.message, e3j.message); + equal(e3r.stack, e3j.stacktrace); + + // parity with toJSON + let e4 = new JavaScriptError("first", "second", "third", "fourth"); + let e4s = e4.toJSON(); + deepEqual(e4, WebDriverError.fromJSON(e4s)); + + run_next_test(); +}); + +add_test(function test_WebDriverError() { + let err = new WebDriverError("foo"); + equal("WebDriverError", err.name); + equal("foo", err.message); + equal("webdriver error", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_ElementClickInterceptedError() { + let otherEl = { + nodeType: 1, + localName: "a", + classList: [], + }; + let obscuredEl = { + nodeType: 1, + localName: "b", + classList: [], + ownerDocument: { + elementFromPoint: function (x, y) { + return otherEl; + }, + }, + }; + + let err = new ElementClickInterceptedError(obscuredEl, {x: 1, y: 2}); + equal("ElementClickInterceptedError", err.name); + equal("Element <b> is not clickable at point (1,2) " + + "because another element <a> obscures it", + err.message); + equal("element click intercepted", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_ElementNotAccessibleError() { + let err = new ElementNotAccessibleError("foo"); + equal("ElementNotAccessibleError", err.name); + equal("foo", err.message); + equal("element not accessible", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_ElementNotInteractableError() { + let err = new ElementNotInteractableError("foo"); + equal("ElementNotInteractableError", err.name); + equal("foo", err.message); + equal("element not interactable", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_InvalidArgumentError() { + let err = new InvalidArgumentError("foo"); + equal("InvalidArgumentError", err.name); + equal("foo", err.message); + equal("invalid argument", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_InvalidElementStateError() { + let err = new InvalidElementStateError("foo"); + equal("InvalidElementStateError", err.name); + equal("foo", err.message); + equal("invalid element state", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_InvalidSelectorError() { + let err = new InvalidSelectorError("foo"); + equal("InvalidSelectorError", err.name); + equal("foo", err.message); + equal("invalid selector", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_InvalidSessionIDError() { + let err = new InvalidSessionIDError("foo"); + equal("InvalidSessionIDError", err.name); + equal("foo", err.message); + equal("invalid session id", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_JavaScriptError() { + let err = new JavaScriptError("foo"); + equal("JavaScriptError", err.name); + equal("foo", err.message); + equal("javascript error", err.status); + ok(err instanceof WebDriverError); + + equal("undefined", new JavaScriptError(undefined).message); + // TODO(ato): Bug 1240550 + //equal("funcname @file", new JavaScriptError("message", "funcname", "file").stack); + equal("funcname @file, line line", + new JavaScriptError("message", "funcname", "file", "line").stack); + + // TODO(ato): More exhaustive tests for JS stack computation + + run_next_test(); +}); + +add_test(function test_NoAlertOpenError() { + let err = new NoAlertOpenError("foo"); + equal("NoAlertOpenError", err.name); + equal("foo", err.message); + equal("no such alert", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_NoSuchElementError() { + let err = new NoSuchElementError("foo"); + equal("NoSuchElementError", err.name); + equal("foo", err.message); + equal("no such element", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_NoSuchFrameError() { + let err = new NoSuchFrameError("foo"); + equal("NoSuchFrameError", err.name); + equal("foo", err.message); + equal("no such frame", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_NoSuchWindowError() { + let err = new NoSuchWindowError("foo"); + equal("NoSuchWindowError", err.name); + equal("foo", err.message); + equal("no such window", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_ScriptTimeoutError() { + let err = new ScriptTimeoutError("foo"); + equal("ScriptTimeoutError", err.name); + equal("foo", err.message); + equal("script timeout", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_SessionNotCreatedError() { + let err = new SessionNotCreatedError("foo"); + equal("SessionNotCreatedError", err.name); + equal("foo", err.message); + equal("session not created", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_StaleElementReferenceError() { + let err = new StaleElementReferenceError("foo"); + equal("StaleElementReferenceError", err.name); + equal("foo", err.message); + equal("stale element reference", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_TimeoutError() { + let err = new TimeoutError("foo"); + equal("TimeoutError", err.name); + equal("foo", err.message); + equal("timeout", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_UnableToSetCookieError() { + let err = new UnableToSetCookieError("foo"); + equal("UnableToSetCookieError", err.name); + equal("foo", err.message); + equal("unable to set cookie", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_UnknownCommandError() { + let err = new UnknownCommandError("foo"); + equal("UnknownCommandError", err.name); + equal("foo", err.message); + equal("unknown command", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_UnknownError() { + let err = new UnknownError("foo"); + equal("UnknownError", err.name); + equal("foo", err.message); + equal("unknown error", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); + +add_test(function test_UnsupportedOperationError() { + let err = new UnsupportedOperationError("foo"); + equal("UnsupportedOperationError", err.name); + equal("foo", err.message); + equal("unsupported operation", err.status); + ok(err instanceof WebDriverError); + + run_next_test(); +}); |