The Tor Browser: comparison addon-sdk/source/test/test-page-worker.js

comparison: addon-sdk/source/test/test-page-worker.js

addon-sdk/source/test/test-page-worker.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:8e9b8c1fd3df
+/* 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 { Loader } = require('sdk/test/loader');
+const { Page } = require("sdk/page-worker");
+const { URL } = require("sdk/url");
+const fixtures = require("./fixtures");
+const testURI = fixtures.url("test.html");
+const ERR_DESTROYED =
+"Couldn't find the worker to receive this message. " +
+"The script may not be initialized yet, or may already have been unloaded.";
+exports.testSimplePageCreation = function(assert, done) {
+let page = new Page({
+contentScript: "self.postMessage(window.location.href)",
+contentScriptWhen: "end",
+onMessage: function (message) {
+assert.equal(message, "about:blank",
+"Page Worker should start with a blank page by default");
+assert.equal(this, page, "The 'this' object is the page itself.");
+done();
+}
+});
+}
+/*
+* Tests that we can't be tricked by document overloads as we have access
+* to wrapped nodes
+*/
+exports.testWrappedDOM = function(assert, done) {
+let page = Page({
+allow: { script: true },
+contentURL: "data:text/html;charset=utf-8,<script>document.getElementById=3;window.scrollTo=3;</script>",
+contentScript: "window.addEventListener('load', function () " +
+"self.postMessage([typeof(document.getElementById), " +
+"typeof(window.scrollTo)]), true)",
+onMessage: function (message) {
+assert.equal(message[0],
+"function",
+"getElementById from content script is the native one");
+assert.equal(message[1],
+"function",
+"scrollTo from content script is the native one");
+done();
+}
+});
+}
+/*
+// We do not offer unwrapped access to DOM since bug 601295 landed
+// See 660780 to track progress of unwrap feature
+exports.testUnwrappedDOM = function(assert, done) {
+let page = Page({
+allow: { script: true },
+contentURL: "data:text/html;charset=utf-8,<script>document.getElementById=3;window.scrollTo=3;</script>",
+contentScript: "window.addEventListener('load', function () " +
+"self.postMessage([typeof(unsafeWindow.document.getElementById), " +
+"typeof(unsafeWindow.scrollTo)]), true)",
+onMessage: function (message) {
+assert.equal(message[0],
+"number",
+"document inside page is free to be changed");
+assert.equal(message[1],
+"number",
+"window inside page is free to be changed");
+done();
+}
+});
+}
+*/
+exports.testPageProperties = function(assert) {
+let page = new Page();
+for each (let prop in ['contentURL', 'allow', 'contentScriptFile',
+'contentScript', 'contentScriptWhen', 'on',
+'postMessage', 'removeListener']) {
+assert.ok(prop in page, prop + " property is defined on page.");
+}
+assert.ok(function () page.postMessage("foo") || true,
+"postMessage doesn't throw exception on page.");
+}
+exports.testConstructorAndDestructor = function(assert, done) {
+let loader = Loader(module);
+let { Page } = loader.require("sdk/page-worker");
+let global = loader.sandbox("sdk/page-worker");
+let pagesReady = 0;
+let page1 = Page({
+contentScript:      "self.postMessage('')",
+contentScriptWhen:  "end",
+onMessage:          pageReady
+});
+let page2 = Page({
+contentScript:      "self.postMessage('')",
+contentScriptWhen:  "end",
+onMessage:          pageReady
+});
+assert.notEqual(page1, page2,
+"Page 1 and page 2 should be different objects.");
+function pageReady() {
+if (++pagesReady == 2) {
+page1.destroy();
+page2.destroy();
+assert.ok(isDestroyed(page1), "page1 correctly unloaded.");
+assert.ok(isDestroyed(page2), "page2 correctly unloaded.");
+loader.unload();
+done();
+}
+}
+}
+exports.testAutoDestructor = function(assert, done) {
+let loader = Loader(module);
+let { Page } = loader.require("sdk/page-worker");
+let page = Page({
+contentScript: "self.postMessage('')",
+contentScriptWhen: "end",
+onMessage: function() {
+loader.unload();
+assert.ok(isDestroyed(page), "Page correctly unloaded.");
+done();
+}
+});
+}
+exports.testValidateOptions = function(assert) {
+assert.throws(
+function () Page({ contentURL: 'home' }),
+/The `contentURL` option must be a valid URL\./,
+"Validation correctly denied a non-URL contentURL"
+);
+assert.throws(
+function () Page({ onMessage: "This is not a function."}),
+/The option "onMessage" must be one of the following types: function/,
+"Validation correctly denied a non-function onMessage."
+);
+assert.pass("Options validation is working.");
+}
+exports.testContentAndAllowGettersAndSetters = function(assert, done) {
+let content = "data:text/html;charset=utf-8,<script>window.localStorage.allowScript=3;</script>";
+// Load up the page with testURI initially for the resource:// principal,
+// then load the actual data:* content, as data:* URIs no longer
+// have localStorage
+let page = Page({
+contentURL: testURI,
+contentScript: "if (window.location.href==='"+testURI+"')" +
+"  self.postMessage('reload');" +
+"else " +
+"  self.postMessage(window.localStorage.allowScript)",
+contentScriptWhen: "end",
+onMessage: step0
+});
+function step0(message) {
+if (message === 'reload')
+return page.contentURL = content;
+assert.equal(message, "3",
+"Correct value expected for allowScript - 3");
+assert.equal(page.contentURL, content,
+"Correct content expected");
+page.removeListener('message', step0);
+page.on('message', step1);
+page.allow = { script: false };
+page.contentURL = content =
+"data:text/html;charset=utf-8,<script>window.localStorage.allowScript='f'</script>";
+}
+function step1(message) {
+assert.equal(message, "3",
+"Correct value expected for allowScript - 3");
+assert.equal(page.contentURL, content, "Correct content expected");
+page.removeListener('message', step1);
+page.on('message', step2);
+page.allow = { script: true };
+page.contentURL = content =
+"data:text/html;charset=utf-8,<script>window.localStorage.allowScript='g'</script>";
+}
+function step2(message) {
+assert.equal(message, "g",
+"Correct value expected for allowScript - g");
+assert.equal(page.contentURL, content, "Correct content expected");
+page.removeListener('message', step2);
+page.on('message', step3);
+page.allow.script = false;
+page.contentURL = content =
+"data:text/html;charset=utf-8,<script>window.localStorage.allowScript=3</script>";
+}
+function step3(message) {
+assert.equal(message, "g",
+"Correct value expected for allowScript - g");
+assert.equal(page.contentURL, content, "Correct content expected");
+page.removeListener('message', step3);
+page.on('message', step4);
+page.allow.script = true;
+page.contentURL = content =
+"data:text/html;charset=utf-8,<script>window.localStorage.allowScript=4</script>";
+}
+function step4(message) {
+assert.equal(message, "4",
+"Correct value expected for allowScript - 4");
+assert.equal(page.contentURL, content, "Correct content expected");
+done();
+}
+}
+exports.testOnMessageCallback = function(assert, done) {
+Page({
+contentScript: "self.postMessage('')",
+contentScriptWhen: "end",
+onMessage: function() {
+assert.pass("onMessage callback called");
+done();
+}
+});
+}
+exports.testMultipleOnMessageCallbacks = function(assert, done) {
+let count = 0;
+let page = Page({
+contentScript: "self.postMessage('')",
+contentScriptWhen: "end",
+onMessage: () => count += 1
+});
+page.on('message', () => count += 2);
+page.on('message', () => count *= 3);
+page.on('message', () =>
+assert.equal(count, 9, "All callbacks were called, in order."));
+page.on('message', done);
+};
+exports.testLoadContentPage = function(assert, done) {
+let page = Page({
+onMessage: function(message) {
+// The message is an array whose first item is the test method to call
+// and the rest of whose items are arguments to pass it.
+let msg = message.shift();
+if (msg == "done")
+return done();
+assert[msg].apply(assert, message);
+},
+contentURL: fixtures.url("test-page-worker.html"),
+contentScriptFile: fixtures.url("test-page-worker.js"),
+contentScriptWhen: "ready"
+});
+}
+exports.testAllowScriptDefault = function(assert, done) {
+let page = Page({
+onMessage: function(message) {
+assert.ok(message, "Script is allowed to run by default.");
+done();
+},
+contentURL: "data:text/html;charset=utf-8,<script>document.documentElement.setAttribute('foo', 3);</script>",
+contentScript: "self.postMessage(document.documentElement.getAttribute('foo'))",
+contentScriptWhen: "ready"
+});
+}
+exports.testAllowScript = function(assert, done) {
+let page = Page({
+onMessage: function(message) {
+assert.ok(message, "Script runs when allowed to do so.");
+done();
+},
+allow: { script: true },
+contentURL: "data:text/html;charset=utf-8,<script>document.documentElement.setAttribute('foo', 3);</script>",
+contentScript: "self.postMessage(document.documentElement.hasAttribute('foo') && " +
+"                 document.documentElement.getAttribute('foo') == 3)",
+contentScriptWhen: "ready"
+});
+}
+exports.testPingPong = function(assert, done) {
+let page = Page({
+contentURL: 'data:text/html;charset=utf-8,ping-pong',
+contentScript: 'self.on("message", function(message) self.postMessage("pong"));'
++ 'self.postMessage("ready");',
+onMessage: function(message) {
+if ('ready' == message) {
+page.postMessage('ping');
+}
+else {
+assert.ok(message, 'pong', 'Callback from contentScript');
+done();
+}
+}
+});
+};
+exports.testRedirect = function (assert, done) {
+let page = Page({
+contentURL: 'data:text/html;charset=utf-8,first-page',
+contentScriptWhen: "end",
+contentScript: '' +
+'if (/first-page/.test(document.location.href)) ' +
+'  document.location.href = "data:text/html;charset=utf-8,redirect";' +
+'else ' +
+'  self.port.emit("redirect", document.location.href);'
+});
+page.port.on('redirect', function (url) {
+assert.equal(url, 'data:text/html;charset=utf-8,redirect', 'Reinjects contentScript on reload');
+done();
+});
+};
+exports.testRedirectIncludeArrays = function (assert, done) {
+let firstURL = 'data:text/html;charset=utf-8,first-page';
+let page = Page({
+contentURL: firstURL,
+contentScript: '(function () {' +
+'self.port.emit("load", document.location.href);' +
+'  self.port.on("redirect", function (url) {' +
+'   document.location.href = url;' +
+'  })' +
+'})();',
+include: ['about:blank', 'data:*']
+});
+page.port.on('load', function (url) {
+if (url === firstURL) {
+page.port.emit('redirect', 'about:blank');
+} else if (url === 'about:blank') {
+page.port.emit('redirect', 'about:mozilla');
+assert.ok('`include` property handles arrays');
+assert.equal(url, 'about:blank', 'Redirects work with accepted domains');
+done();
+} else if (url === 'about:mozilla') {
+assert.fail('Should not redirect to restricted domain');
+}
+});
+};
+exports.testRedirectFromWorker = function (assert, done) {
+let firstURL = 'data:text/html;charset=utf-8,first-page';
+let secondURL = 'data:text/html;charset=utf-8,second-page';
+let thirdURL = 'data:text/html;charset=utf-8,third-page';
+let page = Page({
+contentURL: firstURL,
+contentScript: '(function () {' +
+'self.port.emit("load", document.location.href);' +
+'  self.port.on("redirect", function (url) {' +
+'   document.location.href = url;' +
+'  })' +
+'})();',
+include: 'data:*'
+});
+page.port.on('load', function (url) {
+if (url === firstURL) {
+page.port.emit('redirect', secondURL);
+} else if (url === secondURL) {
+page.port.emit('redirect', thirdURL);
+} else if (url === thirdURL) {
+page.port.emit('redirect', 'about:mozilla');
+assert.equal(url, thirdURL, 'Redirects work with accepted domains on include strings');
+done();
+} else {
+assert.fail('Should not redirect to unauthorized domains');
+}
+});
+};
+exports.testRedirectWithContentURL = function (assert, done) {
+let firstURL = 'data:text/html;charset=utf-8,first-page';
+let secondURL = 'data:text/html;charset=utf-8,second-page';
+let thirdURL = 'data:text/html;charset=utf-8,third-page';
+let page = Page({
+contentURL: firstURL,
+contentScript: '(function () {' +
+'self.port.emit("load", document.location.href);' +
+'})();',
+include: 'data:*'
+});
+page.port.on('load', function (url) {
+if (url === firstURL) {
+page.contentURL = secondURL;
+} else if (url === secondURL) {
+page.contentURL = thirdURL;
+} else if (url === thirdURL) {
+page.contentURL = 'about:mozilla';
+assert.equal(url, thirdURL, 'Redirects work with accepted domains on include strings');
+done();
+} else {
+assert.fail('Should not redirect to unauthorized domains');
+}
+});
+};
+exports.testMultipleDestroys = function(assert) {
+let page = Page();
+page.destroy();
+page.destroy();
+assert.pass("Multiple destroys should not cause an error");
+};
+exports.testContentScriptOptionsOption = function(assert, done) {
+let page = new Page({
+contentScript: "self.postMessage( [typeof self.options.d, self.options] );",
+contentScriptWhen: "end",
+contentScriptOptions: {a: true, b: [1,2,3], c: "string", d: function(){ return 'test'}},
+onMessage: 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');
+done();
+}
+});
+};
+exports.testMessageQueue = function (assert, done) {
+let page = new Page({
+contentScript: 'self.on("message", function (m) {' +
+'self.postMessage(m);' +
+'});',
+contentURL: 'data:text/html;charset=utf-8,',
+});
+page.postMessage('ping');
+page.on('message', function (m) {
+assert.equal(m, 'ping', 'postMessage should queue messages');
+done();
+});
+};
+function isDestroyed(page) {
+try {
+page.postMessage("foo");
+}
+catch (err) {
+if (err.message == ERR_DESTROYED) {
+return true;
+}
+else {
+throw err;
+}
+}
+return false;
+}
+require("test").run(exports);