Files
firefox/devtools/shared/webconsole/test/common.js
T
Alexandre Poirot cf703aefe9 Bug 1513565 - Always use Target's WebConsoleClient instead of trying to instantiate it manually. r=yulia,nchevobbe
This will help getting rid of another usage of Target.form.
And also helps instantiating only one WebConsole client.
Once WebConsole becomes a front, we can replace all the target.activeTab
to target.getFront("console").

Differential Revision: https://phabricator.services.mozilla.com/D14278
2018-12-18 23:35:55 +00:00

281 lines
8.5 KiB
JavaScript

/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set ft= javascript ts=2 et sw=2 tw=80: */
/* 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 ObjectClient, attachConsole, attachConsoleToTab, attachConsoleToWorker,
closeDebugger, checkConsoleAPICalls, checkRawHeaders, runTests, nextTest, Ci, Cc,
withActiveServiceWorker, Services, consoleAPICall */
const {require} = ChromeUtils.import("resource://devtools/shared/Loader.jsm", {});
const {DebuggerServer} = require("devtools/server/main");
const {DebuggerClient} = require("devtools/shared/client/debugger-client");
const ObjectClient = require("devtools/shared/client/object-client");
const Services = require("Services");
const {TargetFactory} = require("devtools/client/framework/target");
function initCommon() {
// Services.prefs.setBoolPref("devtools.debugger.log", true);
}
function initDebuggerServer() {
DebuggerServer.init();
DebuggerServer.registerAllActors();
DebuggerServer.allowChromeProcess = true;
}
async function connectToDebugger() {
initCommon();
initDebuggerServer();
const transport = DebuggerServer.connectPipe();
const client = new DebuggerClient(transport);
await client.connect();
return client;
}
async function attachConsole(listeners, callback) {
const { state, response } = await _attachConsole(listeners);
callback(state, response);
}
async function attachConsoleToTab(listeners, callback) {
const { state, response } = await _attachConsole(listeners, true);
callback(state, response);
}
async function attachConsoleToWorker(listeners, callback) {
const { state, response } = await _attachConsole(listeners, true, true);
callback(state, response);
}
var _attachConsole = async function(
listeners, attachToTab, attachToWorker
) {
try {
const client = await connectToDebugger();
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 target, worker;
if (!attachToTab) {
const front = await client.mainRoot.getMainProcess();
target = await TargetFactory.forRemoteTab({
client,
activeTab: front,
chrome: true,
});
} else {
const targetFront = await client.mainRoot.getTab();
target = await TargetFactory.forRemoteTab({
client,
activeTab: targetFront,
});
if (attachToWorker) {
const workerName = "console-test-worker.js#" + new Date().getTime();
worker = new Worker(workerName);
await waitForMessage(worker);
const { workers } = await target.activeTab.listWorkers();
const workerTargetFront = workers.filter(w => w.url == workerName)[0];
if (!workerTargetFront) {
console.error("listWorkers failed. Unable to find the worker actor\n");
return null;
}
target = await TargetFactory.forRemoteTab({
client,
activeTab: workerTargetFront,
});
}
}
// Attach the Target in order to instantiate the console client
await target.attach();
const webConsoleClient = target.activeConsole;
// By default the console isn't listening for anything,
// request listeners from here
const response = await webConsoleClient.startListeners(listeners);
return {
state: {
dbgClient: client,
client: webConsoleClient,
actor: webConsoleClient.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;
};
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) {
if (expected.level != "trace" && expected.arguments) {
is(call.arguments.length, expected.arguments.length,
"number of arguments");
}
checkObject(call, expected);
}
function checkObject(object, expected) {
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 {DebuggerClient} debuggerClient
* @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(debuggerClient, consoleCall) {
const onConsoleAPICall = debuggerClient.addOneTimeListener("consoleAPICall");
consoleCall();
return onConsoleAPICall;
}