diff options
Diffstat (limited to 'devtools/shared/webconsole/test/chrome')
29 files changed, 3589 insertions, 0 deletions
diff --git a/devtools/shared/webconsole/test/chrome/chrome.ini b/devtools/shared/webconsole/test/chrome/chrome.ini new file mode 100644 index 0000000000..ee903ac727 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/chrome.ini @@ -0,0 +1,34 @@ +[DEFAULT] +tags = devtools +support-files = + common.js + data.json + data.json^headers^ + helper_serviceworker.js + network_requests_iframe.html + sandboxed_iframe.html + console-test-worker.js + !/browser/base/content/test/general/browser_star_hsts.sjs + +[test_basics.html] +[test_cached_messages.html] +[test_consoleapi.html] +[test_consoleapi_innerID.html] +[test_console_assert.html] +[test_console_group_styling.html] +[test_console_serviceworker.html] +[test_console_serviceworker_cached.html] +[test_console_styling.html] +[test_console_timestamp.html] +[test_console_worker.html] +[test_file_uri.html] +[test_jsterm_autocomplete.html] +[test_network_get.html] +skip-if = verify +[test_network_post.html] +[test_network_security-hsts.html] +[test_nsiconsolemessage.html] +[test_object_actor.html] +[test_object_actor_native_getters.html] +[test_object_actor_native_getters_lenient_this.html] +[test_page_errors.html] diff --git a/devtools/shared/webconsole/test/chrome/common.js b/devtools/shared/webconsole/test/chrome/common.js new file mode 100644 index 0000000000..62878d7e60 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/common.js @@ -0,0 +1,274 @@ +/* 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"; + +/* exported attachConsole, attachConsoleToTab, attachConsoleToWorker, + closeDebugger, checkConsoleAPICalls, checkRawHeaders, runTests, nextTest, Ci, Cc, + withActiveServiceWorker, Services, consoleAPICall, createCommandsForTab, FRACTIONAL_NUMBER_REGEX, DevToolsServer */ + +const { require } = ChromeUtils.importESModule( + "resource://devtools/shared/loader/Loader.sys.mjs" +); +const { + DevToolsServer, +} = require("resource://devtools/server/devtools-server.js"); +const { + CommandsFactory, +} = require("resource://devtools/shared/commands/commands-factory.js"); + +// timeStamp are the result of a number in microsecond divided by 1000. +// so we can't expect a precise number of decimals, or even if there would +// be decimals at all. +const FRACTIONAL_NUMBER_REGEX = /^\d+(\.\d{1,3})?$/; + +function attachConsole(listeners) { + return _attachConsole(listeners); +} +function attachConsoleToTab(listeners) { + return _attachConsole(listeners, true); +} +function attachConsoleToWorker(listeners) { + return _attachConsole(listeners, true, true); +} + +var _attachConsole = async function (listeners, attachToTab, attachToWorker) { + try { + function waitForMessage(target) { + return new Promise(resolve => { + target.addEventListener("message", resolve, { once: true }); + }); + } + + // Fetch the console actor out of the expected target + // ParentProcessTarget / WorkerTarget / FrameTarget + let commands, target, worker; + if (!attachToTab) { + commands = await CommandsFactory.forMainProcess(); + target = await commands.descriptorFront.getTarget(); + } else { + commands = await CommandsFactory.forCurrentTabInChromeMochitest(); + // Descriptor's getTarget will only work if the TargetCommand watches for the first top target + await commands.targetCommand.startListening(); + target = await commands.descriptorFront.getTarget(); + if (attachToWorker) { + const workerName = "console-test-worker.js#" + new Date().getTime(); + worker = new Worker(workerName); + await waitForMessage(worker); + + const { workers } = await target.listWorkers(); + target = workers.filter(w => w.url == workerName)[0]; + if (!target) { + console.error( + "listWorkers failed. Unable to find the worker actor\n" + ); + return null; + } + // This is still important to attach workers as target is still a descriptor front + // which "becomes" a target when calling this method: + await target.morphWorkerDescriptorIntoWorkerTarget(); + } + } + + // Attach the Target and the target thread in order to instantiate the console client. + await target.attachThread(); + + const webConsoleFront = await target.getFront("console"); + + // By default the console isn't listening for anything, + // request listeners from here + const response = await webConsoleFront.startListeners(listeners); + return { + state: { + dbgClient: commands.client, + webConsoleFront, + actor: webConsoleFront.actor, + // Keep a strong reference to the Worker to avoid it being + // GCd during the test (bug 1237492). + // eslint-disable-next-line camelcase + _worker_ref: worker, + }, + response, + }; + } catch (error) { + console.error( + `attachConsole failed: ${error.error} ${error.message} - ` + error.stack + ); + } + return null; +}; + +async function createCommandsForTab() { + const commands = await CommandsFactory.forMainProcess(); + await commands.targetCommand.startListening(); + return commands; +} + +function closeDebugger(state, callback) { + const onClose = state.dbgClient.close(); + + state.dbgClient = null; + state.client = null; + + if (typeof callback === "function") { + onClose.then(callback); + } + return onClose; +} + +function checkConsoleAPICalls(consoleCalls, expectedConsoleCalls) { + is( + consoleCalls.length, + expectedConsoleCalls.length, + "received correct number of console calls" + ); + expectedConsoleCalls.forEach(function (message, index) { + info("checking received console call #" + index); + checkConsoleAPICall(consoleCalls[index], expectedConsoleCalls[index]); + }); +} + +function checkConsoleAPICall(call, expected) { + is( + call.arguments?.length || 0, + expected.arguments?.length || 0, + "number of arguments" + ); + + checkObject(call, expected); +} + +function checkObject(object, expected) { + if (object && object.getGrip) { + object = object.getGrip(); + } + + for (const name of Object.keys(expected)) { + const expectedValue = expected[name]; + const value = object[name]; + checkValue(name, value, expectedValue); + } +} + +function checkValue(name, value, expected) { + if (expected === null) { + ok(!value, "'" + name + "' is null"); + } else if (value === undefined) { + ok(false, "'" + name + "' is undefined"); + } else if (value === null) { + ok(false, "'" + name + "' is null"); + } else if ( + typeof expected == "string" || + typeof expected == "number" || + typeof expected == "boolean" + ) { + is(value, expected, "property '" + name + "'"); + } else if (expected instanceof RegExp) { + ok(expected.test(value), name + ": " + expected + " matched " + value); + } else if (Array.isArray(expected)) { + info("checking array for property '" + name + "'"); + checkObject(value, expected); + } else if (typeof expected == "object") { + info("checking object for property '" + name + "'"); + checkObject(value, expected); + } +} + +function checkHeadersOrCookies(array, expected) { + const foundHeaders = {}; + + for (const elem of array) { + if (!(elem.name in expected)) { + continue; + } + foundHeaders[elem.name] = true; + info("checking value of header " + elem.name); + checkValue(elem.name, elem.value, expected[elem.name]); + } + + for (const header in expected) { + if (!(header in foundHeaders)) { + ok(false, header + " was not found"); + } + } +} + +function checkRawHeaders(text, expected) { + const headers = text.split(/\r\n|\n|\r/); + const arr = []; + for (const header of headers) { + const index = header.indexOf(": "); + if (index < 0) { + continue; + } + arr.push({ + name: header.substr(0, index), + value: header.substr(index + 2), + }); + } + + checkHeadersOrCookies(arr, expected); +} + +var gTestState = {}; + +function runTests(tests, endCallback) { + function* driver() { + let lastResult, sendToNext; + for (let i = 0; i < tests.length; i++) { + gTestState.index = i; + const fn = tests[i]; + info("will run test #" + i + ": " + fn.name); + lastResult = fn(sendToNext, lastResult); + sendToNext = yield lastResult; + } + yield endCallback(sendToNext, lastResult); + } + gTestState.driver = driver(); + return gTestState.driver.next(); +} + +function nextTest(message) { + return gTestState.driver.next(message); +} + +function withActiveServiceWorker(win, url, scope) { + const opts = {}; + if (scope) { + opts.scope = scope; + } + return win.navigator.serviceWorker.register(url, opts).then(swr => { + if (swr.active) { + return swr; + } + + // Unfortunately we can't just use navigator.serviceWorker.ready promise + // here. If the service worker is for a scope that does not cover the window + // then the ready promise will never resolve. Instead monitor the service + // workers state change events to determine when its activated. + return new Promise(resolve => { + const sw = swr.waiting || swr.installing; + sw.addEventListener("statechange", function stateHandler(evt) { + if (sw.state === "activated") { + sw.removeEventListener("statechange", stateHandler); + resolve(swr); + } + }); + }); + }); +} + +/** + * + * @param {Front} consoleFront + * @param {Function} consoleCall: A function which calls the consoleAPI, e.g. : + * `() => top.console.log("test")`. + * @returns {Promise} A promise that will be resolved with the packet sent by the server + * in response to the consoleAPI call. + */ +function consoleAPICall(consoleFront, consoleCall) { + const onConsoleAPICall = consoleFront.once("consoleAPICall"); + consoleCall(); + return onConsoleAPICall; +} diff --git a/devtools/shared/webconsole/test/chrome/console-test-worker.js b/devtools/shared/webconsole/test/chrome/console-test-worker.js new file mode 100644 index 0000000000..9e92f6af65 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/console-test-worker.js @@ -0,0 +1,21 @@ +"use strict"; + +console.log("Log from worker init"); + +function f() { + const a = 1; + const b = 2; + const c = 3; + return { a, b, c }; +} + +self.onmessage = function (event) { + if (event.data == "ping") { + f(); + postMessage("pong"); + } else if (event.data?.type == "log") { + console.log(event.data.message); + } +}; + +postMessage("load"); diff --git a/devtools/shared/webconsole/test/chrome/data.json b/devtools/shared/webconsole/test/chrome/data.json new file mode 100644 index 0000000000..eca9d0e796 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/data.json @@ -0,0 +1,5 @@ +{ + "id": "test JSON data", + "myArray": ["foo", "bar", "baz", "biff"], + "veryLong": "foo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo bar" +} diff --git a/devtools/shared/webconsole/test/chrome/data.json^headers^ b/devtools/shared/webconsole/test/chrome/data.json^headers^ new file mode 100644 index 0000000000..bb6b45500f --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/data.json^headers^ @@ -0,0 +1,3 @@ +Content-Type: application/json +x-very-long: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse a ipsum massa. Phasellus at elit dictum libero laoreet sagittis. Phasellus condimentum ultricies imperdiet. Nam eu ligula justo, ut tincidunt quam. Etiam sollicitudin, tortor sed egestas blandit, sapien sem tincidunt nulla, eu luctus libero odio quis leo. Nam elit massa, mattis quis blandit ac, facilisis vitae arcu. Donec vitae dictum neque. Proin ornare nisl at lectus commodo iaculis eget eget est. Quisque scelerisque vestibulum quam sed interdum. +x-very-short: hello world diff --git a/devtools/shared/webconsole/test/chrome/helper_serviceworker.js b/devtools/shared/webconsole/test/chrome/helper_serviceworker.js new file mode 100644 index 0000000000..74092183e2 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/helper_serviceworker.js @@ -0,0 +1,21 @@ +"use strict"; + +console.log("script evaluation"); + +addEventListener("install", function (evt) { + console.log("install event"); +}); + +addEventListener("activate", function (evt) { + console.log("activate event"); +}); + +addEventListener("fetch", function (evt) { + console.log("fetch event: " + evt.request.url); + evt.respondWith(new Response("Hello world")); +}); + +addEventListener("message", function (evt) { + console.log("message event: " + evt.data.message); + evt.source.postMessage({ type: "PONG" }); +}); diff --git a/devtools/shared/webconsole/test/chrome/network_requests_iframe.html b/devtools/shared/webconsole/test/chrome/network_requests_iframe.html new file mode 100644 index 0000000000..6bb806b904 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/network_requests_iframe.html @@ -0,0 +1,66 @@ +<!DOCTYPE HTML> +<html> + <head> + <meta charset="utf-8"> + <title>Console HTTP test page</title> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> + <script type="text/javascript"><!-- + "use strict"; + let setAllowAllCookies = false; + + function makeXhr(method, url, requestBody, callback) { + // On the first call, allow all cookies and set cookies, then resume the actual test + if (!setAllowAllCookies) { + SpecialPowers.pushPrefEnv({"set": [["network.cookie.cookieBehavior", 0]]}, + function() { + setAllowAllCookies = true; + setCookies(); + makeXhrCallback(method, url, requestBody, callback); + }); + } else { + makeXhrCallback(method, url, requestBody, callback); + } + } + + function makeXhrCallback(method, url, requestBody, callback) { + const xmlhttp = new XMLHttpRequest(); + xmlhttp.open(method, url, true); + if (callback) { + xmlhttp.onreadystatechange = function() { + if (xmlhttp.readyState == 4) { + callback(); + } + }; + } + xmlhttp.send(requestBody); + } + + /* exported testXhrGet */ + function testXhrGet(callback, url = "data.json") { + makeXhr("get", url, null, callback); + } + + /* exported testXhrPost */ + function testXhrPost(callback) { + const body = "Hello world! " + (new Array(50)).join("foobaz barr"); + makeXhr("post", "data.json", body, callback); + } + + function setCookies() { + document.cookie = "foobar=fooval"; + document.cookie = "omgfoo=bug768096"; + document.cookie = "badcookie=bug826798=st3fan"; + } + </script> + </head> + <body> + <h1>Web Console HTTP Logging Testpage</h1> + <h2>This page is used to test the HTTP logging.</h2> + + <form action="?" method="post"> + <input name="name" type="text" value="foo bar"><br> + <input name="age" type="text" value="144"><br> + </form> + </body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/sandboxed_iframe.html b/devtools/shared/webconsole/test/chrome/sandboxed_iframe.html new file mode 100644 index 0000000000..55a6224b50 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/sandboxed_iframe.html @@ -0,0 +1,8 @@ +<html> +<head><title>Sandboxed iframe</title></head> +<body> + <iframe id="sandboxed-iframe" + sandbox="allow-scripts" + srcdoc="<script>var foobarObject = {bug1051224: 'sandboxed'};</script>"></iframe> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_basics.html b/devtools/shared/webconsole/test/chrome/test_basics.html new file mode 100644 index 0000000000..761a97bc8d --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_basics.html @@ -0,0 +1,61 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Basic Web Console Actor tests</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Basic Web Console Actor tests</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +async function startTest() +{ + removeEventListener("load", startTest); + + let {state, response} = await attachConsoleToTab(["PageError"]); + is(response.startedListeners.length, 1, "startedListeners.length"); + is(response.startedListeners[0], "PageError", "startedListeners: PageError"); + + await closeDebugger(state); + top.console_ = top.console; + top.console = { lolz: "foo" }; + ({state, response} = await attachConsoleToTab(["PageError", "ConsoleAPI", "foo"])); + + const startedListeners = response.startedListeners; + is(startedListeners.length, 2, "startedListeners.length"); + isnot(startedListeners.indexOf("PageError"), -1, "startedListeners: PageError"); + isnot(startedListeners.indexOf("ConsoleAPI"), -1, + "startedListeners: ConsoleAPI"); + is(startedListeners.indexOf("foo"), -1, "startedListeners: no foo"); + + top.console = top.console_; + response = await state.webConsoleFront.stopListeners(["ConsoleAPI", "foo"]); + + is(response.stoppedListeners.length, 1, "stoppedListeners.length"); + is(response.stoppedListeners[0], "ConsoleAPI", "stoppedListeners: ConsoleAPI"); + await closeDebugger(state); + ({state, response} = await attachConsoleToTab(["ConsoleAPI"])); + + is(response.startedListeners.length, 1, "startedListeners.length"); + is(response.startedListeners[0], "ConsoleAPI", "startedListeners: ConsoleAPI"); + + top.console = top.console_; + delete top.console_; + + closeDebugger(state, function() { + SimpleTest.finish(); + }); +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_cached_messages.html b/devtools/shared/webconsole/test/chrome/test_cached_messages.html new file mode 100644 index 0000000000..12d5069c7d --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_cached_messages.html @@ -0,0 +1,217 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for cached messages</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for cached messages</p> + +<script class="testbody" type="application/javascript"> +"use strict"; + +const { MESSAGE_CATEGORY } = require("devtools/shared/constants"); + +const previousEnabled = window.docShell.cssErrorReportingEnabled; +window.docShell.cssErrorReportingEnabled = true; + +SimpleTest.registerCleanupFunction(() => { + window.docShell.cssErrorReportingEnabled = previousEnabled; +}); + +var ConsoleAPIStorage = Cc["@mozilla.org/consoleAPI-storage;1"] + .getService(Ci.nsIConsoleAPIStorage); +let expectedConsoleCalls = []; +let expectedPageErrors = []; + +function doPageErrors() { + Services.console.reset(); + + expectedPageErrors = [ + { + errorMessage: /fooColor/, + sourceName: /.+/, + category: MESSAGE_CATEGORY.CSS_PARSER, + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: false, + warning: true, + }, + { + errorMessage: /doTheImpossible/, + sourceName: /.+/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + ]; + + let container = document.createElement("script"); + document.body.appendChild(container); + container.textContent = "document.body.style.color = 'fooColor';"; + document.body.removeChild(container); + + SimpleTest.expectUncaughtException(); + + container = document.createElement("script"); + document.body.appendChild(container); + container.textContent = "document.doTheImpossible();"; + document.body.removeChild(container); +} + +function doConsoleCalls() { + ConsoleAPIStorage.clearEvents(); + + top.console.log("foobarBaz-log", undefined); + top.console.info("foobarBaz-info", null); + top.console.warn("foobarBaz-warn", document.body); + + expectedConsoleCalls = [ + { + level: "log", + filename: /test_cached_messages/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: ["foobarBaz-log", { type: "undefined" }], + }, + { + level: "info", + filename: /test_cached_messages/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: ["foobarBaz-info", { type: "null" }], + }, + { + level: "warn", + filename: /test_cached_messages/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: ["foobarBaz-warn", { type: "object", actor: /[a-z]/ }], + }, + ]; +} +</script> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); +var {ConsoleServiceListener} = + require("devtools/server/actors/webconsole/listeners/console-service"); +var {ConsoleAPIListener} = + require("devtools/server/actors/webconsole/listeners/console-api"); + +let consoleAPIListener, consoleServiceListener; +let consoleAPICalls = 0; +let pageErrors = 0; + +async function onConsoleAPICall(message) { + for (const msg of expectedConsoleCalls) { + if (msg.functionName == message.functionName && + msg.filename.test(message.filename)) { + consoleAPICalls++; + break; + } + } + if (consoleAPICalls == expectedConsoleCalls.length) { + await checkConsoleAPICache(); + } +} + +async function onConsoleServiceMessage(message) { + if (!(message instanceof Ci.nsIScriptError)) { + return; + } + for (const msg of expectedPageErrors) { + if (msg.category == message.category && + msg.errorMessage.test(message.errorMessage)) { + pageErrors++; + break; + } + } + if (pageErrors == expectedPageErrors.length) { + await testPageErrors(); + } +} + +function startTest() { + removeEventListener("load", startTest); + + consoleAPIListener = new ConsoleAPIListener(top, onConsoleAPICall); + consoleAPIListener.init(); + + doConsoleCalls(); +} + +async function checkConsoleAPICache() { + consoleAPIListener.destroy(); + consoleAPIListener = null; + const {state} = await attachConsole(["ConsoleAPI"]); + const response = await state.webConsoleFront.getCachedMessages(["ConsoleAPI"]); + onCachedConsoleAPI(state, response); +} + +function onCachedConsoleAPI(state, response) { + const msgs = response.messages; + info("cached console messages: " + msgs.length); + + ok(msgs.length >= expectedConsoleCalls.length, + "number of cached console messages"); + + for (const {message} of msgs) { + for (const expected of expectedConsoleCalls) { + if (expected.filename.test(message.filename)) { + expectedConsoleCalls.splice(expectedConsoleCalls.indexOf(expected)); + checkConsoleAPICall(message, expected); + break; + } + } + } + + is(expectedConsoleCalls.length, 0, "all expected messages have been found"); + + closeDebugger(state, function() { + consoleServiceListener = new ConsoleServiceListener(null, onConsoleServiceMessage); + consoleServiceListener.init(); + doPageErrors(); + }); +} + +async function testPageErrors() { + consoleServiceListener.destroy(); + consoleServiceListener = null; + const {state} = await attachConsole(["PageError"]); + const response = await state.webConsoleFront.getCachedMessages(["PageError"]); + onCachedPageErrors(state, response); +} + +function onCachedPageErrors(state, response) { + const msgs = response.messages; + info("cached page errors: " + msgs.length); + + ok(msgs.length >= expectedPageErrors.length, + "number of cached page errors"); + + for (const {pageError} of msgs) { + for (const expected of expectedPageErrors) { + if (expected.category == pageError.category && + expected.errorMessage.test(pageError.errorMessage)) { + expectedPageErrors.splice(expectedPageErrors.indexOf(expected)); + checkObject(pageError, expected); + break; + } + } + } + + is(expectedPageErrors.length, 0, "all expected messages have been found"); + + closeDebugger(state, function() { + SimpleTest.finish(); + }); +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_console_assert.html b/devtools/shared/webconsole/test/chrome/test_console_assert.html new file mode 100644 index 0000000000..f847d5f5d8 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_console_assert.html @@ -0,0 +1,106 @@ +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for console.group styling with %c</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> + <script> +"use strict"; + +window.onload = async function () { + SimpleTest.waitForExplicitFinish(); + let state; + try { + state = (await attachConsole(["ConsoleAPI"])).state; + const {webConsoleFront} = state; + + await testFalseAssert(webConsoleFront); + await testFalsyAssert(webConsoleFront); + await testUndefinedAssert(webConsoleFront); + await testNullAssert(webConsoleFront); + await testTrueAssert(webConsoleFront); + + } catch (e) { + ok(false, `Error thrown: ${e.message}`); + } + + await closeDebugger(state); + SimpleTest.finish(); +}; + +async function testFalseAssert(consoleFront) { + info(`Testing console.assert(false)`); + const packet = await consoleAPICall( + consoleFront, + () => top.console.assert(false, "assertion is false") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["assertion is false"] + }); +} + +async function testFalsyAssert(consoleFront) { + info(`Testing console.assert(0")`); + const packet = await consoleAPICall( + consoleFront, + () => top.console.assert(0, "assertion is false") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["assertion is false"] + }); +} + +async function testUndefinedAssert(consoleFront) { + info(`Testing console.assert(undefined)`); + const packet = await consoleAPICall( + consoleFront, + () => top.console.assert(undefined, "assertion is false") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["assertion is false"] + }); +} + +async function testNullAssert(consoleFront) { + info(`Testing console.assert(null)`); + const packet = await consoleAPICall( + consoleFront, + () => top.console.assert(null, "assertion is false") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["assertion is false"] + }); +} + +async function testTrueAssert(consoleFront) { + info(`Testing console.assert(true)`); + const onConsoleApiCall = consoleAPICall( + consoleFront, + () => top.console.assert(true, "assertion is false") + ); + + const TIMEOUT = Symbol(); + const onTimeout = new Promise(resolve => setTimeout(() => resolve(TIMEOUT), 1000)); + + const res = await Promise.race([onConsoleApiCall, onTimeout]); + is(res, TIMEOUT, + "There was no consoleAPICall event in response to a truthy console.assert"); +} + + </script> +</head> +<body> + <p id="display"></p> + <div id="content" style="display: none"> + </div> + <pre id="test"> + </pre> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_console_group_styling.html b/devtools/shared/webconsole/test/chrome/test_console_group_styling.html new file mode 100644 index 0000000000..23a93f8b8d --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_console_group_styling.html @@ -0,0 +1,121 @@ +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for console.group styling with %c</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> + <script> +"use strict"; + +window.onload = async function () { + SimpleTest.waitForExplicitFinish(); + let state; + try { + state = (await attachConsole(["ConsoleAPI"])).state + const consoleFront = state.webConsoleFront; + + await testSingleCustomStyleGroup(consoleFront); + await testSingleCustomStyleGroupCollapsed(consoleFront); + await testMultipleCustomStyleGroup(consoleFront); + await testMultipleCustomStyleGroupCollapsed(consoleFront); + await testFormatterWithNoStyleGroup(consoleFront); + await testFormatterWithNoStyleGroupCollapsed(consoleFront); + } catch (e) { + ok(false, `Error thrown: ${e.message}`); + } + + await closeDebugger(state); + SimpleTest.finish(); +}; + +async function testSingleCustomStyleGroup(consoleFront) { + info("Testing console.group with a custom style"); + const packet = await consoleAPICall( + consoleFront, + () => top.console.group("%cfoobar", "color:red") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["foobar"], + styles: ["color:red"] + }); +} + +async function testSingleCustomStyleGroupCollapsed(consoleFront) { + info("Testing console.groupCollapsed with a custom style"); + const packet = await consoleAPICall( + consoleFront, + () => top.console.groupCollapsed("%cfoobaz", "color:blue") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["foobaz"], + styles: ["color:blue"] + }); +} + +async function testMultipleCustomStyleGroup(consoleFront) { + info("Testing console.group with multiple custom styles"); + const packet = await consoleAPICall( + consoleFront, + () => top.console.group("%cfoo%cbar", "color:red", "color:blue") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["foo", "bar"], + styles: ["color:red", "color:blue"] + }); +} + +async function testMultipleCustomStyleGroupCollapsed(consoleFront) { + info("Testing console.groupCollapsed with multiple custom styles"); + const packet = await consoleAPICall( + consoleFront, + () => top.console.group("%cfoo%cbaz", "color:red", "color:green") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["foo", "baz"], + styles: ["color:red", "color:green"] + }); +} + +async function testFormatterWithNoStyleGroup(consoleFront) { + info("Testing console.group with one formatter but no style"); + const packet = await consoleAPICall( + consoleFront, + () => top.console.group("%cfoobar") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["%cfoobar"], + }); + is(packet.message.styles, undefined, "No 'styles' property"); +} + +async function testFormatterWithNoStyleGroupCollapsed(consoleFront) { + info("Testing console.groupCollapsed with one formatter but no style"); + const packet = await consoleAPICall( + consoleFront, + () => top.console.groupCollapsed("%cfoobaz") + ); + + checkConsoleAPICall(packet.message, { + arguments: ["%cfoobaz"], + }); + is(packet.message.styles, undefined, "No 'styles' property"); +} + + </script> +</head> +<body> + <p id="display"></p> + <div id="content" style="display: none"> + </div> + <pre id="test"> + </pre> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_console_serviceworker.html b/devtools/shared/webconsole/test/chrome/test_console_serviceworker.html new file mode 100644 index 0000000000..33b6ba1457 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_console_serviceworker.html @@ -0,0 +1,202 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for the Console API and Service Workers</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the Console API and Service Workers</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +// Utils functions +function withFrame(url) { + return new Promise(resolve => { + const iframe = document.createElement("iframe"); + iframe.onload = function () { + resolve(iframe); + }; + iframe.src = url; + document.body.appendChild(iframe); + }); +} + +function navigateFrame(iframe, url) { + return new Promise(resolve => { + iframe.onload = function () { + resolve(iframe); + }; + iframe.src = url; + }); +} + +function forceReloadFrame(iframe) { + return new Promise(resolve => { + iframe.onload = function () { + resolve(iframe); + }; + iframe.contentWindow.location.reload(true); + }); +} + +function messageServiceWorker(win, scope, message) { + return win.navigator.serviceWorker.getRegistration(scope).then(swr => { + return new Promise(resolve => { + win.navigator.serviceWorker.onmessage = evt => { + resolve(); + }; + const sw = swr.active || swr.waiting || swr.installing; + sw.postMessage({ type: "PING", message }); + }); + }); +} + +function unregisterServiceWorker(win) { + return win.navigator.serviceWorker.ready.then(swr => { + return swr.unregister(); + }); +} + +// Test +const BASE_URL = "https://example.com/chrome/devtools/shared/webconsole/test/chrome/"; +const SERVICE_WORKER_URL = BASE_URL + "helper_serviceworker.js"; +const SCOPE = BASE_URL + "foo/"; +const NONSCOPE_FRAME_URL = BASE_URL + "sandboxed_iframe.html"; +const SCOPE_FRAME_URL = SCOPE + "fake.html"; +const SCOPE_FRAME_URL2 = SCOPE + "whatsit.html"; +const MESSAGE = 'Tic Tock'; + +const expectedConsoleCalls = [ + { + level: "log", + filename: /helper_serviceworker/, + arguments: ['script evaluation'], + }, + { + level: "log", + filename: /helper_serviceworker/, + arguments: ['install event'], + }, + { + level: "log", + filename: /helper_serviceworker/, + arguments: ['activate event'], + }, + { + level: "log", + filename: /helper_serviceworker/, + arguments: ['fetch event: ' + SCOPE_FRAME_URL], + }, + { + level: "log", + filename: /helper_serviceworker/, + arguments: ['fetch event: ' + SCOPE_FRAME_URL2], + }, +]; +let consoleCalls = []; + +const startTest = async function () { + removeEventListener("load", startTest); + + await new Promise(resolve => { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.enabled", true], + ["devtools.webconsole.filter.serviceworkers", true] + ]}, resolve); + }); + + const {state, response} = await attachConsoleToTab(["ConsoleAPI"]); + onAttach(state, response); +}; +addEventListener("load", startTest); + +const onAttach = async function (state, response) { + onConsoleAPICall = onConsoleAPICall.bind(null, state); + state.webConsoleFront.on("consoleAPICall", onConsoleAPICall); + + let currentFrame; + try { + // First, we need a frame from which to register our script. This + // will not trigger any console calls. + info("Loading a non-scope frame from which to register a service worker."); + currentFrame = await withFrame(NONSCOPE_FRAME_URL); + + // Now register the service worker and wait for it to become + // activate. This should trigger 3 console calls; 1 for script + // evaluation, 1 for the install event, and 1 for the activate + // event. These console calls are received because we called + // register(), not because we are in scope for the worker. + info("Registering the service worker"); + await withActiveServiceWorker(currentFrame.contentWindow, + SERVICE_WORKER_URL, SCOPE); + ok(!currentFrame.contentWindow.navigator.serviceWorker.controller, + 'current frame should not be controlled'); + + // Now that the service worker is activate, lets navigate our frame. + // This will trigger 1 more console call for the fetch event. + info("Service worker registered. Navigating frame."); + await navigateFrame(currentFrame, SCOPE_FRAME_URL); + ok(currentFrame.contentWindow.navigator.serviceWorker.controller, + 'navigated frame should be controlled'); + + // We now have a controlled frame. Lets perform a non-navigation fetch. + // This should produce another console call for the fetch event. + info("Frame navigated. Calling fetch()."); + await currentFrame.contentWindow.fetch(SCOPE_FRAME_URL2); + + // Now force refresh our controlled frame. This will cause the frame + // to bypass the service worker and become an uncontrolled frame. It + // also happens to make the frame display a 404 message because the URL + // does not resolve to a real resource. This is ok, as we really only + // care about the frame being non-controlled, but still having a location + // that matches our service worker scope so we can provide its not + // incorrectly getting console calls. + info("Completed fetch(). Force refreshing to get uncontrolled frame."); + await forceReloadFrame(currentFrame); + ok(!currentFrame.contentWindow.navigator.serviceWorker.controller, + 'current frame should not be controlled after force refresh'); + is(currentFrame.contentWindow.location.toString(), SCOPE_FRAME_URL, + 'current frame should still have in-scope location URL even though it got 404'); + + // Now postMessage() the service worker to trigger its message event + // handler. This will generate 1 or 2 to console.log() statements + // depending on if the worker thread needs to spin up again. In either + // case, though, we should not get any console calls because we don't + // have a controlled or registering document. + info("Completed force refresh. Messaging service worker."); + await messageServiceWorker(currentFrame.contentWindow, SCOPE, MESSAGE); + + info("Done messaging service worker. Unregistering service worker."); + await unregisterServiceWorker(currentFrame.contentWindow); + + info('Service worker unregistered. Checking console calls.'); + state.webConsoleFront.off("consoleAPICall", onConsoleAPICall); + checkConsoleAPICalls(consoleCalls, expectedConsoleCalls); + } catch(error) { + ok(false, 'unexpected error: ' + error); + } finally { + if (currentFrame) { + currentFrame.remove(); + currentFrame = null; + } + consoleCalls = []; + closeDebugger(state, function() { + SimpleTest.finish(); + }); + } +}; + +function onConsoleAPICall(state, packet) { + info("received message level: " + packet.message.level); + consoleCalls.push(packet.message); +} +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_console_serviceworker_cached.html b/devtools/shared/webconsole/test/chrome/test_console_serviceworker_cached.html new file mode 100644 index 0000000000..9f94f82f93 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_console_serviceworker_cached.html @@ -0,0 +1,119 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for getCachedMessages and Service Workers</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for getCachedMessages and Service Workers</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +const BASE_URL = "https://example.com/chrome/devtools/shared/webconsole/test/chrome/"; +const SERVICE_WORKER_URL = BASE_URL + "helper_serviceworker.js"; +const FRAME_URL = BASE_URL + "sandboxed_iframe.html"; + +const firstTabExpectedCalls = [ + { + message: { + level: "log", + filename: /helper_serviceworker/, + arguments: ['script evaluation'], + } + }, { + message: { + level: "log", + filename: /helper_serviceworker/, + arguments: ['install event'], + } + }, { + message: { + level: "log", + filename: /helper_serviceworker/, + arguments: ['activate event'], + } + }, +]; + +const secondTabExpectedCalls = [ + { + message: { + level: "log", + filename: /helper_serviceworker/, + arguments: ['fetch event: ' + FRAME_URL], + } + } +]; + +const startTest = async function () { + removeEventListener("load", startTest); + + await new Promise(resolve => { + SpecialPowers.pushPrefEnv({"set": [ + ["dom.serviceWorkers.enabled", true], + ["devtools.webconsole.filter.serviceworkers", true] + ]}, resolve); + }); + + info("Adding a tab and attaching a service worker"); + const tab1 = await addTab(FRAME_URL); + const swr = await withActiveServiceWorker(tab1.linkedBrowser.contentWindow, + SERVICE_WORKER_URL); + + info("Attaching console to tab 1"); + let {state} = await attachConsoleToTab(["ConsoleAPI"]); + let calls = await state.webConsoleFront.getCachedMessages(["ConsoleAPI"]); + checkConsoleAPICalls(calls.messages, firstTabExpectedCalls); + await closeDebugger(state); + + // Because this tab is being added after the original messages happened, + // they shouldn't show up in a call to getCachedMessages. + // However, there is a fetch event which is logged due to loading the tab. + info("Adding a new tab at the same URL"); + + await addTab(FRAME_URL); + info("Attaching console to tab 2"); + state = (await attachConsoleToTab(["ConsoleAPI"])).state; + calls = await state.webConsoleFront.getCachedMessages(["ConsoleAPI"]); + checkConsoleAPICalls(calls.messages, secondTabExpectedCalls); + await closeDebugger(state); + + await swr.unregister(); + + SimpleTest.finish(); +}; +addEventListener("load", startTest); + +// This test needs to add tabs that are controlled by a service worker +// so use some special powers to dig around and find gBrowser +const {gBrowser} = SpecialPowers._getTopChromeWindow(SpecialPowers.window); + +SimpleTest.registerCleanupFunction(() => { + while (gBrowser.tabs.length > 1) { + gBrowser.removeCurrentTab(); + } +}); + +function addTab(url) { + info("Adding a new tab with URL: '" + url + "'"); + return new Promise(resolve => { + const tab = gBrowser.selectedTab = gBrowser.addTab(url, { + triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(), + }); + gBrowser.selectedBrowser.addEventListener("load", function () { + info("URL '" + url + "' loading complete"); + resolve(tab); + }, {capture: true, once: true}); + }); +} + +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_console_styling.html b/devtools/shared/webconsole/test/chrome/test_console_styling.html new file mode 100644 index 0000000000..841e19076f --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_console_styling.html @@ -0,0 +1,134 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for console.log styling with %c</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for console.log styling with %c</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +let expectedConsoleCalls = []; + +function doConsoleCalls(aState) +{ + top.console.log("%cOne formatter with no styles"); + top.console.log("%cOne formatter", "color: red"); + top.console.log("%cTwo formatters%cEach with an arg", + "color: red", "background: red"); + top.console.log("%c%cTwo formatters next to each other", + "color: red", "background: red"); + top.console.log("%c%c%cThree formatters next to each other", + "color: red", "background: red", "font-size: 150%"); + top.console.log("%c%cTwo formatters%cWith a third separated", + "color: red", "background: red", "font-size: 150%"); + top.console.log("%cOne formatter", "color: red", + "Second arg with no styles"); + top.console.log("%cOne formatter", "color: red", + "%cSecond formatter is ignored", "background: blue") + + expectedConsoleCalls = [ + { + level: "log", + styles: undefined, + arguments: ["%cOne formatter with no styles"], + }, + { + level: "log", + styles: /^color: red$/, + arguments: ["One formatter"], + }, + { + level: "log", + styles: /^color: red,background: red$/, + arguments: ["Two formatters", "Each with an arg"], + }, + { + level: "log", + styles: /^background: red$/, + arguments: ["Two formatters next to each other"], + }, + { + level: "log", + styles: /^font-size: 150%$/, + arguments: ["Three formatters next to each other"], + }, + { + level: "log", + styles: /^background: red,font-size: 150%$/, + arguments: ["Two formatters", "With a third separated"], + }, + { + level: "log", + styles: /^color: red$/, + arguments: ["One formatter", "Second arg with no styles"], + }, + { + level: "log", + styles: /^color: red$/, + arguments: ["One formatter", + "%cSecond formatter is ignored", + "background: blue"], + }, + ]; +} + +async function startTest() +{ + removeEventListener("load", startTest); + + const {state, response} = await attachConsoleToTab(["ConsoleAPI"]); + onAttach(state, response); +} + +function onAttach(aState, aResponse) +{ + onConsoleAPICall = onConsoleAPICall.bind(null, aState); + aState.webConsoleFront.on("consoleAPICall", onConsoleAPICall); + doConsoleCalls(aState.actor); +} + +let consoleCalls = []; + +function onConsoleAPICall(aState, aPacket) +{ + info("received message level: " + aPacket.message.level); + + consoleCalls.push(aPacket.message); + if (consoleCalls.length != expectedConsoleCalls.length) { + return; + } + + aState.webConsoleFront.off("consoleAPICall", onConsoleAPICall); + + expectedConsoleCalls.forEach(function(aMessage, aIndex) { + info("checking received console call #" + aIndex); + const expected = expectedConsoleCalls[aIndex]; + const consoleCall = consoleCalls[aIndex]; + if (expected.styles == undefined) { + delete expected.styles; + is(consoleCall.styles, undefined, "No 'styles' property") + } + checkConsoleAPICall(consoleCall, expected); + }); + + + consoleCalls = []; + + closeDebugger(aState, function() { + SimpleTest.finish(); + }); +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_console_timestamp.html b/devtools/shared/webconsole/test/chrome/test_console_timestamp.html new file mode 100644 index 0000000000..a64de0d7b2 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_console_timestamp.html @@ -0,0 +1,48 @@ +<!DOCTYPE HTML> +<html> +<head> + <meta charset="utf-8"> + <title>Test for console.group styling with %c</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> + <script> +"use strict"; + +window.onload = async function () { + SimpleTest.waitForExplicitFinish(); + let state; + try { + state = (await attachConsole(["ConsoleAPI"])).state; + const consoleFront = state.webConsoleFront; + + info("Testing console.log packet timestamp correctness"); + const clientLogTimestamp = Date.now(); + const packet = await consoleAPICall(consoleFront, + () => top.console.log("test")); + const packetReceivedTimestamp = Date.now(); + + const {timeStamp} = packet.message; + ok(clientLogTimestamp <= timeStamp && timeStamp <= packetReceivedTimestamp, + "console.log message timestamp is between the expected time range " + + `(${clientLogTimestamp} <= ${timeStamp} <= ${packetReceivedTimestamp})` + ); + } catch (e) { + ok(false, `Error thrown: ${e.message}`); + } + + await closeDebugger(state); + SimpleTest.finish(); +}; + + </script> +</head> +<body> + <p id="display"></p> + <div id="content" style="display: none"> + </div> + <pre id="test"> + </pre> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_console_worker.html b/devtools/shared/webconsole/test/chrome/test_console_worker.html new file mode 100644 index 0000000000..330c083f6b --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_console_worker.html @@ -0,0 +1,73 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for the Console API and Workers</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the Console API and Workers</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +const expectedCachedConsoleCalls = [{ + message:{ + level: "log", + filename: /console-test-worker/, + arguments: ['Log from worker init'], + } +}]; + +const expectedConsoleAPICalls = [{ + message: { + level: "log", + arguments: ['Log was requested from worker'], + } +}]; + +window.onload = async function () { + const {state} = await attachConsoleToWorker(["ConsoleAPI"]); + + await testCachedMessages(state); + await testConsoleAPI(state); + + closeDebugger(state, function() { + SimpleTest.finish(); + }); +}; + +const testCachedMessages = async function (state) { + info("testCachedMessages entered"); + return new Promise(resolve => { + const onCachedConsoleAPI = (response) => { + const consoleCalls = response.messages; + + info('Received cached response. Checking console calls.'); + checkConsoleAPICalls(consoleCalls, expectedCachedConsoleCalls); + resolve(); + }; + state.webConsoleFront.getCachedMessages(["ConsoleAPI"]).then(onCachedConsoleAPI); + }) +}; + +const testConsoleAPI = async function (state) { + info("testConsoleAPI: adding listener for consoleAPICall"); + const onConsoleApiMessage = state.webConsoleFront.once("consoleAPICall"); + state._worker_ref.postMessage({ + type: "log", + message: "Log was requested from worker" + }); + const packet = await onConsoleApiMessage; + info("received message level: " + packet.message.level); + checkConsoleAPICalls([packet], expectedConsoleAPICalls); +}; + +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_consoleapi.html b/devtools/shared/webconsole/test/chrome/test_consoleapi.html new file mode 100644 index 0000000000..b5d8edf23e --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_consoleapi.html @@ -0,0 +1,225 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for the Console API</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the Console API</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +let expectedConsoleCalls = []; + +function doConsoleCalls(aState) +{ + const longString = (new Array(DevToolsServer.LONG_STRING_LENGTH + 2)).join("a"); + + top.console.log("foobarBaz-log", undefined); + + top.console.log("Float from not a number: %f", "foo"); + top.console.log("Float from string: %f", "1.2"); + top.console.log("Float from number: %f", 1.3); + + top.console.info("foobarBaz-info", null); + top.console.warn("foobarBaz-warn", top.document.documentElement); + top.console.debug(null); + top.console.trace(); + top.console.dir(top.document, top.location); + top.console.log("foo", longString); + + const sandbox = new Cu.Sandbox(null, { invisibleToDebugger: true }); + const sandboxObj = sandbox.eval("new Object"); + top.console.log(sandboxObj); + + function fromAsmJS() { + top.console.error("foobarBaz-asmjs-error", undefined); + } + + (function(global, foreign) { + "use asm"; + function inAsmJS2() { foreign.fromAsmJS() } + function inAsmJS1() { inAsmJS2() } + return inAsmJS1 + })(null, { fromAsmJS })(); + + expectedConsoleCalls = [ + { + level: "log", + filename: /test_consoleapi/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: ["foobarBaz-log", { type: "undefined" }], + }, + { + level: "log", + arguments: ["Float from not a number: NaN"], + }, + { + level: "log", + arguments: ["Float from string: 1.200000"], + }, + { + level: "log", + arguments: ["Float from number: 1.300000"], + }, + { + level: "info", + filename: /test_consoleapi/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: ["foobarBaz-info", { type: "null" }], + }, + { + level: "warn", + filename: /test_consoleapi/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: ["foobarBaz-warn", { type: "object", actor: /[a-z]/ }], + }, + { + level: "debug", + filename: /test_consoleapi/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: [{ type: "null" }], + }, + { + level: "trace", + filename: /test_consoleapi/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + stacktrace: [ + { + filename: /test_consoleapi/, + functionName: "doConsoleCalls", + }, + { + filename: /test_consoleapi/, + functionName: "onAttach", + }, + ], + }, + { + level: "dir", + filename: /test_consoleapi/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: [ + { + type: "object", + actor: /[a-z]/, + class: "HTMLDocument", + }, + { + type: "object", + actor: /[a-z]/, + class: "Location", + } + ], + }, + { + level: "log", + filename: /test_consoleapi/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: [ + "foo", + { + type: "longString", + initial: longString.substring(0, + DevToolsServer.LONG_STRING_INITIAL_LENGTH), + length: longString.length, + actor: /[a-z]/, + }, + ], + }, + { + level: "log", + filename: /test_consoleapi/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: [ + { + type: "object", + actor: /[a-z]/, + class: "InvisibleToDebugger: Object", + }, + ], + }, + { + level: "error", + filename: /test_consoleapi/, + timeStamp: FRACTIONAL_NUMBER_REGEX, + arguments: ["foobarBaz-asmjs-error", { type: "undefined" }], + + stacktrace: [ + { + filename: /test_consoleapi/, + functionName: "fromAsmJS", + }, + { + filename: /test_consoleapi/, + functionName: "inAsmJS2", + }, + { + filename: /test_consoleapi/, + functionName: "inAsmJS1", + }, + { + filename: /test_consoleapi/, + functionName: "doConsoleCalls", + }, + { + filename: /test_consoleapi/, + functionName: "onAttach", + }, + ], + }, + ]; +} + +async function startTest() +{ + removeEventListener("load", startTest); + + const {state, response} = await attachConsoleToTab(["ConsoleAPI"]); + onAttach(state, response); +} + +function onAttach(aState, aResponse) +{ + onConsoleAPICall = onConsoleAPICall.bind(null, aState); + aState.webConsoleFront.on("consoleAPICall", onConsoleAPICall); + doConsoleCalls(aState.actor); +} + +let consoleCalls = []; + +function onConsoleAPICall(aState, aPacket) +{ + info("received message level: " + aPacket.message.level); + + consoleCalls.push(aPacket.message); + if (consoleCalls.length != expectedConsoleCalls.length) { + return; + } + + aState.webConsoleFront.off("consoleAPICall", onConsoleAPICall); + + expectedConsoleCalls.forEach(function(aMessage, aIndex) { + info("checking received console call #" + aIndex); + checkConsoleAPICall(consoleCalls[aIndex], expectedConsoleCalls[aIndex]); + }); + + + consoleCalls = []; + + closeDebugger(aState, function() { + SimpleTest.finish(); + }); +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_consoleapi_innerID.html b/devtools/shared/webconsole/test/chrome/test_consoleapi_innerID.html new file mode 100644 index 0000000000..98fc783a84 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_consoleapi_innerID.html @@ -0,0 +1,157 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for the innerID property of the Console API</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the Console API</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +let expectedConsoleCalls = []; + +function doConsoleCalls(aState) +{ + const { ConsoleAPI } = ChromeUtils.import("resource://gre/modules/Console.jsm"); + const console = new ConsoleAPI({ + innerID: window.top.windowGlobalChild.innerWindowId + }); + + const longString = (new Array(DevToolsServer.LONG_STRING_LENGTH + 2)).join("a"); + + console.log("foobarBaz-log", undefined); + console.info("foobarBaz-info", null); + console.warn("foobarBaz-warn", top.document.documentElement); + console.debug(null); + console.trace(); + console.dir(top.document, top.location); + console.log("foo", longString); + + expectedConsoleCalls = [ + { + level: "log", + filename: /test_consoleapi/, + timeStamp: /^\d+$/, + arguments: ["foobarBaz-log", { type: "undefined" }], + }, + { + level: "info", + filename: /test_consoleapi/, + timeStamp: /^\d+$/, + arguments: ["foobarBaz-info", { type: "null" }], + }, + { + level: "warn", + filename: /test_consoleapi/, + timeStamp: /^\d+$/, + arguments: ["foobarBaz-warn", { type: "object", actor: /[a-z]/ }], + }, + { + level: "debug", + filename: /test_consoleapi/, + timeStamp: /^\d+$/, + arguments: [{ type: "null" }], + }, + { + level: "trace", + filename: /test_consoleapi/, + timeStamp: /^\d+$/, + stacktrace: [ + { + filename: /test_consoleapi/, + functionName: "doConsoleCalls", + }, + { + filename: /test_consoleapi/, + functionName: "onAttach", + }, + ], + }, + { + level: "dir", + filename: /test_consoleapi/, + timeStamp: /^\d+$/, + arguments: [ + { + type: "object", + actor: /[a-z]/, + class: "HTMLDocument", + }, + { + type: "object", + actor: /[a-z]/, + class: "Location", + } + ], + }, + { + level: "log", + filename: /test_consoleapi/, + timeStamp: /^\d+$/, + arguments: [ + "foo", + { + type: "longString", + initial: longString.substring(0, + DevToolsServer.LONG_STRING_INITIAL_LENGTH), + length: longString.length, + actor: /[a-z]/, + }, + ], + }, + ]; +} + +async function startTest() +{ + removeEventListener("load", startTest); + + const {state} = await attachConsoleToTab(["ConsoleAPI"]); + onAttach(state); +} + +function onAttach(aState) +{ + onConsoleAPICall = onConsoleAPICall.bind(null, aState); + aState.webConsoleFront.on("consoleAPICall", onConsoleAPICall); + doConsoleCalls(aState.actor); +} + +let consoleCalls = []; + +function onConsoleAPICall(aState, aPacket) +{ + info("received message level: " + aPacket.message.level); + + consoleCalls.push(aPacket.message); + if (consoleCalls.length != expectedConsoleCalls.length) { + return; + } + + aState.webConsoleFront.off("consoleAPICall", onConsoleAPICall); + + expectedConsoleCalls.forEach(function(aMessage, aIndex) { + info("checking received console call #" + aIndex); + checkConsoleAPICall(consoleCalls[aIndex], expectedConsoleCalls[aIndex]); + }); + + + consoleCalls = []; + + closeDebugger(aState, function() { + SimpleTest.finish(); + }); +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_file_uri.html b/devtools/shared/webconsole/test/chrome/test_file_uri.html new file mode 100644 index 0000000000..76c3b8193e --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_file_uri.html @@ -0,0 +1,110 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for file activity tracking</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for file activity tracking</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +const {NetUtil} = ChromeUtils.import("resource://gre/modules/NetUtil.jsm"); +const {FileUtils} = ChromeUtils.import("resource://gre/modules/FileUtils.jsm"); + +let gState; +let gTmpFile; + +function doFileActivity() +{ + info("doFileActivity"); + const fileContent = "<p>hello world from bug 798764"; + + gTmpFile = FileUtils.getFile("TmpD", ["bug798764.html"]); + gTmpFile.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE); + + const fout = FileUtils.openSafeFileOutputStream(gTmpFile, + FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE | FileUtils.MODE_TRUNCATE); + + const stream = Cc[ + "@mozilla.org/io/arraybuffer-input-stream;1" + ].createInstance(Ci.nsIArrayBufferInputStream); + const buffer = new TextEncoder().encode(fileContent).buffer; + stream.setData(buffer, 0, buffer.byteLength); + NetUtil.asyncCopy(stream, fout, addIframe); +} + +function addIframe(aStatus) +{ + ok(Components.isSuccessCode(aStatus), + "the temporary file was saved successfully"); + + const iframe = document.createElement("iframe"); + iframe.src = NetUtil.newURI(gTmpFile).spec; + document.body.appendChild(iframe); +} + +async function startTest() +{ + removeEventListener("load", startTest); + + const {state} = await attachConsole(["FileActivity"]); + onAttach(state); +} + +function onAttach(aState) +{ + gState = aState; + gState.webConsoleFront.on("fileActivity", onFileActivity); + doFileActivity(); +} + +function onFileActivity(aPacket) +{ + gState.webConsoleFront.off("fileActivity", onFileActivity); + + info("aPacket.uri: " + aPacket.uri); + ok(/\bbug798764\b.*\.html$/.test(aPacket.uri), "file URI match"); + + testEnd(); +} + +function testEnd() +{ + if (gTmpFile) { + SimpleTest.executeSoon(function() { + try { + gTmpFile.remove(false); + } + catch (ex) { + if (ex.name != "NS_ERROR_FILE_IS_LOCKED") { + throw ex; + } + // Sometimes remove() throws because the file is not unlocked soon + // enough. + } + gTmpFile = null; + }); + } + + if (gState) { + closeDebugger(gState, function() { + gState = null; + SimpleTest.finish(); + }); + } else { + SimpleTest.finish(); + } +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_jsterm_autocomplete.html b/devtools/shared/webconsole/test/chrome/test_jsterm_autocomplete.html new file mode 100644 index 0000000000..bbc9aeb6fc --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_jsterm_autocomplete.html @@ -0,0 +1,635 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for JavaScript terminal functionality</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for JavaScript terminal autocomplete functionality</p> + +<script class="testbody" type="text/javascript"> + "use strict"; + + SimpleTest.waitForExplicitFinish(); + const { + MAX_AUTOCOMPLETE_ATTEMPTS, + MAX_AUTOCOMPLETIONS + } = require("devtools/shared/webconsole/js-property-provider"); + const RESERVED_JS_KEYWORDS = require("devtools/shared/webconsole/reserved-js-words"); + + + addEventListener("load", startTest); + + async function startTest() { + // First run the tests with a tab as a target. + let {state} = await attachConsoleToTab(["PageError"]); + await performTests({state, isWorker: false}); + + // Then run the tests with a worker as a target. + state = (await attachConsoleToWorker(["PageError"])).state; + await performTests({state, isWorker: true}); + + SimpleTest.finish(); + } + + async function performTests({state, isWorker}) { + // Set up the global variables needed to test autocompletion in the target. + const script = ` + // This is for workers so autocomplete acts the same + if (!this.window) { + window = this; + } + + window.foobarObject = Object.create(null); + window.foobarObject.foo = 1; + window.foobarObject.foobar = 2; + window.foobarObject.foobaz = 3; + window.foobarObject.omg = 4; + window.foobarObject.omgfoo = 5; + window.foobarObject.strfoo = "foobarz"; + window.foobarObject.omgstr = "foobarz" + + (new Array(${DevToolsServer.LONG_STRING_LENGTH})).join("abb"); + window.largeObject1 = Object.create(null); + for (let i = 0; i < ${MAX_AUTOCOMPLETE_ATTEMPTS + 1}; i++) { + window.largeObject1['a' + i] = i; + } + + window.largeObject2 = Object.create(null); + for (let i = 0; i < ${MAX_AUTOCOMPLETIONS * 2}; i++) { + window.largeObject2['a' + i] = i; + } + + window.proxy1 = new Proxy({foo: 1}, { + getPrototypeOf() { throw new Error() } + }); + window.proxy2 = new Proxy(Object.create(Object.create(null, {foo:{}})), { + ownKeys() { throw new Error() } + }); + window.emojiObject = Object.create(null); + window.emojiObject["😎"] = "😎"; + + window.insensitiveTestCase = Object.create(null, Object.getOwnPropertyDescriptors({ + PROP: "", + Prop: "", + prop: "", + PRÖP: "", + pröp: "", + })); + + window.elementAccessTestCase = Object.create(null, Object.getOwnPropertyDescriptors({ + bar: "", + BAR: "", + dataTest: "", + "data-test": "", + 'da"ta"test': "", + 'da\`ta\`test': "", + "da'ta'test": "", + })); + + window.varify = true; + + var Cu_Sandbox = Cu ? Cu.Sandbox : null; + `; + await evaluateExpression(state.webConsoleFront, script); + + const tests = [ + doAutocomplete1, + doAutocomplete2, + doAutocomplete3, + doAutocomplete4, + doAutocompleteLarge1, + doAutocompleteLarge2, + doAutocompleteProxyThrowsPrototype, + doAutocompleteProxyThrowsOwnKeys, + doAutocompleteDotSurroundedBySpaces, + doAutocompleteAfterOr, + doInsensitiveAutocomplete, + doElementAccessAutocomplete, + doAutocompleteAfterOperator, + dontAutocompleteAfterDeclaration, + doKeywordsAutocomplete, + dontAutocomplete, + ]; + + if (!isWorker) { + // `Cu` is not defined in workers, then we can't test `Cu.Sandbox` + tests.push(doAutocompleteSandbox); + // Some cases are handled in worker context because we can't use parser.js. + // See Bug 1507181. + tests.push( + doAutocompleteArray, + doAutocompleteString, + doAutocompleteCommands, + doAutocompleteBracketSurroundedBySpaces, + ); + } + + for (const test of tests) { + await test(state.webConsoleFront); + } + + // Null out proxy1 and proxy2: the proxy handlers use scripted functions + // that can keep the debugger sandbox alive longer than necessary via their + // environment chain (due to the webconsole helper functions defined there). + await evaluateExpression(state.webConsoleFront, `this.proxy1 = null; this.proxy2 = null;`); + + await closeDebugger(state); + } + + async function doAutocomplete1(webConsoleFront) { + info("test autocomplete for 'window.foo'"); + const response = await webConsoleFront.autocomplete("window.foo"); + const matches = response.matches; + + is(response.matchProp, "foo", "matchProp"); + is(matches.length, 1, "matches.length"); + is(matches[0], "foobarObject", "matches[0]"); + } + + async function doAutocomplete2(webConsoleFront) { + info("test autocomplete for 'window.foobarObject.'"); + const response = await webConsoleFront.autocomplete("window.foobarObject."); + const matches = response.matches; + + ok(!response.matchProp, "matchProp"); + is(matches.length, 7, "matches.length"); + checkObject(matches, + ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]); + } + + async function doAutocomplete3(webConsoleFront) { + // Check that completion suggestions are offered inside the string. + info("test autocomplete for 'dump(window.foobarObject.)'"); + const response = await webConsoleFront.autocomplete("dump(window.foobarObject.)", 25); + const matches = response.matches; + + ok(!response.matchProp, "matchProp"); + is(matches.length, 7, "matches.length"); + checkObject(matches, + ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]); + } + + async function doAutocomplete4(webConsoleFront) { + // Check that completion requests can have no suggestions. + info("test autocomplete for 'dump(window.foobarObject.)'"); + const response = await webConsoleFront.autocomplete("dump(window.foobarObject.)"); + ok(!response.matchProp, "matchProp"); + is(response.matches, null, "matches is null"); + } + + async function doAutocompleteLarge1(webConsoleFront) { + // Check that completion requests with too large objects will + // have no suggestions. + info("test autocomplete for 'window.largeObject1.'"); + const response = await webConsoleFront.autocomplete("window.largeObject1."); + ok(!response.matchProp, "matchProp"); + info (response.matches.join("|")); + is(response.matches.length, 0, "Bailed out with too many properties"); + } + + async function doAutocompleteLarge2(webConsoleFront) { + // Check that completion requests with pretty large objects will + // have MAX_AUTOCOMPLETIONS suggestions + info("test autocomplete for 'window.largeObject2.'"); + const response = await webConsoleFront.autocomplete("window.largeObject2."); + ok(!response.matchProp, "matchProp"); + is(response.matches.length, MAX_AUTOCOMPLETIONS, "matches.length is MAX_AUTOCOMPLETIONS"); + } + + async function doAutocompleteProxyThrowsPrototype(webConsoleFront) { + // Check that completion provides own properties even if [[GetPrototypeOf]] throws. + info("test autocomplete for 'window.proxy1.'"); + const response = await webConsoleFront.autocomplete("window.proxy1."); + ok(!response.matchProp, "matchProp"); + is(response.matches.length, 14, "matches.length"); + ok(response.matches.includes("foo"), "matches has own property for proxy with throwing getPrototypeOf trap"); + } + + async function doAutocompleteProxyThrowsOwnKeys(webConsoleFront) { + // Check that completion provides inherited properties even if [[OwnPropertyKeys]] throws. + info("test autocomplete for 'window.proxy2.'"); + const response = await webConsoleFront.autocomplete("window.proxy2."); + ok(!response.matchProp, "matchProp"); + is(response.matches.length, 1, "matches.length"); + checkObject(response.matches, ["foo"]); + } + + async function doAutocompleteSandbox(webConsoleFront) { + // Check that completion provides inherited properties even if [[OwnPropertyKeys]] throws. + info("test autocomplete for 'Cu_Sandbox.'"); + const response = await webConsoleFront.autocomplete("Cu_Sandbox."); + ok(!response.matchProp, "matchProp"); + const keys = Object.getOwnPropertyNames(Object.prototype).sort(); + is(response.matches.length, keys.length, "matches.length"); + // checkObject(response.matches, keys); + is(response.matches.join(" - "), keys.join(" - ")); + } + + async function doAutocompleteArray(webConsoleFront) { + info("test autocomplete for [1,2,3]"); + const response = await webConsoleFront.autocomplete("[1,2,3]."); + let {matches} = response; + + ok(!!matches.length, "There are completion results for the array"); + ok(matches.includes("length") && matches.includes("filter"), + "Array autocomplete contains expected results"); + + info("test autocomplete for '[] . '"); + matches = (await webConsoleFront.autocomplete("[] . ")).matches; + ok(matches.length > 1); + ok(matches.includes("length") && matches.includes("filter"), + "Array autocomplete contains expected results"); + ok(!matches.includes("copy"), "Array autocomplete does not contain helpers"); + + info("test autocomplete for '[1,2,3]['"); + matches = (await webConsoleFront.autocomplete("[1,2,3][")).matches; + ok(matches.length > 1); + ok(matches.includes('"length"') && matches.includes('"filter"'), + "Array autocomplete contains expected results, surrounded by quotes"); + + info("test autocomplete for '[1,2,3]['"); + matches = (await webConsoleFront.autocomplete("[1,2,3]['")).matches; + ok(matches.length > 1); + ok(matches.includes("'length'") && matches.includes("'filter'"), + "Array autocomplete contains expected results, surrounded by quotes"); + + info("test autocomplete for '[1,2,3][l"); + matches = (await webConsoleFront.autocomplete("[1,2,3][l")).matches; + ok(matches.length >= 1); + ok(matches.includes('"length"'), + "Array autocomplete contains expected results, surrounded by quotes"); + + info("test autocomplete for '[1,2,3]['l"); + matches = (await webConsoleFront.autocomplete("[1,2,3]['l")).matches; + ok(matches.length >= 1); + ok(matches.includes("'length'"), + "Array autocomplete contains expected results, surrounded by quotes"); + } + + async function doAutocompleteString(webConsoleFront) { + info(`test autocomplete for "foo".`); + const response = await webConsoleFront.autocomplete(`"foo".`); + let {matches} = response; + + ok(!!matches.length, "There are completion results for the string"); + ok(matches.includes("substr") && matches.includes("trim"), + "String autocomplete contains expected results"); + + info("test autocomplete for `foo`["); + matches = (await webConsoleFront.autocomplete("`foo`[")).matches; + ok(matches.length > 1, "autocomplete string with bracket works"); + ok(matches.includes('"substr"') && matches.includes('"trim"'), + "String autocomplete contains expected results, surrounded by quotes"); + } + + async function doAutocompleteDotSurroundedBySpaces(webConsoleFront) { + info("test autocomplete for 'window.foobarObject\n .'"); + let {matches} = await webConsoleFront.autocomplete("window.foobarObject\n ."); + is(matches.length, 7); + checkObject(matches, + ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]); + + info("test autocomplete for 'window.foobarObject\n .o'"); + matches = (await webConsoleFront.autocomplete("window.foobarObject\n .o")).matches; + is(matches.length, 3); + checkObject(matches, ["omg", "omgfoo", "omgstr"]); + + info("test autocomplete for 'window.foobarObject\n .\n s'"); + matches = (await webConsoleFront.autocomplete("window.foobarObject\n .\n s")).matches; + is(matches.length, 1); + checkObject(matches, ["strfoo"]); + + info("test autocomplete for 'window.foobarObject\n . '"); + matches = (await webConsoleFront.autocomplete("window.foobarObject\n . ")).matches; + is(matches.length, 7); + checkObject(matches, + ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]); + + matches = + (await webConsoleFront.autocomplete("window.foobarObject. foo ; window.foo")).matches; + is(matches.length, 1); + checkObject(matches, ["foobarObject"]); + } + + async function doAutocompleteBracketSurroundedBySpaces(webConsoleFront) { + const wrap = (arr, quote = `"`) => arr.map(x => `${quote}${x}${quote}`); + let matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n [") + is(matches.length, 7); + checkObject(matches, + wrap(["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"])); + + matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n ['o") + is(matches.length, 3); + checkObject(matches, wrap(["omg", "omgfoo", "omgstr"], "'")); + + matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n [\n s"); + is(matches.length, 1); + checkObject(matches, [`"strfoo"`]); + + matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n [ "); + is(matches.length, 7); + checkObject(matches, + wrap(["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"])); + + matches = await getAutocompleteMatches(webConsoleFront, "window.emojiObject [ '"); + is(matches.length, 1); + checkObject(matches, [`'😎'`]); + } + + async function doAutocompleteAfterOr(webConsoleFront) { + info("test autocomplete for 'true || foo'"); + const {matches} = await webConsoleFront.autocomplete("true || foobar"); + is(matches.length, 1, "autocomplete returns expected results"); + is(matches.join("-"), "foobarObject"); + } + + async function doInsensitiveAutocomplete(webConsoleFront) { + info("test autocomplete for 'window.insensitiveTestCase.'"); + let {matches} = await webConsoleFront.autocomplete("window.insensitiveTestCase."); + is(matches.join("-"), "prop-pröp-Prop-PROP-PRÖP", + "autocomplete returns the expected items, in the expected order"); + + info("test autocomplete for 'window.insensitiveTestCase.p'"); + matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.p")).matches; + is(matches.join("-"), "prop-pröp-Prop-PROP-PRÖP", + "autocomplete is case-insensitive when first letter is lowercased"); + + info("test autocomplete for 'window.insensitiveTestCase.pRoP'"); + matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.pRoP")).matches; + is(matches.join("-"), "prop-Prop-PROP", + "autocomplete is case-insensitive when first letter is lowercased"); + + info("test autocomplete for 'window.insensitiveTestCase.P'"); + matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.P")).matches; + is(matches.join("-"), "Prop-PROP-PRÖP", + "autocomplete is case-sensitive when first letter is uppercased"); + + info("test autocomplete for 'window.insensitiveTestCase.PROP'"); + matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.PROP")).matches; + is(matches.join("-"), "PROP", + "autocomplete is case-sensitive when first letter is uppercased"); + + info("test autocomplete for 'window.insensitiveTestCase.prö'"); + matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.prö")).matches; + is(matches.join("-"), "pröp-PRÖP", "expected result with lowercase diacritic"); + + info("test autocomplete for 'window.insensitiveTestCase.PRÖ'"); + matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.PRÖ")).matches; + is(matches.join("-"), "PRÖP", "expected result with uppercase diacritic"); + } + + async function doElementAccessAutocomplete(webConsoleFront) { + info("test autocomplete for 'window.elementAccessTestCase['"); + let res = (await webConsoleFront.autocomplete("window.elementAccessTestCase[")); + is( + res.matches.join("|"), + `"bar"|"da'ta'test"|"da\\"ta\\"test"|"da\`ta\`test"|"data-test"|"dataTest"|"BAR"`, + "autocomplete returns the expected items, wrapped in quotes"); + is(res.isElementAccess, true); + + info("test autocomplete for 'window.elementAccessTestCase[d'"); + res = await webConsoleFront.autocomplete("window.elementAccessTestCase[d"); + is( + res.matches.join("|"), + `"da'ta'test"|"da\\"ta\\"test"|"da\`ta\`test"|"data-test"|"dataTest"`, + "autocomplete returns the expected filtered items"); + is(res.isElementAccess, true); + + info(`test autocomplete for 'window.elementAccessTestCase["d'`); + res = await webConsoleFront.autocomplete(`window.elementAccessTestCase["d`); + is( + res.matches.join("|"), + `"da'ta'test"|"da\\"ta\\"test"|"da\`ta\`test"|"data-test"|"dataTest"`, + "autocomplete returns the expected items, wrapped in quotes"); + is(res.isElementAccess, true); + + info(`test autocomplete for 'window.elementAccessTestCase["data-`); + res = await webConsoleFront.autocomplete(`window.elementAccessTestCase["data-`); + is(res.matches.join("|"), `"data-test"`, + "autocomplete returns the expected items, wrapped in quotes"); + is(res.isElementAccess, true); + + info(`test autocomplete for 'window.elementAccessTestCase['d'`); + res = await webConsoleFront.autocomplete(`window.elementAccessTestCase['d`); + is( + res.matches.join("|"), + `'da"ta"test'|'da\\'ta\\'test'|'da\`ta\`test'|'data-test'|'dataTest'`, + "autocomplete returns the expected items, wrapped in the same quotes the user entered"); + is(res.isElementAccess, true); + + info("test autocomplete for 'window.elementAccessTestCase[`d'"); + res = await webConsoleFront.autocomplete("window.elementAccessTestCase[`d"); + is( + res.matches.join("|"), + "`da'ta'test`|`da\"ta\"test`|`da\\`ta\\`test`|`data-test`|`dataTest`", + "autocomplete returns the expected items, wrapped in the same quotes the user entered"); + is(res.isElementAccess, true); + + info(`test autocomplete for '['`); + res = await webConsoleFront.autocomplete(`[`); + is(res.matches, null, "it does not return anything"); + + info(`test autocomplete for '[1,2,3'`); + res = await webConsoleFront.autocomplete(`[1,2,3`); + is(res.matches, null, "it does not return anything"); + + info(`test autocomplete for '["'`); + res = await webConsoleFront.autocomplete(`["`); + is(res.matches, null, "it does not return anything"); + + info(`test autocomplete for '[;'`); + res = await webConsoleFront.autocomplete(`[;`); + is(res.matches, null, "it does not return anything"); + } + + async function doAutocompleteCommands(webConsoleFront) { + info("test autocomplete for 'c'"); + let matches = (await webConsoleFront.autocomplete("c")).matches; + ok(matches.includes("clear"), "commands are returned"); + + info("test autocomplete for 's'"); + matches = (await webConsoleFront.autocomplete("s")).matches; + is(matches.includes("screenshot"), false, "screenshot is not returned"); + + info("test autocomplete for ':s'"); + matches = (await webConsoleFront.autocomplete(":s")).matches; + is(matches.includes(":screenshot"), true, "screenshot is returned"); + + info("test autocomplete for 'window.c'"); + matches = (await webConsoleFront.autocomplete("window.c")).matches; + ok(!matches.includes("clear"), "commands are not returned"); + + info("test autocomplete for 'window[c'"); + matches = (await webConsoleFront.autocomplete("window[c")).matches; + ok(!matches.includes("clear"), "commands are not returned"); + + info(`test autocomplete for 'window["c'`); + matches = (await webConsoleFront.autocomplete(`window["c`)).matches; + ok(!matches.includes("clear"), "commands are not returned"); + + info(`test autocomplete for 'window["c'`); + matches = (await webConsoleFront.autocomplete(`window["c`)).matches; + ok(!matches.includes("clear"), "commands are not returned"); + + info(`test autocomplete for 'window[";c'`); + matches = (await webConsoleFront.autocomplete(`window[";c`)).matches; + ok(!matches.includes("clear"), "commands are not returned"); + + info(`test autocomplete for 'window[;c'`); + matches = (await webConsoleFront.autocomplete(`window[;c`)).matches; + ok(!matches.includes("clear"), "commands are not returned"); + } + + async function doAutocompleteAfterOperator(webConsoleFront) { + const inputs = [ + "true;foob", + "true,foob", + "({key:foob", + "a=foob", + "if(a<foob", + "if(a>foob", + "1+foob", + "1-foob", + "++foob", + "--foob", + "1*foob", + "2**foob", + "1/foob", + "1%foob", + "1|foob", + "1&foob", + "1^foob", + "~foob", + "1<<foob", + "1>>foob", + "1>>>foob", + "false||foob", + "false&&foob", + "x=true?foob", + "x=false?1:foob", + "!foob", + "false??foob", + ]; + + for (const input of inputs) { + info(`test autocomplete for "${input}"`); + const matches = (await webConsoleFront.autocomplete(input)).matches; + ok(matches.includes("foobarObject"), `Expected autocomplete result for ${input}"`); + } + } + + async function dontAutocompleteAfterDeclaration(webConsoleFront) { + info("test autocomplete for 'var win'"); + let matches = (await webConsoleFront.autocomplete("var win")).matches; + is(matches, null, "no autocompletion on a var declaration"); + + info("test autocomplete for 'const win'"); + matches = (await webConsoleFront.autocomplete("const win")).matches; + is(matches, null, "no autocompletion on a const declaration"); + + info("test autocomplete for 'let win'"); + matches = (await webConsoleFront.autocomplete("let win")).matches; + is(matches, null, "no autocompletion on a let declaration"); + + info("test autocomplete for 'function win'"); + matches = (await webConsoleFront.autocomplete("function win")).matches; + is(matches, null, "no autocompletion on a function declaration"); + + info("test autocomplete for 'class win'"); + matches = (await webConsoleFront.autocomplete("class win")).matches; + is(matches, null, "no autocompletion on a class declaration"); + + info("test autocomplete for 'const win = win'"); + matches = (await webConsoleFront.autocomplete("const win = win")).matches; + ok(matches.includes("window"), "autocompletion still happens after the `=` sign"); + + info("test autocomplete for 'in var'"); + matches = (await webConsoleFront.autocomplete("in var")).matches; + ok(matches.includes("varify"), + "autocompletion still happens with a property name starting with 'var'"); +} + +async function doKeywordsAutocomplete(webConsoleFront) { + info("test autocomplete for 'func'"); + let matches = (await webConsoleFront.autocomplete("func")).matches; + ok(matches.includes("function"), "keywords are returned"); + + info("test autocomplete for ':func'"); + matches = (await webConsoleFront.autocomplete(":func")).matches; + is(!matches.includes("function"), true, + "'function' is not returned when prefixed with ':'"); + + info("test autocomplete for 'window.func'"); + matches = (await webConsoleFront.autocomplete("window.func")).matches; + ok(!matches.includes("function"), + "'function' is not returned when doing a property access"); + + info("test autocomplete for 'window[func'"); + matches = (await webConsoleFront.autocomplete("window[func")).matches; + ok(!matches.includes("function"), + "'function' is not returned when doing an element access"); + } + + async function dontAutocomplete(webConsoleFront) { + const inputs = [ + "", + " ", + "\n", + "\n ", + " \n ", + " \n", + "true;", + "true,", + "({key:", + "a=", + "if(a<", + "if(a>", + "1+", + "1-", + "++", + "--", + "1*", + "2**", + "1/", + "1%", + "1|", + "1&", + "1^", + "~", + "1<<", + "1>>", + "1>>>", + "false||", + "false&&", + "x=true?", + "x=false?1:", + "!", + ...RESERVED_JS_KEYWORDS.map(keyword => `${keyword} `), + ...RESERVED_JS_KEYWORDS.map(keyword => `${keyword} `), + ]; + for (const input of inputs) { + info(`test autocomplete for "${input}"`); + const matches = (await webConsoleFront.autocomplete(input)).matches; + is(matches, null, `No autocomplete result for ${input}"`); + } + } + + async function getAutocompleteMatches(webConsoleFront, input) { + info(`test autocomplete for "${input}"`); + const res = (await webConsoleFront.autocomplete(input)); + return res.matches; + } + + async function evaluateExpression(consoleFront, expression) { + const onEvaluationResult = consoleFront.once("evaluationResult"); + await consoleFront.evaluateJSAsync({ text: expression }); + return onEvaluationResult; + } + +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_network_get.html b/devtools/shared/webconsole/test/chrome/test_network_get.html new file mode 100644 index 0000000000..71bb6c388c --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_network_get.html @@ -0,0 +1,132 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for the network actor (GET request)</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the network actor (GET request)</p> + +<iframe src="http://example.com/chrome/devtools/shared/webconsole/test/chrome/network_requests_iframe.html"></iframe> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +async function startTest() +{ + await SpecialPowers.pushPrefEnv({ + 'set': [ + // Bug 1617611: Fix all the tests broken by "cookies SameSite=lax by default" + ['network.cookie.sameSite.laxByDefault', false], + ] + }); + + const commands = await createCommandsForTab(); + const target = commands.targetCommand.targetFront; + const resourceCommand = commands.resourceCommand; + + info("test network GET request"); + const resource = await new Promise(resolve => { + resourceCommand + .watchResources([resourceCommand.TYPES.NETWORK_EVENT], { + onAvailable: () => {}, + onUpdated: resourceUpdate => { + resolve(resourceUpdate[0].resource); + }, + }) + .then(() => { + // Spawn the network request after we started watching + const iframe = document.querySelector("iframe").contentWindow; + iframe.wrappedJSObject.testXhrGet(null, "data.json?" + Date.now()); + }); + }); + + const webConsoleFront = await target.getFront("console"); + const netActor = resource.actor; + + info("checking request headers"); + const requestHeadersPacket = await webConsoleFront.getRequestHeaders(netActor); + ok(!!requestHeadersPacket.headers.length, `request headers > 0 (${requestHeadersPacket.headers.length})`); + ok(requestHeadersPacket.headersSize > 0, `request headersSize > 0 (${requestHeadersPacket.headersSize})`); + ok(!!requestHeadersPacket.rawHeaders, "request rawHeaders available"); + + checkHeadersOrCookies(requestHeadersPacket.headers, { + Referer: /network_requests_iframe\.html/, + Cookie: /bug768096/, + }); + + checkRawHeaders(requestHeadersPacket.rawHeaders, { + Referer: /network_requests_iframe\.html/, + Cookie: /bug768096/, + }); + + info("checking request cookies"); + const requestCookiesPacket = await webConsoleFront.getRequestCookies(netActor); + is(requestCookiesPacket.cookies.length, 3, "request cookies length"); + + checkHeadersOrCookies(requestCookiesPacket.cookies, { + foobar: "fooval", + omgfoo: "bug768096", + badcookie: "bug826798=st3fan", + }); + + info("checking request POST data"); + const postDataPacket = await webConsoleFront.getRequestPostData(netActor); + ok(!postDataPacket.postData.text, "no request POST data"); + ok(!postDataPacket.postDataDiscarded, "request POST data was not discarded"); + + info("checking response headers"); + const responseHeaderPacket = await webConsoleFront.getResponseHeaders(netActor); + + ok(!!responseHeaderPacket.headers.length, "response headers > 0"); + ok(responseHeaderPacket.headersSize > 0, "response headersSize > 0"); + ok(!!responseHeaderPacket.rawHeaders, "response rawHeaders available"); + + checkHeadersOrCookies(responseHeaderPacket.headers, { + "content-type": /^application\/(json|octet-stream)$/, + "content-length": /^\d+$/, + }); + + checkRawHeaders(responseHeaderPacket.rawHeaders, { + "content-type": /^application\/(json|octet-stream)$/, + "content-length": /^\d+$/, + }); + + info("checking response cookies"); + const responseCookiesPacket = await webConsoleFront.getResponseCookies(netActor); + is(responseCookiesPacket.cookies.length, 0, "response cookies length"); + + info("checking response content"); + const responseContentPacket = await webConsoleFront.getResponseContent(netActor); + ok(responseContentPacket.content.text, "response content text"); + ok(!responseContentPacket.contentDiscarded, "response content was not discarded"); + + info("checking event timings"); + const eventTimingPacket = await webConsoleFront.getEventTimings(netActor); + checkObject(eventTimingPacket, { + timings: { + blocked: /^-1|\d+$/, + dns: /^-1|\d+$/, + connect: /^-1|\d+$/, + send: /^-1|\d+$/, + wait: /^-1|\d+$/, + receive: /^-1|\d+$/, + }, + totalTime: /^\d+$/, + }); + + await commands.destroy(); + SpecialPowers.clearUserPref("network.cookie.sameSite.laxByDefault"); + SimpleTest.finish(); +} + +addEventListener("load", startTest, { once: true}); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_network_post.html b/devtools/shared/webconsole/test/chrome/test_network_post.html new file mode 100644 index 0000000000..237494c323 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_network_post.html @@ -0,0 +1,143 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for the network actor (POST request)</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the network actor (POST request)</p> + +<iframe src="http://example.com/chrome/devtools/shared/webconsole/test/chrome/network_requests_iframe.html"></iframe> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +async function startTest() +{ + await SpecialPowers.pushPrefEnv({ + 'set': [ + // Bug 1617611: Fix all the tests broken by "cookies SameSite=lax by default" + ['network.cookie.sameSite.laxByDefault', false], + ] + }); + + const commands = await createCommandsForTab(); + const target = commands.targetCommand.targetFront; + const resourceCommand = commands.resourceCommand; + + info("test network POST request"); + const resource = await new Promise(resolve => { + resourceCommand + .watchResources([resourceCommand.TYPES.NETWORK_EVENT], { + onAvailable: () => {}, + onUpdated: resourceUpdate => { + resolve(resourceUpdate[0].resource); + }, + }) + .then(() => { + // Spawn the network request after we started watching + const iframe = document.querySelector("iframe").contentWindow; + iframe.wrappedJSObject.testXhrPost(); + }); + }); + + const webConsoleFront = await target.getFront("console"); + const netActor = resource.actor; + + info("checking request headers"); + const requestHeadersPacket = await webConsoleFront.getRequestHeaders(netActor); + + ok(!!requestHeadersPacket.headers.length, "request headers > 0"); + ok(requestHeadersPacket.headersSize > 0, "request headersSize > 0"); + ok(!!requestHeadersPacket.rawHeaders.length, "request rawHeaders available"); + + checkHeadersOrCookies(requestHeadersPacket.headers, { + Referer: /network_requests_iframe\.html/, + Cookie: /bug768096/, + }); + + checkRawHeaders(requestHeadersPacket.rawHeaders, { + Referer: /network_requests_iframe\.html/, + Cookie: /bug768096/, + }); + + info("checking request cookies"); + const requestCookiesPacket = await webConsoleFront.getRequestCookies(netActor); + is(requestCookiesPacket.cookies.length, 3, "request cookies length"); + + checkHeadersOrCookies(requestCookiesPacket.cookies, { + foobar: "fooval", + omgfoo: "bug768096", + badcookie: "bug826798=st3fan", + }); + + info("checking request POST data"); + const requestPostDataPacket = await webConsoleFront.getRequestPostData(netActor); + + checkObject(requestPostDataPacket, { + postData: { + text: /^Hello world! foobaz barr.+foobaz barr$/, + }, + postDataDiscarded: false, + }); + + is(requestPostDataPacket.postData.text.length, 552, "postData text length"); + + info("checking response headers"); + const responseHeadersPacket = await webConsoleFront.getResponseHeaders(netActor); + ok(!!responseHeadersPacket.headers.length, "response headers > 0"); + ok(responseHeadersPacket.headersSize > 0, "response headersSize > 0"); + ok(!!responseHeadersPacket.rawHeaders, "response rawHeaders available"); + + checkHeadersOrCookies(responseHeadersPacket.headers, { + "content-type": /^application\/(json|octet-stream)$/, + "content-length": /^\d+$/, + }); + + checkRawHeaders(responseHeadersPacket.rawHeaders, { + "content-type": /^application\/(json|octet-stream)$/, + "content-length": /^\d+$/, + }); + + info("checking response cookies"); + const responseCookiesPacket = await webConsoleFront.getResponseCookies(netActor); + is(responseCookiesPacket.cookies.length, 0, "response cookies length"); + + info("checking response content"); + const responseContentPacket = await webConsoleFront.getResponseContent(netActor); + checkObject(responseContentPacket, { + content: { + text: /"test JSON data"/, + }, + contentDiscarded: false, + }); + + info("checking event timings"); + const eventTimingsPacket = await webConsoleFront.getEventTimings(netActor); + checkObject(eventTimingsPacket, { + timings: { + blocked: /^-1|\d+$/, + dns: /^-1|\d+$/, + connect: /^-1|\d+$/, + send: /^-1|\d+$/, + wait: /^-1|\d+$/, + receive: /^-1|\d+$/, + }, + totalTime: /^\d+$/, + }); + + await commands.destroy(); + SpecialPowers.clearUserPref("network.cookie.sameSite.laxByDefault"); + SimpleTest.finish(); +} + +addEventListener("load", startTest, { once: true }); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_network_security-hsts.html b/devtools/shared/webconsole/test/chrome/test_network_security-hsts.html new file mode 100644 index 0000000000..6139aa4e05 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_network_security-hsts.html @@ -0,0 +1,89 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for the network actor (HSTS detection)</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the network actor (HSTS detection)</p> + +<iframe src="https://example.com/chrome/devtools/shared/webconsole/test/chrome/network_requests_iframe.html"></iframe> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +const TEST_CASES = [ + { + desc: "no HSTS", + url: "https://example.com", + usesHSTS: false, + }, + { + desc: "HSTS from this response", + url: "https://example.com/"+ + "browser/browser/base/content/test/general/browser_star_hsts.sjs", + usesHSTS: true, + }, + { + desc: "stored HSTS from previous response", + url: "https://example.com/", + usesHSTS: true, + } +]; + +async function startTest() +{ + info("Test detection of HTTP Strict Transport Security."); + for (const testCase of TEST_CASES) { + await checkHSTS(testCase) + } + + // Reset HSTS state. + const gSSService = Cc["@mozilla.org/ssservice;1"].getService(Ci.nsISiteSecurityService); + const uri = Services.io.newURI(TEST_CASES[0].url); + gSSService.resetState(uri); + + SimpleTest.finish(); +} + +async function checkHSTS({desc, url, usesHSTS}) { + info("Testing HSTS for " + url); + const commands = await createCommandsForTab(); + const target = commands.targetCommand.targetFront; + const resourceCommand = commands.resourceCommand; + + const resource = await new Promise(resolve => { + resourceCommand + .watchResources([resourceCommand.TYPES.NETWORK_EVENT], { + onAvailable: () => {}, + onUpdated: resourceUpdate => { + resolve(resourceUpdate[0].resource); + }, + }) + .then(() => { + // Spawn the network requests after we started watching + const iframe = document.querySelector("iframe").contentWindow; + iframe.wrappedJSObject.makeXhrCallback("GET", url); + }); + }); + + const webConsoleFront = await target.getFront("console"); + const packet = await webConsoleFront.getSecurityInfo(resource.actor); + is( + packet.securityInfo.hsts, + usesHSTS, + "Strict Transport Security detected correctly for " + url + ); + await commands.destroy(); +} + +addEventListener("load", startTest, { once: true }); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_nsiconsolemessage.html b/devtools/shared/webconsole/test/chrome/test_nsiconsolemessage.html new file mode 100644 index 0000000000..4e460225df --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_nsiconsolemessage.html @@ -0,0 +1,74 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for nsIConsoleMessages</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Make sure that nsIConsoleMessages are logged. See bug 859756.</p> + +<script class="testbody" type="text/javascript"> +"use strict"; +SimpleTest.waitForExplicitFinish(); + +let expectedMessages = []; + +async function startTest() +{ + removeEventListener("load", startTest); + const {state} = await attachConsole(["PageError"]); + onAttach(state); +} + +function onAttach(aState) +{ + onLogMessage = onLogMessage.bind(null, aState); + aState.webConsoleFront.on("logMessage", onLogMessage); + + expectedMessages = [{ + message: "hello world! bug859756", + timeStamp: FRACTIONAL_NUMBER_REGEX, + }]; + + Services.console.logStringMessage("hello world! bug859756"); + + info("waiting for messages"); +} + +const receivedMessages = []; + +function onLogMessage(aState, aPacket) +{ + info("received message: " + aPacket.message); + + let found = false; + for (const expected of expectedMessages) { + if (expected.message == aPacket.message) { + found = true; + break; + } + } + if (!found) { + return; + } + + receivedMessages.push(aPacket); + if (receivedMessages.length != expectedMessages.length) { + return; + } + + aState.webConsoleFront.off("logMessage", onLogMessage); + + checkObject(receivedMessages, expectedMessages); + + closeDebugger(aState, () => SimpleTest.finish()); +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_object_actor.html b/devtools/shared/webconsole/test/chrome/test_object_actor.html new file mode 100644 index 0000000000..f42035e2ce --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_object_actor.html @@ -0,0 +1,158 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for the object actor</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the object actor</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +SpecialPowers.pushPrefEnv({ + "set": [["security.allow_eval_with_system_principal", true]] +}); + +async function startTest() { + removeEventListener("load", startTest); + + const longString = (new Array(DevToolsServer.LONG_STRING_LENGTH + 3)).join("\u0629"); + createTestGlobalVariable(longString); + + const {state} = await attachConsoleToTab(["ConsoleAPI"]); + const onConsoleApiCall = state.webConsoleFront.once("consoleAPICall"); + top.console.log("hello", top.wrappedJSObject.foobarObject); + const {message} = await onConsoleApiCall; + + info("checking the console API call packet"); + checkConsoleAPICall(message, { + level: "log", + filename: /test_object_actor/, + arguments: ["hello", { + type: "object", + actor: /[a-z]/, + }], + }); + + info("inspecting object properties"); + const {ownProperties} = await message.arguments[1].getPrototypeAndProperties(); + + const expectedProps = { + "abArray": { + value: { + type: "object", + class: "Array", + actor: /[a-z]/, + }, + }, + "foo": { + configurable: true, + enumerable: true, + writable: true, + value: 1, + }, + "foobar": { + value: "hello", + }, + "foobaz": { + value: { + type: "object", + class: "HTMLDocument", + actor: /[a-z]/, + }, + }, + "getterAndSetter": { + get: { + type: "object", + class: "Function", + actor: /[a-z]/, + }, + set: { + type: "object", + class: "Function", + actor: /[a-z]/, + }, + }, + "longStringObj": { + value: { + type: "object", + class: "Object", + actor: /[a-z]/, + }, + }, + "notInspectable": { + value: { + type: "object", + class: "Object", + actor: /[a-z]/, + }, + }, + "omg": { + value: { type: "null" }, + }, + "omgfn": { + value: { + type: "object", + class: "Function", + actor: /[a-z]/, + }, + }, + "tamarbuta": { + value: { + type: "longString", + initial: longString.substring(0, + DevToolsServer.LONG_STRING_INITIAL_LENGTH), + length: longString.length, + }, + }, + "testfoo": { + value: false, + }, + }; + is(Object.keys(ownProperties).length, Object.keys(expectedProps).length, + "number of enumerable properties"); + checkObject(ownProperties, expectedProps); + + await closeDebugger(state); + SimpleTest.finish(); +} + + +function createTestGlobalVariable(longString) { + // Here we put the objects in the correct window, to avoid having them all + // wrapped by proxies for cross-compartment access. + const foobarObject = top.Object.create(null); + foobarObject.tamarbuta = longString; + foobarObject.foo = 1; + foobarObject.foobar = "hello"; + foobarObject.omg = null; + foobarObject.testfoo = false; + foobarObject.notInspectable = top.Object.create(null); + foobarObject.omgfn = new top.Function("return 'myResult'"); + foobarObject.abArray = new top.Array("a", "b"); + foobarObject.foobaz = top.document; + + top.Object.defineProperty(foobarObject, "getterAndSetter", { + enumerable: true, + get: new top.Function("return 'foo';"), + set: new top.Function("1+2"), + }); + + foobarObject.longStringObj = top.Object.create(null); + foobarObject.longStringObj.toSource = new top.Function("'" + longString + "'"); + foobarObject.longStringObj.toString = new top.Function("'" + longString + "'"); + foobarObject.longStringObj.boom = "explode"; + top.wrappedJSObject.foobarObject = foobarObject; +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters.html b/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters.html new file mode 100644 index 0000000000..6ac292fb9a --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters.html @@ -0,0 +1,75 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for the native getters in object actors</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the native getters in object actors</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +async function startTest() { + removeEventListener("load", startTest); + const {state} = await attachConsoleToTab(["ConsoleAPI"]); + + const onConsoleAPICall = state.webConsoleFront.once("consoleAPICall"); + top.console.log("hello", document); + const {message} = await onConsoleAPICall; + + info("checking the console API call packet"); + checkConsoleAPICall(message, { + level: "log", + filename: /test_object_actor/, + arguments: ["hello", { + type: "object", + actor: /[a-z]/, + }], + }); + + info("inspecting object properties"); + const args = message.arguments; + const {ownProperties, safeGetterValues} = await args[1].getPrototypeAndProperties(); + + const expectedProps = { + "location": { + get: { + type: "object", + class: "Function", + actor: /[a-z]/, + }, + }, + }; + ok(Object.keys(ownProperties).length >= Object.keys(expectedProps).length, + "number of properties"); + + info("check ownProperties"); + checkObject(ownProperties, expectedProps); + + info("check safeGetterValues"); + checkObject(safeGetterValues, { + "title": { + getterValue: /native getters in object actors/, + getterPrototypeLevel: 2, + }, + "styleSheets": { + getterValue: /Front for obj\//, + getterPrototypeLevel: 2, + }, + }); + + await closeDebugger(state); + SimpleTest.finish(); +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters_lenient_this.html b/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters_lenient_this.html new file mode 100644 index 0000000000..473dfb3b03 --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters_lenient_this.html @@ -0,0 +1,54 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test that WebIDL attributes with the LenientThis extended attribute + do not appear in the wrong objects</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for the native getters in object actors</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +SimpleTest.waitForExplicitFinish(); + +async function startTest() { + removeEventListener("load", startTest); + const {state} = await attachConsoleToTab(["ConsoleAPI"]); + + const onConsoleApiCall = state.webConsoleFront.once("consoleAPICall"); + const docAsProto = Object.create(document); + top.console.log("hello", docAsProto); + const {message} = await onConsoleApiCall; + + info("checking the console API call packet"); + checkConsoleAPICall(message, { + level: "log", + filename: /test_object_actor/, + arguments: ["hello", { + type: "object", + actor: /[a-z]/, + }], + }); + + info("inspecting object properties"); + const args = message.arguments; + + const {ownProperties, safeGetterValues} = await args[1].getPrototypeAndProperties(); + + is(Object.keys(ownProperties).length, 0, "number of properties"); + is(Object.keys(safeGetterValues).length, 0, "number of safe getters"); + + await closeDebugger(state); + SimpleTest.finish(); +} + +addEventListener("load", startTest); +</script> +</body> +</html> diff --git a/devtools/shared/webconsole/test/chrome/test_page_errors.html b/devtools/shared/webconsole/test/chrome/test_page_errors.html new file mode 100644 index 0000000000..0976eed92d --- /dev/null +++ b/devtools/shared/webconsole/test/chrome/test_page_errors.html @@ -0,0 +1,224 @@ +<!DOCTYPE HTML> +<html lang="en"> +<head> + <meta charset="utf8"> + <title>Test for page errors</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="common.js"></script> + <!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> +</head> +<body> +<p>Test for page errors</p> + +<script class="testbody" type="text/javascript"> +"use strict"; + +const { MESSAGE_CATEGORY } = require("devtools/shared/constants"); +SimpleTest.waitForExplicitFinish(); + +const previousEnabled = window.docShell.cssErrorReportingEnabled; +window.docShell.cssErrorReportingEnabled = true; + +SimpleTest.registerCleanupFunction(() => { + window.docShell.cssErrorReportingEnabled = previousEnabled; +}); + +let expectedPageErrors = []; + +const NO_UNCAUGHT_EXCEPTION = Symbol(); + +function doPageErrors() { + expectedPageErrors = { + "document.body.style.color = 'fooColor';": { + errorMessage: /fooColor/, + sourceName: /test_page_errors/, + category: MESSAGE_CATEGORY.CSS_PARSER, + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: false, + warning: true, + }, + "document.doTheImpossible();": { + errorMessage: /doTheImpossible/, + errorMessageName: undefined, + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + "(42).toString(0);": { + errorMessage: /radix/, + errorMessageName: "JSMSG_BAD_RADIX", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + "'use strict'; (Object.freeze({name: 'Elsa', score: 157})).score = 0;": { + errorMessage: /read.only/, + errorMessageName: "JSMSG_READ_ONLY", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + "([]).length = -1": { + errorMessage: /array length/, + errorMessageName: "JSMSG_BAD_ARRAY_LENGTH", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + "'abc'.repeat(-1);": { + errorMessage: /repeat count.*non-negative/, + errorMessageName: "JSMSG_NEGATIVE_REPETITION_COUNT", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + "'a'.repeat(2e28);": { + errorMessage: /repeat count.*less than infinity/, + errorMessageName: "JSMSG_RESULTING_STRING_TOO_LARGE", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + "77.1234.toExponential(-1);": { + errorMessage: /out of range/, + errorMessageName: "JSMSG_PRECISION_RANGE", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + "function a() { return; 1 + 1; }": { + errorMessage: /unreachable code/, + errorMessageName: "JSMSG_STMT_AFTER_RETURN", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: false, + warning: true, + }, + "let a, a;": { + errorMessage: /redeclaration of/, + errorMessageName: "JSMSG_REDECLARED_VAR", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + notes: [ + { + messageBody: /Previously declared at line/, + frame: { + source: /test_page_errors/, + } + } + ] + }, + [`let error = new TypeError("abc"); + error.name = "MyError"; + error.message = "here"; + throw error`]: { + errorMessage: /MyError: here/, + errorMessageName: "", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + "DOMTokenList.prototype.contains.call([])": { + errorMessage: /does not implement interface/, + errorMessageName: "MSG_METHOD_THIS_DOES_NOT_IMPLEMENT_INTERFACE", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + }, + [`let error2 = new TypeError("abc"); + error2.name = "MyPromiseError"; + error2.message = "here2"; + Promise.reject(error2)`]: { + errorMessage: /MyPromiseError: here2/, + errorMessageName: "", + sourceName: /test_page_errors/, + category: "chrome javascript", + timeStamp: FRACTIONAL_NUMBER_REGEX, + error: true, + warning: false, + // Promise.reject doesn't produce an uncaught exception + // even though |exception: true|. + [NO_UNCAUGHT_EXCEPTION]: true + } + }; + + let container = document.createElement("script"); + for (const stmt of Object.keys(expectedPageErrors)) { + if (expectedPageErrors[stmt].error && + !expectedPageErrors[stmt][NO_UNCAUGHT_EXCEPTION]) { + SimpleTest.expectUncaughtException(); + } + info("starting stmt: " + stmt); + container = document.createElement("script"); + document.body.appendChild(container); + container.textContent = stmt; + document.body.removeChild(container); + info("ending stmt: " + stmt); + } +} + +async function startTest() { + removeEventListener("load", startTest); + + const {state} = await attachConsole(["PageError"]); + onAttach(state); +} + +function onAttach(state) { + onPageError = onPageError.bind(null, state); + state.webConsoleFront.on("pageError", onPageError); + doPageErrors(); +} + +const pageErrors = []; + +function onPageError(state, packet) { + if (!packet.pageError.sourceName.includes("test_page_errors")) { + info("Ignoring error from unknown source: " + packet.pageError.sourceName); + return; + } + + pageErrors.push(packet.pageError); + if (pageErrors.length != Object.keys(expectedPageErrors).length) { + return; + } + + state.webConsoleFront.off("pageError", onPageError); + + Object.values(expectedPageErrors).forEach(function(message, index) { + info("checking received page error #" + index); + checkObject(pageErrors[index], Object.values(expectedPageErrors)[index]); + }); + + closeDebugger(state, function() { + SimpleTest.finish(); + }); +} + +addEventListener("load", startTest); +</script> +</body> +</html> |