summaryrefslogtreecommitdiffstats
path: root/addon-sdk/source/test/test-page-mod.js
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /addon-sdk/source/test/test-page-mod.js
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'addon-sdk/source/test/test-page-mod.js')
-rw-r--r--addon-sdk/source/test/test-page-mod.js2214
1 files changed, 2214 insertions, 0 deletions
diff --git a/addon-sdk/source/test/test-page-mod.js b/addon-sdk/source/test/test-page-mod.js
new file mode 100644
index 000000000..d03463d2d
--- /dev/null
+++ b/addon-sdk/source/test/test-page-mod.js
@@ -0,0 +1,2214 @@
+/* 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);