test-page-mod.js
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
const { Cc, Ci, Cu } = require("chrome");
const { PageMod } = require("sdk/page-mod");
const { testPageMod, handleReadyState, openNewTab,
contentScriptWhenServer, createLoader } = require("./page-mod/helpers");
const { Loader } = require("sdk/test/loader");
const tabs = require("sdk/tabs");
const { setTimeout } = require("sdk/timers");
const system = require("sdk/system/events");
const { open, getFrames, getMostRecentBrowserWindow, getInnerId } = require("sdk/window/utils");
const { getTabContentWindow, getActiveTab, setTabURL, openTab, closeTab,
getBrowserForTab } = require("sdk/tabs/utils");
const xulApp = require("sdk/system/xul-app");
const { isPrivateBrowsingSupported } = require("sdk/self");
const { isPrivate } = require("sdk/private-browsing");
const { openWebpage } = require("./private-browsing/helper");
const { isTabPBSupported, isWindowPBSupported } = require("sdk/private-browsing/utils");
const promise = require("sdk/core/promise");
const { pb } = require("./private-browsing/helper");
const { URL } = require("sdk/url");
const { defer, all, resolve } = require("sdk/core/promise");
const { waitUntil } = require("sdk/test/utils");
const data = require("./fixtures");
const { cleanUI, after } = require("sdk/test/utils");
const testPageURI = data.url("test.html");
function Isolate(worker) {
return "(" + worker + ")()";
}
/* Tests for the PageMod APIs */
exports.testPageMod1 = function*(assert) {
let modAttached = defer();
let mod = PageMod({
include: /about:/,
contentScriptWhen: "end",
contentScript: "new " + function WorkerScope() {
window.document.body.setAttribute("JEP-107", "worked");
self.port.once("done", () => {
self.port.emit("results", window.document.body.getAttribute("JEP-107"))
});
},
onAttach: function(worker) {
assert.equal(this, mod, "The 'this' object is the page mod.");
mod.port.once("results", modAttached.resolve)
mod.port.emit("done");
}
});
let tab = yield new Promise(resolve => {
tabs.open({
url: "about:",
inBackground: true,
onReady: resolve
})
});
assert.pass("test tab was opened.");
let worked = yield modAttached.promise;
assert.pass("test mod was attached.");
mod.destroy();
assert.pass("test mod was destroyed.");
assert.equal(worked, "worked", "PageMod.onReady test");
};
exports.testPageMod2 = function*(assert) {
let modAttached = defer();
let mod = PageMod({
include: testPageURI,
contentScriptWhen: "end",
contentScript: [
'new ' + function contentScript() {
window.AUQLUE = function() { return 42; }
try {
window.AUQLUE()
}
catch(e) {
throw new Error("PageMod scripts executed in order");
}
document.documentElement.setAttribute("first", "true");
},
'new ' + function contentScript() {
document.documentElement.setAttribute("second", "true");
self.port.once("done", () => {
self.port.emit("results", {
"first": window.document.documentElement.getAttribute("first"),
"second": window.document.documentElement.getAttribute("second"),
"AUQLUE": unsafeWindow.getAUQLUE()
});
});
}
],
onAttach: modAttached.resolve
});
let tab = yield new Promise(resolve => {
tabs.open({
url: testPageURI,
inBackground: true,
onReady: resolve
})
});
assert.pass("test tab was opened.");
let worker = yield modAttached.promise;
assert.pass("test mod was attached.");
let results = yield new Promise(resolve => {
worker.port.once("results", resolve)
worker.port.emit("done");
});
mod.destroy();
assert.pass("test mod was destroyed.");
assert.equal(results["first"],
"true",
"PageMod test #2: first script has run");
assert.equal(results["second"],
"true",
"PageMod test #2: second script has run");
assert.equal(results["AUQLUE"], false,
"PageMod test #2: scripts get a wrapped window");
};
exports.testPageModIncludes = function*(assert) {
var modsAttached = [];
var modNumber = 0;
var modAttached = defer();
let includes = [
"*",
"*.google.com",
"resource:*",
"resource:",
testPageURI
];
let expected = [
false,
false,
true,
false,
true
]
let mod = PageMod({
include: testPageURI,
contentScript: 'new ' + function() {
self.port.on("get-local-storage", () => {
let result = {};
self.options.forEach(include => {
result[include] = !!window.localStorage[include]
});
self.port.emit("got-local-storage", result);
window.localStorage.clear();
});
},
contentScriptOptions: includes,
onAttach: modAttached.resolve
});
function createPageModTest(include, expectedMatch) {
var modIndex = modNumber++;
let attached = defer();
modsAttached.push(expectedMatch ? attached.promise : resolve());
// ...and corresponding PageMod options
return PageMod({
include: include,
contentScript: 'new ' + function() {
self.on("message", function(msg) {
window.localStorage[msg] = true
self.port.emit('done');
});
},
// The testPageMod callback with test assertions is called on 'end',
// and we want this page mod to be attached before it gets called,
// so we attach it on 'start'.
contentScriptWhen: 'start',
onAttach: function(worker) {
assert.pass("mod " + modIndex + " was attached");
worker.port.once("done", () => {
assert.pass("mod " + modIndex + " is done");
attached.resolve(worker);
});
worker.postMessage(this.include[0]);
}
});
}
let mods = [
createPageModTest("*", false),
createPageModTest("*.google.com", false),
createPageModTest("resource:*", true),
createPageModTest("resource:", false),
createPageModTest(testPageURI, true)
];
let tab = yield new Promise(resolve => {
tabs.open({
url: testPageURI,
inBackground: true,
onReady: resolve
});
});
assert.pass("tab was opened");
yield all(modsAttached);
assert.pass("all mods were attached.");
mods.forEach(mod => mod.destroy());
assert.pass("all mods were destroyed.");
yield modAttached.promise;
assert.pass("final test mod was attached.");
yield new Promise(resolve => {
mod.port.on("got-local-storage", (storage) => {
includes.forEach((include, i) => {
assert.equal(storage[include], expected[i], "localStorage is correct for " + include);
});
resolve();
});
mod.port.emit("get-local-storage");
});
assert.pass("final test of localStorage is complete.");
mod.destroy();
assert.pass("final test mod was destroyed.");
};
exports.testPageModExcludes = function(assert, done) {
var asserts = [];
function createPageModTest(include, exclude, expectedMatch) {
// Create an 'onload' test function...
asserts.push(function(test, win) {
var matches = JSON.stringify([include, exclude]) in win.localStorage;
assert.ok(expectedMatch ? matches : !matches,
"[include, exclude] = [" + include + ", " + exclude +
"] match test, expected: " + expectedMatch);
});
// ...and corresponding PageMod options
return {
include: include,
exclude: exclude,
contentScript: 'new ' + function() {
self.on("message", function(msg) {
// The key in localStorage is "[<include>, <exclude>]".
window.localStorage[JSON.stringify(msg)] = true;
});
},
// The testPageMod callback with test assertions is called on 'end',
// and we want this page mod to be attached before it gets called,
// so we attach it on 'start'.
contentScriptWhen: 'start',
onAttach: function(worker) {
worker.postMessage([this.include[0], this.exclude[0]]);
}
};
}
testPageMod(assert, done, testPageURI, [
createPageModTest("*", testPageURI, false),
createPageModTest(testPageURI, testPageURI, false),
createPageModTest(testPageURI, "resource://*", false),
createPageModTest(testPageURI, "*.google.com", true)
],
function (win, done) {
waitUntil(() => win.localStorage[JSON.stringify([testPageURI, "*.google.com"])],
testPageURI + " page-mod to be executed")
.then(() => {
asserts.forEach(fn => fn(assert, win));
win.localStorage.clear();
done();
});
});
};
exports.testPageModValidationAttachTo = function(assert) {
[{ val: 'top', type: 'string "top"' },
{ val: 'frame', type: 'string "frame"' },
{ val: ['top', 'existing'], type: 'array with "top" and "existing"' },
{ val: ['frame', 'existing'], type: 'array with "frame" and "existing"' },
{ val: ['top'], type: 'array with "top"' },
{ val: ['frame'], type: 'array with "frame"' },
{ val: undefined, type: 'undefined' }].forEach((attachTo) => {
new PageMod({ attachTo: attachTo.val, include: '*.validation111' });
assert.pass("PageMod() does not throw when attachTo is " + attachTo.type);
});
[{ val: 'existing', type: 'string "existing"' },
{ val: ['existing'], type: 'array with "existing"' },
{ val: 'not-legit', type: 'string with "not-legit"' },
{ val: ['not-legit'], type: 'array with "not-legit"' },
{ val: {}, type: 'object' }].forEach((attachTo) => {
assert.throws(() =>
new PageMod({ attachTo: attachTo.val, include: '*.validation111' }),
/The `attachTo` option/,
"PageMod() throws when 'attachTo' option is " + attachTo.type + ".");
});
};
exports.testPageModValidationInclude = function(assert) {
[{ val: undefined, type: 'undefined' },
{ val: {}, type: 'object' },
{ val: [], type: 'empty array'},
{ val: [/regexp/, 1], type: 'array with non string/regexp' },
{ val: 1, type: 'number' }].forEach((include) => {
assert.throws(() => new PageMod({ include: include.val }),
/The `include` option must always contain atleast one rule/,
"PageMod() throws when 'include' option is " + include.type + ".");
});
[{ val: '*.validation111', type: 'string' },
{ val: /validation111/, type: 'regexp' },
{ val: ['*.validation111'], type: 'array with length > 0'}].forEach((include) => {
new PageMod({ include: include.val });
assert.pass("PageMod() does not throw when include option is " + include.type);
});
};
exports.testPageModValidationExclude = function(assert) {
let includeVal = '*.validation111';
[{ val: {}, type: 'object' },
{ val: [], type: 'empty array'},
{ val: [/regexp/, 1], type: 'array with non string/regexp' },
{ val: 1, type: 'number' }].forEach((exclude) => {
assert.throws(() => new PageMod({ include: includeVal, exclude: exclude.val }),
/If set, the `exclude` option must always contain at least one rule as a string, regular expression, or an array of strings and regular expressions./,
"PageMod() throws when 'exclude' option is " + exclude.type + ".");
});
[{ val: undefined, type: 'undefined' },
{ val: '*.validation111', type: 'string' },
{ val: /validation111/, type: 'regexp' },
{ val: ['*.validation111'], type: 'array with length > 0'}].forEach((exclude) => {
new PageMod({ include: includeVal, exclude: exclude.val });
assert.pass("PageMod() does not throw when exclude option is " + exclude.type);
});
};
/* Tests for internal functions. */
exports.testCommunication1 = function*(assert) {
let workerDone = defer();
let mod = PageMod({
include: "about:*",
contentScriptWhen: "end",
contentScript: 'new ' + function WorkerScope() {
self.on('message', function(msg) {
document.body.setAttribute('JEP-107', 'worked');
self.postMessage(document.body.getAttribute('JEP-107'));
});
self.port.on('get-jep-107', () => {
self.port.emit('got-jep-107', document.body.getAttribute('JEP-107'));
});
},
onAttach: function(worker) {
worker.on('error', function(e) {
assert.fail('Errors where reported');
});
worker.on('message', function(value) {
assert.equal(
"worked",
value,
"test comunication"
);
workerDone.resolve();
});
worker.postMessage("do it!")
}
});
let tab = yield new Promise(resolve => {
tabs.open({
url: "about:",
onReady: resolve
});
});
assert.pass("opened tab");
yield workerDone.promise;
assert.pass("the worker has made a change");
let value = yield new Promise(resolve => {
mod.port.once("got-jep-107", resolve);
mod.port.emit("get-jep-107");
});
assert.equal("worked", value, "attribute should be modified");
mod.destroy();
assert.pass("the worker was destroyed");
};
exports.testCommunication2 = function*(assert) {
let workerDone = defer();
let url = data.url("test.html");
let mod = PageMod({
include: url,
contentScriptWhen: 'start',
contentScript: 'new ' + function WorkerScope() {
document.documentElement.setAttribute('AUQLUE', 42);
window.addEventListener('load', function listener() {
self.postMessage({
msg: 'onload',
AUQLUE: document.documentElement.getAttribute('AUQLUE')
});
}, false);
self.on("message", function(msg) {
if (msg == "get window.test") {
unsafeWindow.changesInWindow();
}
self.postMessage({
msg: document.documentElement.getAttribute("test")
});
});
},
onAttach: function(worker) {
worker.on('error', function(e) {
assert.fail('Errors where reported');
});
worker.on('message', function({ msg, AUQLUE }) {
if ('onload' == msg) {
assert.equal('42', AUQLUE, 'PageMod scripts executed in order');
worker.postMessage('get window.test');
}
else {
assert.equal('changes in window', msg, 'PageMod test #2: second script has run');
workerDone.resolve();
}
});
}
});
let tab = yield new Promise(resolve => {
tabs.open({
url: url,
inBackground: true,
onReady: resolve
});
});
assert.pass("opened tab");
yield workerDone.promise;
mod.destroy();
assert.pass("the worker was destroyed");
};
exports.testEventEmitter = function(assert, done) {
let workerDone = false,
callbackDone = null;
testPageMod(assert, done, "about:", [{
include: "about:*",
contentScript: 'new ' + function WorkerScope() {
self.port.on('addon-to-content', function(data) {
self.port.emit('content-to-addon', data);
});
},
onAttach: function(worker) {
worker.on('error', function(e) {
assert.fail('Errors were reported : '+e);
});
worker.port.on('content-to-addon', function(value) {
assert.equal(
"worked",
value,
"EventEmitter API works!"
);
if (callbackDone)
callbackDone();
else
workerDone = true;
});
worker.port.emit('addon-to-content', 'worked');
}
}],
function(win, done) {
if (workerDone)
done();
else
callbackDone = done;
}
);
};
// Execute two concurrent page mods on same document to ensure that their
// JS contexts are different
exports.testMixedContext = function(assert, done) {
let doneCallback = null;
let messages = 0;
let modObject = {
include: "data:text/html;charset=utf-8,",
contentScript: 'new ' + function WorkerScope() {
// Both scripts will execute this,
// context is shared if one script see the other one modification.
let isContextShared = "sharedAttribute" in document;
self.postMessage(isContextShared);
document.sharedAttribute = true;
},
onAttach: function(w) {
w.on("message", function (isContextShared) {
if (isContextShared) {
assert.fail("Page mod contexts are mixed.");
doneCallback();
}
else if (++messages == 2) {
assert.pass("Page mod contexts are different.");
doneCallback();
}
});
}
};
testPageMod(assert, done, "data:text/html;charset=utf-8,", [modObject, modObject],
function(win, done) {
doneCallback = done;
}
);
};
exports.testHistory = function(assert, done) {
// We need a valid url in order to have a working History API.
// (i.e do not work on data: or about: pages)
// Test bug 679054.
let url = data.url("test-page-mod.html");
let callbackDone = null;
testPageMod(assert, done, url, [{
include: url,
contentScriptWhen: 'end',
contentScript: 'new ' + function WorkerScope() {
history.pushState({}, "", "#");
history.replaceState({foo: "bar"}, "", "#");
self.postMessage(history.state);
},
onAttach: function(worker) {
worker.on('message', function (data) {
assert.equal(JSON.stringify(data), JSON.stringify({foo: "bar"}),
"History API works!");
callbackDone();
});
}
}],
function(win, done) {
callbackDone = done;
}
);
};
exports.testRelatedTab = function(assert, done) {
let tab;
let pageMod = new PageMod({
include: "about:*",
onAttach: function(worker) {
assert.ok(!!worker.tab, "Worker.tab exists");
assert.equal(tab, worker.tab, "Worker.tab is valid");
pageMod.destroy();
tab.close(done);
}
});
tabs.open({
url: "about:",
onOpen: function onOpen(t) {
tab = t;
}
});
};
// related to bug #989288
// https://bugzilla.mozilla.org/show_bug.cgi?id=989288
exports.testRelatedTabNewWindow = function(assert, done) {
let url = "about:logo"
let pageMod = new PageMod({
include: url,
onAttach: function(worker) {
assert.equal(worker.tab.url, url, "Worker.tab.url is valid");
worker.tab.close(done);
}
});
tabs.activeTab.attach({
contentScript: "window.open('about:logo', '', " +
"'width=800,height=600,resizable=no,status=no,location=no');"
});
};
exports.testRelatedTabNoRequireTab = function(assert, done) {
let loader = Loader(module);
let tab;
let url = "data:text/html;charset=utf-8," + encodeURI("Test related worker tab 2");
let { PageMod } = loader.require("sdk/page-mod");
let pageMod = new PageMod({
include: url,
onAttach: function(worker) {
assert.equal(worker.tab.url, url, "Worker.tab.url is valid");
worker.tab.close(function() {
pageMod.destroy();
loader.unload();
done();
});
}
});
tabs.open(url);
};
exports.testRelatedTabNoOtherReqs = function(assert, done) {
let loader = Loader(module);
let { PageMod } = loader.require("sdk/page-mod");
let pageMod = new PageMod({
include: "about:blank?testRelatedTabNoOtherReqs",
onAttach: function(worker) {
assert.ok(!!worker.tab, "Worker.tab exists");
pageMod.destroy();
worker.tab.close(function() {
worker.destroy();
loader.unload();
done();
});
}
});
tabs.open({
url: "about:blank?testRelatedTabNoOtherReqs"
});
};
exports.testWorksWithExistingTabs = function(assert, done) {
let url = "data:text/html;charset=utf-8," + encodeURI("Test unique document");
let { PageMod } = require("sdk/page-mod");
tabs.open({
url: url,
onReady: function onReady(tab) {
let pageModOnExisting = new PageMod({
include: url,
attachTo: ["existing", "top", "frame"],
onAttach: function(worker) {
assert.ok(!!worker.tab, "Worker.tab exists");
assert.equal(tab, worker.tab, "A worker has been created on this existing tab");
worker.on('pageshow', () => {
assert.fail("Should not have seen pageshow for an already loaded page");
});
setTimeout(function() {
pageModOnExisting.destroy();
pageModOffExisting.destroy();
tab.close(done);
}, 0);
}
});
let pageModOffExisting = new PageMod({
include: url,
onAttach: function(worker) {
assert.fail("pageModOffExisting page-mod should not have attached to anything");
}
});
}
});
};
exports.testExistingFrameDoesntMatchInclude = function(assert, done) {
let iframeURL = 'data:text/html;charset=utf-8,UNIQUE-TEST-STRING-42';
let iframe = '<iframe src="' + iframeURL + '" />';
let url = 'data:text/html;charset=utf-8,' + encodeURIComponent(iframe);
tabs.open({
url: url,
onReady: function onReady(tab) {
let pagemod = new PageMod({
include: url,
attachTo: ['existing', 'frame'],
onAttach: function() {
assert.fail("Existing iframe URL doesn't match include, must not attach to anything");
}
});
setTimeout(function() {
assert.pass("PageMod didn't attach to anything")
pagemod.destroy();
tab.close(done);
}, 250);
}
});
};
exports.testExistingOnlyFrameMatchesInclude = function(assert, done) {
let iframeURL = 'data:text/html;charset=utf-8,UNIQUE-TEST-STRING-43';
let iframe = '<iframe src="' + iframeURL + '" />';
let url = 'data:text/html;charset=utf-8,' + encodeURIComponent(iframe);
tabs.open({
url: url,
onReady: function onReady(tab) {
let pagemod = new PageMod({
include: iframeURL,
attachTo: ['existing', 'frame'],
onAttach: function(worker) {
assert.equal(iframeURL, worker.url,
"PageMod attached to existing iframe when only it matches include rules");
pagemod.destroy();
tab.close(done);
}
});
}
});
};
exports.testAttachOnlyOncePerDocument = function(assert, done) {
let iframeURL = 'data:text/html;charset=utf-8,testAttachOnlyOncePerDocument';
let iframe = '<iframe src="' + iframeURL + '" />';
let url = 'data:text/html;charset=utf-8,' + encodeURIComponent(iframe);
let count = 0;
tabs.open({
url: url,
onReady: function onReady(tab) {
let pagemod = new PageMod({
include: iframeURL,
attachTo: ['existing', 'frame'],
onAttach: (worker) => {
count++;
assert.equal(iframeURL, worker.url,
"PageMod attached to existing iframe");
assert.equal(count, 1, "PageMod attached only once");
setTimeout(_ => {
assert.equal(count, 1, "PageMod attached only once");
pagemod.destroy();
tab.close(done);
}, 1);
}
});
}
});
}
exports.testContentScriptWhenDefault = function(assert) {
let pagemod = PageMod({include: '*'});
assert.equal(pagemod.contentScriptWhen, 'end', "Default contentScriptWhen is 'end'");
pagemod.destroy();
}
// test timing for all 3 contentScriptWhen options (start, ready, end)
// for new pages, or tabs opened after PageMod is created
exports.testContentScriptWhenForNewTabs = function(assert, done) {
let srv = contentScriptWhenServer();
let url = srv.URL + '?ForNewTabs';
let count = 0;
handleReadyState(url, 'start', {
onLoading: (tab) => {
assert.pass("PageMod is attached while document is loading");
checkDone(++count, tab, srv, done);
},
onInteractive: () => assert.fail("onInteractive should not be called with 'start'."),
onComplete: () => assert.fail("onComplete should not be called with 'start'."),
});
handleReadyState(url, 'ready', {
onInteractive: (tab) => {
assert.pass("PageMod is attached while document is interactive");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'ready'."),
onComplete: () => assert.fail("onComplete should not be called with 'ready'."),
});
handleReadyState(url, 'end', {
onComplete: (tab) => {
assert.pass("PageMod is attached when document is complete");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'end'."),
onInteractive: () => assert.fail("onInteractive should not be called with 'end'."),
});
tabs.open(url);
}
// test timing for all 3 contentScriptWhen options (start, ready, end)
// for PageMods created right as the tab is created (in tab.onOpen)
exports.testContentScriptWhenOnTabOpen = function(assert, done) {
let srv = contentScriptWhenServer();
let url = srv.URL + '?OnTabOpen';
let count = 0;
tabs.open({
url: url,
onOpen: function(tab) {
handleReadyState(url, 'start', {
onLoading: () => {
assert.pass("PageMod is attached while document is loading");
checkDone(++count, tab, srv, done);
},
onInteractive: () => assert.fail("onInteractive should not be called with 'start'."),
onComplete: () => assert.fail("onComplete should not be called with 'start'."),
});
handleReadyState(url, 'ready', {
onInteractive: () => {
assert.pass("PageMod is attached while document is interactive");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'ready'."),
onComplete: () => assert.fail("onComplete should not be called with 'ready'."),
});
handleReadyState(url, 'end', {
onComplete: () => {
assert.pass("PageMod is attached when document is complete");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'end'."),
onInteractive: () => assert.fail("onInteractive should not be called with 'end'."),
});
}
});
}
// test timing for all 3 contentScriptWhen options (start, ready, end)
// for PageMods created while the tab is interactive (in tab.onReady)
exports.testContentScriptWhenOnTabReady = function(assert, done) {
let srv = contentScriptWhenServer();
let url = srv.URL + '?OnTabReady';
let count = 0;
tabs.open({
url: url,
onReady: function(tab) {
handleReadyState(url, 'start', {
onInteractive: () => {
assert.pass("PageMod is attached while document is interactive");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'start'."),
onComplete: () => assert.fail("onComplete should not be called with 'start'."),
});
handleReadyState(url, 'ready', {
onInteractive: () => {
assert.pass("PageMod is attached while document is interactive");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'ready'."),
onComplete: () => assert.fail("onComplete should not be called with 'ready'."),
});
handleReadyState(url, 'end', {
onComplete: () => {
assert.pass("PageMod is attached when document is complete");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'end'."),
onInteractive: () => assert.fail("onInteractive should not be called with 'end'."),
});
}
});
}
// test timing for all 3 contentScriptWhen options (start, ready, end)
// for PageMods created after a tab has completed loading (in tab.onLoad)
exports.testContentScriptWhenOnTabLoad = function(assert, done) {
let srv = contentScriptWhenServer();
let url = srv.URL + '?OnTabLoad';
let count = 0;
tabs.open({
url: url,
onLoad: function(tab) {
handleReadyState(url, 'start', {
onComplete: () => {
assert.pass("PageMod is attached when document is complete");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'start'."),
onInteractive: () => assert.fail("onInteractive should not be called with 'start'."),
});
handleReadyState(url, 'ready', {
onComplete: () => {
assert.pass("PageMod is attached when document is complete");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'ready'."),
onInteractive: () => assert.fail("onInteractive should not be called with 'ready'."),
});
handleReadyState(url, 'end', {
onComplete: () => {
assert.pass("PageMod is attached when document is complete");
checkDone(++count, tab, srv, done);
},
onLoading: () => assert.fail("onLoading should not be called with 'end'."),
onInteractive: () => assert.fail("onInteractive should not be called with 'end'."),
});
}
});
}
function checkDone(count, tab, srv, done) {
if (count === 3)
tab.close(_ => srv.stop(done));
}
exports.testTabWorkerOnMessage = function(assert, done) {
let { browserWindows } = require("sdk/windows");
let tabs = require("sdk/tabs");
let { PageMod } = require("sdk/page-mod");
let url1 = "data:text/html;charset=utf-8,<title>tab1</title><h1>worker1.tab</h1>";
let url2 = "data:text/html;charset=utf-8,<title>tab2</title><h1>worker2.tab</h1>";
let worker1 = null;
let mod = PageMod({
include: "data:text/html*",
contentScriptWhen: "ready",
contentScript: "self.postMessage('#1');",
onAttach: function onAttach(worker) {
worker.on("message", function onMessage() {
this.tab.attach({
contentScriptWhen: "ready",
contentScript: "self.postMessage({ url: window.location.href, title: document.title });",
onMessage: function onMessage(data) {
assert.equal(this.tab.url, data.url, "location is correct");
assert.equal(this.tab.title, data.title, "title is correct");
if (this.tab.url === url1) {
worker1 = this;
tabs.open({ url: url2, inBackground: true });
}
else if (this.tab.url === url2) {
mod.destroy();
worker1.tab.close(function() {
worker1.destroy();
worker.tab.close(function() {
worker.destroy();
done();
});
});
}
}
});
});
}
});
tabs.open(url1);
};
exports.testAutomaticDestroy = function(assert, done) {
let loader = Loader(module);
let pageMod = loader.require("sdk/page-mod").PageMod({
include: "about:*",
contentScriptWhen: "start",
onAttach: function(w) {
assert.fail("Page-mod should have been detroyed during module unload");
}
});
// Unload the page-mod module so that our page mod is destroyed
loader.unload();
// Then create a second tab to ensure that it is correctly destroyed
let tabs = require("sdk/tabs");
tabs.open({
url: "about:",
onReady: function onReady(tab) {
assert.pass("check automatic destroy");
tab.close(done);
}
});
};
exports.testAttachToTabsOnly = function(assert, done) {
let { PageMod } = require('sdk/page-mod');
let openedTab = null; // Tab opened in openTabWithIframe()
let workerCount = 0;
let mod = PageMod({
include: 'data:text/html*',
contentScriptWhen: 'start',
contentScript: '',
onAttach: function onAttach(worker) {
if (worker.tab === openedTab) {
if (++workerCount == 3) {
assert.pass('Succesfully applied to tab documents and its iframe');
worker.destroy();
mod.destroy();
openedTab.close(done);
}
}
else {
assert.fail('page-mod attached to a non-tab document');
}
}
});
function openHiddenFrame() {
assert.pass('Open iframe in hidden window');
let hiddenFrames = require('sdk/frame/hidden-frame');
let hiddenFrame = hiddenFrames.add(hiddenFrames.HiddenFrame({
onReady: function () {
let element = this.element;
element.addEventListener('DOMContentLoaded', function onload() {
element.removeEventListener('DOMContentLoaded', onload, false);
hiddenFrames.remove(hiddenFrame);
if (!xulApp.is("Fennec")) {
openToplevelWindow();
}
else {
openBrowserIframe();
}
}, false);
element.setAttribute('src', 'data:text/html;charset=utf-8,foo');
}
}));
}
function openToplevelWindow() {
assert.pass('Open toplevel window');
let win = open('data:text/html;charset=utf-8,bar');
win.addEventListener('DOMContentLoaded', function onload() {
win.removeEventListener('DOMContentLoaded', onload, false);
win.close();
openBrowserIframe();
}, false);
}
function openBrowserIframe() {
assert.pass('Open iframe in browser window');
let window = require('sdk/deprecated/window-utils').activeBrowserWindow;
let document = window.document;
let iframe = document.createElement('iframe');
iframe.setAttribute('type', 'content');
iframe.setAttribute('src', 'data:text/html;charset=utf-8,foobar');
iframe.addEventListener('DOMContentLoaded', function onload() {
iframe.removeEventListener('DOMContentLoaded', onload, false);
iframe.parentNode.removeChild(iframe);
openTabWithIframes();
}, false);
document.documentElement.appendChild(iframe);
}
// Only these three documents will be accepted by the page-mod
function openTabWithIframes() {
assert.pass('Open iframes in a tab');
let subContent = '<iframe src="data:text/html;charset=utf-8,sub frame" />'
let content = '<iframe src="data:text/html;charset=utf-8,' +
encodeURIComponent(subContent) + '" />';
require('sdk/tabs').open({
url: 'data:text/html;charset=utf-8,' + encodeURIComponent(content),
onOpen: function onOpen(tab) {
openedTab = tab;
}
});
}
openHiddenFrame();
};
exports['test111 attachTo [top]'] = function(assert, done) {
let { PageMod } = require('sdk/page-mod');
let subContent = '<iframe src="data:text/html;charset=utf-8,sub frame" />'
let content = '<iframe src="data:text/html;charset=utf-8,' +
encodeURIComponent(subContent) + '" />';
let topDocumentURL = 'data:text/html;charset=utf-8,' + encodeURIComponent(content)
let workerCount = 0;
let mod = PageMod({
include: 'data:text/html*',
contentScriptWhen: 'start',
contentScript: 'self.postMessage(document.location.href);',
attachTo: ['top'],
onAttach: function onAttach(worker) {
if (++workerCount == 1) {
worker.on('message', function (href) {
assert.equal(href, topDocumentURL,
"worker on top level document only");
let tab = worker.tab;
worker.destroy();
mod.destroy();
tab.close(done);
});
}
else {
assert.fail('page-mod attached to a non-top document');
}
}
});
require('sdk/tabs').open(topDocumentURL);
};
exports['test111 attachTo [frame]'] = function(assert, done) {
let { PageMod } = require('sdk/page-mod');
let subFrameURL = 'data:text/html;charset=utf-8,subframe';
let subContent = '<iframe src="' + subFrameURL + '" />';
let frameURL = 'data:text/html;charset=utf-8,' + encodeURIComponent(subContent);
let content = '<iframe src="' + frameURL + '" />';
let topDocumentURL = 'data:text/html;charset=utf-8,' + encodeURIComponent(content)
let workerCount = 0, messageCount = 0;
function onMessage(href) {
if (href == frameURL)
assert.pass("worker on first frame");
else if (href == subFrameURL)
assert.pass("worker on second frame");
else
assert.fail("worker on unexpected document: " + href);
this.destroy();
if (++messageCount == 2) {
mod.destroy();
require('sdk/tabs').activeTab.close(done);
}
}
let mod = PageMod({
include: 'data:text/html*',
contentScriptWhen: 'start',
contentScript: 'self.postMessage(document.location.href);',
attachTo: ['frame'],
onAttach: function onAttach(worker) {
if (++workerCount <= 2) {
worker.on('message', onMessage);
}
else {
assert.fail('page-mod attached to a non-frame document');
}
}
});
require('sdk/tabs').open(topDocumentURL);
};
exports.testContentScriptOptionsOption = function(assert, done) {
let callbackDone = null;
testPageMod(assert, done, "about:", [{
include: "about:*",
contentScript: "self.postMessage( [typeof self.options.d, self.options] );",
contentScriptWhen: "end",
contentScriptOptions: {a: true, b: [1,2,3], c: "string", d: function(){ return 'test'}},
onAttach: function(worker) {
worker.on('message', function(msg) {
assert.equal( msg[0], 'undefined', 'functions are stripped from contentScriptOptions' );
assert.equal( typeof msg[1], 'object', 'object as contentScriptOptions' );
assert.equal( msg[1].a, true, 'boolean in contentScriptOptions' );
assert.equal( msg[1].b.join(), '1,2,3', 'array and numbers in contentScriptOptions' );
assert.equal( msg[1].c, 'string', 'string in contentScriptOptions' );
callbackDone();
});
}
}],
function(win, done) {
callbackDone = done;
}
);
};
exports.testPageModCss = function(assert, done) {
let [pageMod] = testPageMod(assert, done,
'data:text/html;charset=utf-8,<div style="background: silver">css test</div>', [{
include: ["*", "data:*"],
contentStyle: "div { height: 100px; }",
contentStyleFile: [data.url("include-file.css"), "./border-style.css"]
}],
function(win, done) {
let div = win.document.querySelector("div");
assert.equal(div.clientHeight, 100,
"PageMod contentStyle worked");
assert.equal(div.offsetHeight, 120,
"PageMod contentStyleFile worked");
assert.equal(win.getComputedStyle(div).borderTopStyle, "dashed",
"PageMod contentStyleFile with relative path worked");
done();
}
);
};
exports.testPageModCssList = function*(assert) {
const URL = 'data:text/html;charset=utf-8,<div style="width:320px; max-width: 480px!important">css test</div>';
let modAttached = defer();
let pageMod = PageMod({
include: "data:*",
contentStyleFile: [
// Highlight evaluation order in this list
"data:text/css;charset=utf-8,div { border: 1px solid black; }",
"data:text/css;charset=utf-8,div { border: 10px solid black; }",
// Highlight evaluation order between contentStylesheet & contentStylesheetFile
"data:text/css;charset=utf-8s,div { height: 1000px; }",
// Highlight precedence between the author and user style sheet
"data:text/css;charset=utf-8,div { width: 200px; max-width: 640px!important}",
],
contentStyle: [
"div { height: 10px; }",
"div { height: 100px; }"
],
contentScript: 'new ' + function WorkerScope() {
self.port.on('get-results', () => {
let div = window.document.querySelector('div');
let style = window.getComputedStyle(div);
self.port.emit("results", {
clientHeight: div.clientHeight,
offsetHeight: div.offsetHeight,
width: style.width,
maxWidth: style.maxWidth
});
})
},
onAttach: modAttached.resolve
});
let tab = yield new Promise(resolve => {
tabs.open({
url: URL,
onReady: resolve
});
});
assert.pass("the tab was opened");
yield modAttached.promise;
assert.pass("the mod has been attached");
let results = yield new Promise(resolve => {
pageMod.port.on("results", resolve);
pageMod.port.emit("get-results");
})
assert.equal(
results.clientHeight,
100,
"PageMod contentStyle list works and is evaluated after contentStyleFile"
);
assert.equal(
results.offsetHeight,
120,
"PageMod contentStyleFile list works"
);
assert.equal(
results.width,
"320px",
"PageMod add-on author/page author style sheet precedence works"
);
assert.equal(
results.maxWidth,
"480px",
"PageMod add-on author/page author style sheet precedence with !important works"
);
pageMod.destroy();
assert.pass("the page mod was destroyed");
};
exports.testPageModCssDestroy = function(assert, done) {
let loader = Loader(module);
tabs.open({
url: "data:text/html;charset=utf-8,<div style='width:200px'>css test</div>",
onReady: function onReady(tab) {
let browserWindow = getMostRecentBrowserWindow();
let win = getTabContentWindow(getActiveTab(browserWindow));
let div = win.document.querySelector("div");
let style = win.getComputedStyle(div);
assert.equal(
style.width,
"200px",
"PageMod contentStyle is current before page-mod applies"
);
let pageMod = loader.require("sdk/page-mod").PageMod({
include: "data:*",
contentStyle: "div { width: 100px!important; }",
attachTo: ["top", "existing"],
onAttach: function(worker) {
assert.equal(
style.width,
"100px",
"PageMod contentStyle worked"
);
worker.once('detach', () => {
assert.equal(
style.width,
"200px",
"PageMod contentStyle is removed after page-mod destroy"
);
tab.close(done);
});
pageMod.destroy();
}
});
}
});
};
exports.testPageModCssAutomaticDestroy = function(assert, done) {
let loader = Loader(module);
tabs.open({
url: "data:text/html;charset=utf-8,<div style='width:200px'>css test</div>",
onReady: function onReady(tab) {
let browserWindow = getMostRecentBrowserWindow();
let win = getTabContentWindow(getActiveTab(browserWindow));
let div = win.document.querySelector("div");
let style = win.getComputedStyle(div);
assert.equal(
style.width,
"200px",
"PageMod contentStyle is current before page-mod applies"
);
let pageMod = loader.require("sdk/page-mod").PageMod({
include: "data:*",
contentStyle: "div { width: 100px!important; }",
attachTo: ["top", "existing"],
onAttach: function(worker) {
assert.equal(
style.width,
"100px",
"PageMod contentStyle worked"
);
// Wait for a second page-mod to attach to be sure the unload
// message has made it to the child
let pageMod2 = PageMod({
include: "data:*",
contentStyle: "div { width: 100px!important; }",
attachTo: ["top", "existing"],
onAttach: function(worker) {
assert.equal(
style.width,
"200px",
"PageMod contentStyle is removed after page-mod destroy"
);
pageMod2.destroy();
tab.close(done);
}
});
loader.unload();
}
});
}
});
};
exports.testPageModContentScriptFile = function(assert, done) {
let loader = createLoader();
let { PageMod } = loader.require("sdk/page-mod");
tabs.open({
url: "about:license",
onReady: function(tab) {
let mod = PageMod({
include: "about:*",
attachTo: ["existing", "top"],
contentScriptFile: "./test-contentScriptFile.js",
onMessage: message => {
assert.equal(message, "msg from contentScriptFile",
"PageMod contentScriptFile with relative path worked");
tab.close(function() {
mod.destroy();
loader.unload();
done();
});
}
});
}
})
};
exports.testPageModTimeout = function(assert, done) {
let tab = null
let loader = Loader(module);
let { PageMod } = loader.require("sdk/page-mod");
let mod = PageMod({
include: "data:*",
contentScript: Isolate(function() {
var id = setTimeout(function() {
self.port.emit("fired", id)
}, 10)
self.port.emit("scheduled", id);
}),
onAttach: function(worker) {
worker.port.on("scheduled", function(id) {
assert.pass("timer was scheduled")
worker.port.on("fired", function(data) {
assert.equal(id, data, "timer was fired")
tab.close(function() {
worker.destroy()
loader.unload()
done()
});
})
})
}
});
tabs.open({
url: "data:text/html;charset=utf-8,timeout",
onReady: function($) { tab = $ }
})
}
exports.testPageModcancelTimeout = function(assert, done) {
let tab = null
let loader = Loader(module);
let { PageMod } = loader.require("sdk/page-mod");
let mod = PageMod({
include: "data:*",
contentScript: Isolate(function() {
var id1 = setTimeout(function() {
self.port.emit("failed")
}, 10)
var id2 = setTimeout(function() {
self.port.emit("timeout")
}, 100)
clearTimeout(id1)
}),
onAttach: function(worker) {
worker.port.on("failed", function() {
assert.fail("cancelled timeout fired")
})
worker.port.on("timeout", function(id) {
assert.pass("timer was scheduled")
tab.close(function() {
worker.destroy();
mod.destroy();
loader.unload();
done();
});
})
}
});
tabs.open({
url: "data:text/html;charset=utf-8,cancell timeout",
onReady: function($) { tab = $ }
})
}
exports.testExistingOnFrames = function(assert, done) {
let subFrameURL = 'data:text/html;charset=utf-8,testExistingOnFrames-sub-frame';
let subIFrame = '<iframe src="' + subFrameURL + '" />'
let iFrameURL = 'data:text/html;charset=utf-8,' + encodeURIComponent(subIFrame)
let iFrame = '<iframe src="' + iFrameURL + '" />';
let url = 'data:text/html;charset=utf-8,' + encodeURIComponent(iFrame);
// we want all urls related to the test here, and not just the iframe urls
// because we need to fail if the test is applied to the top window url.
let urls = [url, iFrameURL, subFrameURL];
let counter = 0;
let tab = openTab(getMostRecentBrowserWindow(), url);
function wait4Iframes() {
let window = getTabContentWindow(tab);
if (window.document.readyState != "complete" ||
getFrames(window).length != 2) {
return;
}
let pagemodOnExisting = PageMod({
include: ["*", "data:*"],
attachTo: ["existing", "frame"],
contentScriptWhen: 'ready',
onAttach: function(worker) {
// need to ignore urls that are not part of the test, because other
// tests are not closing their tabs when they complete..
if (urls.indexOf(worker.url) == -1)
return;
assert.notEqual(url,
worker.url,
'worker should not be attached to the top window');
if (++counter < 2) {
// we can rely on this order in this case because we are sure that
// the frames being tested have completely loaded
assert.equal(iFrameURL, worker.url, '1st attach is for top frame');
}
else if (counter > 2) {
assert.fail('applied page mod too many times');
}
else {
assert.equal(subFrameURL, worker.url, '2nd attach is for sub frame');
// need timeout because onAttach is called before the constructor returns
setTimeout(function() {
pagemodOnExisting.destroy();
pagemodOffExisting.destroy();
closeTab(tab);
done();
}, 0);
}
}
});
let pagemodOffExisting = PageMod({
include: ["*", "data:*"],
attachTo: ["frame"],
contentScriptWhen: 'ready',
onAttach: function(mod) {
assert.fail('pagemodOffExisting page-mod should not have been attached');
}
});
}
getBrowserForTab(tab).addEventListener("load", wait4Iframes, true);
};
exports.testIFramePostMessage = function(assert, done) {
let count = 0;
tabs.open({
url: data.url("test-iframe.html"),
onReady: function(tab) {
var worker = tab.attach({
contentScriptFile: data.url('test-iframe.js'),
contentScript: 'var iframePath = \'' + data.url('test-iframe-postmessage.html') + '\'',
onMessage: function(msg) {
assert.equal(++count, 1);
assert.equal(msg.first, 'a string');
assert.ok(msg.second[1], "array");
assert.equal(typeof msg.third, 'object');
worker.destroy();
tab.close(done);
}
});
}
});
};
exports.testEvents = function*(assert) {
let modAttached = defer();
let content = "<script>\n new " + function DocumentScope() {
window.addEventListener("ContentScriptEvent", function () {
window.document.body.setAttribute("receivedEvent", "ok");
}, false);
} + "\n</script>";
let url = "data:text/html;charset=utf-8," + encodeURIComponent(content);
let mod = PageMod({
include: "data:*",
contentScript: 'new ' + function WorkerScope() {
let evt = document.createEvent("Event");
evt.initEvent("ContentScriptEvent", true, true);
document.body.dispatchEvent(evt);
self.port.on("get-result", () => {
self.port.emit("result", {
receivedEvent: window.document.body.getAttribute("receivedEvent")
});
});
},
onAttach: modAttached.resolve
});
let tab = yield new Promise(resolve => {
tabs.open({
url: url,
onReady: resolve
});
});
assert.pass("the tab is ready");
yield modAttached.promise;
assert.pass("the mod was attached")
let result = yield new Promise(resolve => {
mod.port.once("result", resolve);
mod.port.emit("get-result");
});
assert.equal(result.receivedEvent, "ok",
"Content script sent an event and document received it");
};
exports["test page-mod on private tab"] = function (assert, done) {
let fail = assert.fail.bind(assert);
let privateUri = "data:text/html;charset=utf-8," +
"<iframe src=\"data:text/html;charset=utf-8,frame\" />";
let nonPrivateUri = "data:text/html;charset=utf-8,non-private";
let pageMod = new PageMod({
include: "data:*",
onAttach: function(worker) {
if (isTabPBSupported || isWindowPBSupported) {
// When PB isn't supported, the page-mod will apply to all document
// as all of them will be non-private
assert.equal(worker.tab.url,
nonPrivateUri,
"page-mod should only attach to the non-private tab");
}
assert.ok(!isPrivate(worker),
"The worker is really non-private");
assert.ok(!isPrivate(worker.tab),
"The document is really non-private");
pageMod.destroy();
page1.close().
then(page2.close).
then(done, fail);
}
});
let page1, page2;
page1 = openWebpage(privateUri, true);
page1.ready.then(function() {
page2 = openWebpage(nonPrivateUri, false);
}, fail);
}
// Bug 699450: Calling worker.tab.close() should not lead to exception
exports.testWorkerTabClose = function(assert, done) {
let callbackDone;
testPageMod(assert, done, "about:", [{
include: "about:",
contentScript: '',
onAttach: function(worker) {
assert.pass("The page-mod was attached");
worker.tab.close(function () {
// On Fennec, tab is completely destroyed right after close event is
// dispatch, so we need to wait for the next event loop cycle to
// check for tab nulliness.
setTimeout(function () {
assert.ok(!worker.tab,
"worker.tab should be null right after tab.close()");
callbackDone();
}, 0);
});
}
}],
function(win, done) {
callbackDone = done;
}
);
};
exports.testDetachOnDestroy = function(assert, done) {
let tab;
const TEST_URL = 'data:text/html;charset=utf-8,detach';
const loader = Loader(module);
const { PageMod } = loader.require('sdk/page-mod');
let mod1 = PageMod({
include: TEST_URL,
contentScript: Isolate(function() {
self.port.on('detach', function(reason) {
window.document.body.innerHTML += '!' + reason;
});
}),
onAttach: worker => {
assert.pass('attach[1] happened');
worker.on('detach', _ => setTimeout(_ => {
assert.pass('detach happened');
let mod2 = PageMod({
attachTo: [ 'existing', 'top' ],
include: TEST_URL,
contentScript: Isolate(function() {
self.port.on('test', _ => {
self.port.emit('result', { result: window.document.body.innerHTML});
});
}),
onAttach: worker => {
assert.pass('attach[2] happened');
worker.port.once('result', ({ result }) => {
assert.equal(result, 'detach!', 'the body.innerHTML is as expected');
mod1.destroy();
mod2.destroy();
loader.unload();
tab.close(done);
});
worker.port.emit('test');
}
});
}));
worker.destroy();
}
});
tabs.open({
url: TEST_URL,
onOpen: t => tab = t
})
}
exports.testDetachOnUnload = function(assert, done) {
let tab;
const TEST_URL = 'data:text/html;charset=utf-8,detach';
const loader = Loader(module);
const { PageMod } = loader.require('sdk/page-mod');
let mod1 = PageMod({
include: TEST_URL,
contentScript: Isolate(function() {
self.port.on('detach', function(reason) {
window.document.body.innerHTML += '!' + reason;
});
}),
onAttach: worker => {
assert.pass('attach[1] happened');
worker.on('detach', _ => setTimeout(_ => {
assert.pass('detach happened');
let mod2 = require('sdk/page-mod').PageMod({
attachTo: [ 'existing', 'top' ],
include: TEST_URL,
contentScript: Isolate(function() {
self.port.on('test', _ => {
self.port.emit('result', { result: window.document.body.innerHTML});
});
}),
onAttach: worker => {
assert.pass('attach[2] happened');
worker.port.once('result', ({ result }) => {
assert.equal(result, 'detach!shutdown', 'the body.innerHTML is as expected');
mod2.destroy();
tab.close(done);
});
worker.port.emit('test');
}
});
}));
loader.unload('shutdown');
}
});
tabs.open({
url: TEST_URL,
onOpen: t => tab = t
})
}
exports.testConsole = function(assert, done) {
let innerID;
const TEST_URL = 'data:text/html;charset=utf-8,console';
let seenMessage = false;
system.on('console-api-log-event', onMessage);
function onMessage({ subject: { wrappedJSObject: msg }}) {
if (msg.arguments[0] !== "Hello from the page mod")
return;
seenMessage = true;
innerID = msg.innerID;
}
let mod = PageMod({
include: TEST_URL,
contentScriptWhen: "ready",
contentScript: Isolate(function() {
console.log("Hello from the page mod");
self.port.emit("done");
}),
onAttach: function(worker) {
worker.port.on("done", function() {
let window = getTabContentWindow(tab);
let id = getInnerId(window);
assert.ok(seenMessage, "Should have seen the console message");
assert.equal(innerID, id, "Should have seen the right inner ID");
system.off('console-api-log-event', onMessage);
mod.destroy();
closeTab(tab);
done();
});
},
});
let tab = openTab(getMostRecentBrowserWindow(), TEST_URL);
}
exports.testSyntaxErrorInContentScript = function *(assert) {
const url = "data:text/html;charset=utf-8,testSyntaxErrorInContentScript";
const loader = createLoader();
const { PageMod } = loader.require("sdk/page-mod");
let attached = defer();
let errored = defer();
let mod = PageMod({
include: url,
contentScript: 'console.log(23',
onAttach: attached.resolve,
onError: errored.resolve
});
openNewTab(url);
yield attached.promise;
let hitError = yield errored.promise;
assert.notStrictEqual(hitError, null, "The syntax error was reported.");
assert.equal(hitError.name, "SyntaxError", "The error thrown should be a SyntaxError");
loader.unload();
yield cleanUI();
};
exports.testPageShowWhenStart = function(assert, done) {
const TEST_URL = 'data:text/html;charset=utf-8,detach';
let sawWorkerPageShow = false;
let sawInjected = false;
let sawContentScriptPageShow = false;
let mod = PageMod({
include: TEST_URL,
contentScriptWhen: 'start',
contentScript: Isolate(function() {
self.port.emit("injected");
self.on("pageshow", () => {
self.port.emit("pageshow");
});
}),
onAttach: worker => {
worker.port.on("injected", () => {
sawInjected = true;
});
worker.port.on("pageshow", () => {
sawContentScriptPageShow = true;
closeTab(tab);
});
worker.on("pageshow", () => {
sawWorkerPageShow = true;
});
worker.on("detach", () => {
assert.ok(sawWorkerPageShow, "Worker emitted pageshow");
assert.ok(sawInjected, "Content script ran");
assert.ok(sawContentScriptPageShow, "Content script saw pageshow");
mod.destroy();
done();
});
}
});
let tab = openTab(getMostRecentBrowserWindow(), TEST_URL);
};
exports.testPageShowWhenReady = function(assert, done) {
const TEST_URL = 'data:text/html;charset=utf-8,detach';
let sawWorkerPageShow = false;
let sawInjected = false;
let sawContentScriptPageShow = false;
let mod = PageMod({
include: TEST_URL,
contentScriptWhen: 'ready',
contentScript: Isolate(function() {
self.port.emit("injected");
self.on("pageshow", () => {
self.port.emit("pageshow");
});
}),
onAttach: worker => {
worker.port.on("injected", () => {
sawInjected = true;
});
worker.port.on("pageshow", () => {
sawContentScriptPageShow = true;
closeTab(tab);
});
worker.on("pageshow", () => {
sawWorkerPageShow = true;
});
worker.on("detach", () => {
assert.ok(sawWorkerPageShow, "Worker emitted pageshow");
assert.ok(sawInjected, "Content script ran");
assert.ok(sawContentScriptPageShow, "Content script saw pageshow");
mod.destroy();
done();
});
}
});
let tab = openTab(getMostRecentBrowserWindow(), TEST_URL);
};
exports.testPageShowWhenEnd = function(assert, done) {
const TEST_URL = 'data:text/html;charset=utf-8,detach';
let sawWorkerPageShow = false;
let sawInjected = false;
let sawContentScriptPageShow = false;
let mod = PageMod({
include: TEST_URL,
contentScriptWhen: 'end',
contentScript: Isolate(function() {
self.port.emit("injected");
self.on("pageshow", () => {
self.port.emit("pageshow");
});
}),
onAttach: worker => {
worker.port.on("injected", () => {
sawInjected = true;
});
worker.port.on("pageshow", () => {
sawContentScriptPageShow = true;
closeTab(tab);
});
worker.on("pageshow", () => {
sawWorkerPageShow = true;
});
worker.on("detach", () => {
assert.ok(sawWorkerPageShow, "Worker emitted pageshow");
assert.ok(sawInjected, "Content script ran");
assert.ok(sawContentScriptPageShow, "Content script saw pageshow");
mod.destroy();
done();
});
}
});
let tab = openTab(getMostRecentBrowserWindow(), TEST_URL);
};
// Tests that after destroy existing workers have been destroyed
exports.testDestroyKillsChild = function(assert, done) {
const TEST_URL = 'data:text/html;charset=utf-8,detach';
let mod1 = PageMod({
include: TEST_URL,
contentScriptWhen: 'end',
contentScript: Isolate(function() {
self.port.on("ping", detail => {
let event = document.createEvent("CustomEvent");
event.initCustomEvent("Test:Ping", true, true, detail);
document.dispatchEvent(event);
self.port.emit("pingsent");
});
let listener = function(event) {
self.port.emit("pong", event.detail);
};
self.port.on("detach", () => {
window.removeEventListener("Test:Pong", listener);
});
window.addEventListener("Test:Pong", listener);
}),
onAttach: worker1 => {
let mod2 = PageMod({
include: TEST_URL,
attachTo: ["top", "existing"],
contentScriptWhen: 'end',
contentScript: Isolate(function() {
let listener = function(event) {
let newEvent = document.createEvent("CustomEvent");
newEvent.initCustomEvent("Test:Pong", true, true, event.detail);
document.dispatchEvent(newEvent);
};
self.port.on("detach", () => {
window.removeEventListener("Test:Ping", listener);
})
window.addEventListener("Test:Ping", listener);
self.postMessage();
}),
onAttach: worker2 => {
worker1.port.emit("ping", "test1");
worker1.port.once("pong", detail => {
assert.equal(detail, "test1", "Saw the right message");
worker1.port.once("pingsent", () => {
assert.pass("The message was sent");
mod2.destroy();
worker1.port.emit("ping", "test2");
worker1.port.once("pong", detail => {
assert.fail("worker2 shouldn't have responded");
})
worker1.port.once("pingsent", () => {
assert.pass("The message was sent");
mod1.destroy();
closeTab(tab);
done();
});
});
})
}
});
}
});
let tab = openTab(getMostRecentBrowserWindow(), TEST_URL);
}
// Tests that after destroy child page-mod won't attach
exports.testDestroyWontAttach = function(assert, done) {
const TEST_URL = 'data:text/html;charset=utf-8,detach';
let badMod = PageMod({
include: TEST_URL,
contentScriptWhen: 'start',
contentScript: Isolate(function() {
unsafeWindow.testProperty = "attached";
})
});
badMod.destroy();
let mod = PageMod({
include: TEST_URL,
contentScriptWhen: 'end',
contentScript: Isolate(function() {
self.postMessage(unsafeWindow.testProperty);
}),
onMessage: property => {
assert.equal(property, undefined, "Shouldn't have seen the test property set.");
mod.destroy();
closeTab(tab);
done();
}
});
let tab = openTab(getMostRecentBrowserWindow(), TEST_URL);
}
// Tests that after unload existing workers have been destroyed
exports.testUnloadKillsChild = function(assert, done) {
const TEST_URL = 'data:text/html;charset=utf-8,detach';
let mod1 = PageMod({
include: TEST_URL,
contentScriptWhen: 'end',
contentScript: Isolate(function() {
self.port.on("ping", detail => {
let event = document.createEvent("CustomEvent");
event.initCustomEvent("Test:Ping", true, true, detail);
document.dispatchEvent(event);
self.port.emit("pingsent");
});
let listener = function(event) {
self.port.emit("pong", event.detail);
};
self.port.on("detach", () => {
window.removeEventListener("Test:Pong", listener);
});
window.addEventListener("Test:Pong", listener);
}),
onAttach: worker1 => {
let loader = Loader(module);
let mod2 = loader.require('sdk/page-mod').PageMod({
include: TEST_URL,
attachTo: ["top", "existing"],
contentScriptWhen: 'end',
contentScript: Isolate(function() {
let listener = function(event) {
let newEvent = document.createEvent("CustomEvent");
newEvent.initCustomEvent("Test:Pong", true, true, event.detail);
document.dispatchEvent(newEvent);
};
self.port.on("detach", () => {
window.removeEventListener("Test:Ping", listener);
})
window.addEventListener("Test:Ping", listener);
self.postMessage();
}),
onAttach: worker2 => {
worker1.port.emit("ping", "test1");
worker1.port.once("pong", detail => {
assert.equal(detail, "test1", "Saw the right message");
worker1.port.once("pingsent", () => {
assert.pass("The message was sent");
loader.unload();
worker1.port.emit("ping", "test2");
worker1.port.once("pong", detail => {
assert.fail("worker2 shouldn't have responded");
})
worker1.port.once("pingsent", () => {
assert.pass("The message was sent");
mod1.destroy();
closeTab(tab);
done();
});
});
})
}
});
}
});
let tab = openTab(getMostRecentBrowserWindow(), TEST_URL);
}
// Tests that after unload child page-mod won't attach
exports.testUnloadWontAttach = function(assert, done) {
const TEST_URL = 'data:text/html;charset=utf-8,detach';
let loader = Loader(module);
let badMod = loader.require('sdk/page-mod').PageMod({
include: TEST_URL,
contentScriptWhen: 'start',
contentScript: Isolate(function() {
unsafeWindow.testProperty = "attached";
})
});
loader.unload();
let mod = PageMod({
include: TEST_URL,
contentScriptWhen: 'end',
contentScript: Isolate(function() {
self.postMessage(unsafeWindow.testProperty);
}),
onMessage: property => {
assert.equal(property, undefined, "Shouldn't have seen the test property set.");
mod.destroy();
closeTab(tab);
done();
}
});
let tab = openTab(getMostRecentBrowserWindow(), TEST_URL);
}
// Tests that the SDK console isn't injected into documents loaded in tabs
exports.testDontInjectConsole = function(assert, done) {
const TEST_URL = 'data:text/html;charset=utf-8,consoleinject';
let loader = Loader(module);
let mod = PageMod({
include: TEST_URL,
contentScript: Isolate(function() {
// This relies on the fact that the SDK console doesn't have assert defined
self.postMessage((typeof unsafeWindow.console.assert) == "function");
}),
onMessage: isNativeConsole => {
assert.ok(isNativeConsole, "Shouldn't have injected the SDK console.");
mod.destroy();
closeTab(tab);
done();
}
});
let tab = openTab(getMostRecentBrowserWindow(), TEST_URL);
}
after(exports, function*(name, assert) {
assert.pass("cleaning ui.");
yield cleanUI();
});
require('sdk/test').run(exports);
