exports["test Deprecate Usage"] = function testDeprecateUsage(assert) {
set(PREFERENCE, true);
let { loader, messages } = LoaderWithHookedConsole(module);
let deprecate = loader.require("sdk/util/deprecate");
function functionIsDeprecated() {
deprecate.deprecateUsage("foo");
}
functionIsDeprecated();
assert.equal(messages.length, 1, "only one error is dispatched");
assert.equal(messages[0].type, "error", "the console message is an error");
let msg = messages[0].msg;
assert.ok(msg.indexOf("foo") !== -1,
"message contains the given message");
assert.ok(msg.indexOf("functionIsDeprecated") !== -1,
"message contains name of the caller function");
assert.ok(msg.indexOf(module.uri) !== -1,
"message contains URI of the caller module");
loader.unload();
}
function(assert, browser, done) {
let { loader } = LoaderWithHookedConsole(module, onMessage);
// Intercept all console method calls
let calls = [];
function onMessage(type, msg) {
assert.equal(type, msg,
"console.xxx(\"xxx\"), i.e. message is equal to the " +
"console method name we are calling");
calls.push(msg);
}
// Finally, create a worker that will call all console methods
let worker = loader.require("sdk/content/worker").Worker({
window: browser.contentWindow,
contentScript: "new " + function WorkerScope() {
console.log("log");
console.info("info");
console.warn("warn");
console.error("error");
console.debug("debug");
console.exception("exception");
self.postMessage();
},
onMessage: function() {
// Ensure that console methods are called in the same execution order
assert.equal(JSON.stringify(calls),
JSON.stringify(["log", "info", "warn", "error", "debug", "exception"]),
"console has been called successfully, in the expected order");
done();
}
});
}
exports.testDeprecateEvent = function(assert, done) {
set(PREFERENCE, true);
let { loader, messages } = LoaderWithHookedConsole(module);
let deprecate = loader.require("sdk/util/deprecate");
let { on, emit } = loader.require('sdk/event/core');
let testObj = {};
testObj.on = deprecate.deprecateEvent(on.bind(null, testObj), 'BAD', ['fire']);
testObj.on('fire', function() {
testObj.on('water', function() {
assert.equal(messages.length, 1, "only one error is dispatched");
loader.unload();
done();
})
assert.equal(messages.length, 1, "only one error is dispatched");
emit(testObj, 'water');
});
assert.equal(messages.length, 1, "only one error is dispatched");
assert.equal(messages[0].type, "error", "the console message is an error");
let msg = messages[0].msg;
assert.ok(msg.indexOf("BAD") !== -1, "message contains the given message");
assert.ok(msg.indexOf("deprecateEvent") !== -1,
"message contains name of the caller function");
assert.ok(msg.indexOf(module.uri) !== -1,
"message contains URI of the caller module");
emit(testObj, 'fire');
}
exports["test Deprecate Function"] = function testDeprecateFunction(assert) {
set(PREFERENCE, true);
let { loader, messages } = LoaderWithHookedConsole(module);
let deprecate = loader.require("sdk/util/deprecate");
let self = {};
let arg1 = "foo";
let arg2 = {};
function originalFunction(a1, a2) {
assert.equal(this, self);
assert.equal(a1, arg1);
assert.equal(a2, arg2);
};
let deprecateFunction = deprecate.deprecateFunction(originalFunction,
"bar");
deprecateFunction.call(self, arg1, arg2);
assert.equal(messages.length, 1, "only one error is dispatched");
assert.equal(messages[0].type, "error", "the console message is an error");
let msg = messages[0].msg;
assert.ok(msg.indexOf("bar") !== -1, "message contains the given message");
assert.ok(msg.indexOf("testDeprecateFunction") !== -1,
"message contains name of the caller function");
assert.ok(msg.indexOf(module.uri) !== -1,
"message contains URI of the caller module");
loader.unload();
}
exports["test Anchor And Arrow"] = function*(assert, done) {
let { loader } = LoaderWithHookedConsole(module, ignorePassingDOMNodeWarning);
let { Panel } = loader.require('sdk/panel');
let count = 0;
let url = 'data:text/html;charset=utf-8,' +
'<html><head><title>foo</title></head><body>' +
'</body></html>';
let panel = yield new Promise(resolve => {
let browserWindow = getMostRecentBrowserWindow();
let anchor = browserWindow.document.getElementById("identity-box");
let panel = Panel({
contentURL: "data:text/html;charset=utf-8,<html><body style='padding: 0; margin: 0; " +
"background: gray; text-align: center;'>Anchor: " +
anchor.id + "</body></html>",
width: 200,
height: 100,
onShow: () => resolve(panel)
});
panel.show(null, anchor);
});
assert.pass("All anchored panel test displayed");
panel.destroy();
assert.pass("panel was destroyed.");
};
function(assert, browser, done) {
let logs = [];
let clean = message =>
message.trim().
replace(/[\r\n]/g, " ").
replace(/ +/g, " ");
let onMessage = (type, message) => logs.push(clean(message));
let { loader } = LoaderWithHookedConsole(module, onMessage);
let worker = loader.require("sdk/content/worker").Worker({
window: browser.contentWindow,
contentScript: "new " + function WorkerScope() {
console.log(Function);
console.log((foo) => foo * foo);
console.log(function foo(bar) { return bar + bar });
self.postMessage();
},
onMessage: () => {
assert.deepEqual(logs, [
"function Function() { [native code] }",
"(foo) => foo * foo",
"function foo(bar) { \"use strict\"; return bar + bar }"
]);
done();
}
});
}
exports.testWindowDefaults = function(assert) {
// Ensure that browserWindow still works while being deprecated
let { loader, messages } = LoaderWithHookedConsole(module);
let windows = loader.require("sdk/windows").browserWindows;
assert.equal(windows.activeWindow.isPrivateBrowsing, undefined,
'window.isPrivateBrowsing is undefined');
assert.equal(undefined, messages[0],
'isPrivateBrowsing is deprecated');
let chromeWin = winUtils.getMostRecentBrowserWindow();
assert.equal(getMode(chromeWin), false);
assert.equal(isWindowPrivate(chromeWin), false);
};
exports['test passing DOM node as first argument'] = function (assert, done) {
let warned = defer();
let shown = defer();
function onMessage(type, message) {
if (type != 'warn') return;
let warning = 'Passing a DOM node to Panel.show() method is an unsupported ' +
'feature that will be soon replaced. ' +
'See: https://bugzilla.mozilla.org/show_bug.cgi?id=878877';
assert.equal(type, 'warn',
'the message logged is a warning');
assert.equal(message, warning,
'the warning content is correct');
warned.resolve();
}
let { loader } = LoaderWithHookedConsole(module, onMessage);
let { Panel } = loader.require('sdk/panel');
let { ActionButton } = loader.require('sdk/ui/button/action');
let { getNodeView } = loader.require('sdk/view/core');
let { document } = getMostRecentBrowserWindow();
let panel = Panel({
onShow: function() {
let panelNode = document.getElementById('mainPopupSet').lastChild;
assert.equal(panelNode.anchorNode, buttonNode,
'the panel is properly anchored to the button');
shown.resolve();
}
});
let button = ActionButton({
id: 'panel-button',
label: 'panel button',
icon: './icon.png'
});
let buttonNode = getNodeView(button);
all([warned.promise, shown.promise]).
then(loader.unload).
then(done, assert.fail)
panel.show(buttonNode);
};
exports["test LoaderWithHookedConsole"] = function (assert) {
let count = 0;
function onMessage(type, message) {
switch (count++) {
case 0:
assert.equal(type, "log", "got log type");
assert.equal(message, "1st", "got log msg");
break;
case 1:
assert.equal(type, "error", "got error type");
assert.equal(message, "2nd", "got error msg");
break;
case 2:
assert.equal(type, "warn", "got warn type");
assert.equal(message, "3rd", "got warn msg");
break;
case 3:
assert.equal(type, "info", "got info type");
assert.equal(message, "4th", "got info msg");
break;
case 4:
assert.equal(type, "debug", "got debug type");
assert.equal(message, "5th", "got debug msg");
break;
case 5:
assert.equal(type, "exception", "got exception type");
assert.equal(message, "6th", "got exception msg");
break;
default:
assert.fail("Got unexception message: " + i);
}
}
let { loader, messages } = LoaderWithHookedConsole(module, onMessage);
let console = loader.globals.console;
console.log("1st");
console.error("2nd");
console.warn("3rd");
console.info("4th");
console.debug("5th");
console.exception("6th");
assert.equal(messages.length, 6, "Got all console messages");
assert.deepEqual(messages[0], {type: "log", msg: "1st", innerID: null}, "Got log");
assert.deepEqual(messages[1], {type: "error", msg: "2nd", innerID: null}, "Got error");
assert.deepEqual(messages[2], {type: "warn", msg: "3rd", innerID: null}, "Got warn");
assert.deepEqual(messages[3], {type: "info", msg: "4th", innerID: null}, "Got info");
assert.deepEqual(messages[4], {type: "debug", msg: "5th", innerID: null}, "Got debug");
assert.deepEqual(messages[5], {type: "exception", msg: "6th", innerID: null}, "Got exception");
assert.equal(count, 6, "Called for all messages");
};
exports.testWindowDefaults = function(assert) {
setPref(DEPRECATE_PREF, true);
// Ensure that browserWindow still works while being deprecated
let { loader, messages } = LoaderWithHookedConsole(module);
let windows = loader.require("sdk/windows").browserWindows;
assert.equal(windows.activeWindow.isPrivateBrowsing, false,
'window is not private browsing by default');
assert.ok(/DEPRECATED.+isPrivateBrowsing/.test(messages[0].msg),
'isPrivateBrowsing is deprecated');
let chromeWin = winUtils.getMostRecentBrowserWindow();
assert.equal(getMode(chromeWin), false);
assert.equal(isWindowPrivate(chromeWin), false);
};
exports.testAPIExtension = function(assert) {
let { loader, messages } = LoaderWithHookedConsole(module);
let { XMLHttpRequest } = loader.require("sdk/net/xhr");
let xhr = new XMLHttpRequest();
assert.equal(typeof(xhr.forceAllowThirdPartyCookie), "function",
"forceAllowThirdPartyCookie is defined");
assert.equal(xhr.forceAllowThirdPartyCookie(), undefined,
"function can be called");
assert.ok(messages[0].msg.indexOf("`xhr.forceAllowThirdPartyCookie()` is deprecated") >= 0,
"deprecation warning was dumped");
assert.ok(xhr.mozBackgroundRequest, "is background request");
loader.unload();
};
function(assert, browser, done) {
let { loader } = LoaderWithHookedConsole(module);
let worker = loader.require("sdk/content/worker").Worker({
window: browser.contentWindow,
contentScript: 'new ' + function WorkerScope() {
self.port.on('detach', function(reason) {
window.location.hash += '!' + reason;
})
},
});
browser.contentWindow.addEventListener('hashchange', _ => {
assert.equal(browser.contentWindow.location.hash, '#detach!shutdown',
"location.href is as expected");
done();
})
loader.unload('shutdown');
}
function(assert, browser, done) {
let contentScript = "window.addEventListener('message', function (e) {" +
" if (e.data === 'from -> window')" +
" self.port.emit('response', e.data, e.origin);" +
"});" +
"postMessage('from -> content-script', '*');";
let { loader } = LoaderWithHookedConsole(module);
let worker = loader.require("sdk/content/worker").Worker({
window: browser.contentWindow,
contentScriptWhen: "ready",
contentScript: contentScript
});
worker.port.on("response", (data, origin) => {
assert.equal(data, "from -> window", "Communication from content-script to window completed");
done();
});
});
exports.testDeprecateSettingToggle = function (assert, done) {
let { loader, messages } = LoaderWithHookedConsole(module);
let deprecate = loader.require("sdk/util/deprecate");
function fn () { deprecate.deprecateUsage("foo"); }
set(PREFERENCE, false);
fn();
assert.equal(messages.length, 0, 'no deprecation warnings');
set(PREFERENCE, true);
fn();
assert.equal(messages.length, 1, 'deprecation warnings when toggled');
set(PREFERENCE, false);
fn();
assert.equal(messages.length, 1, 'no new deprecation warnings');
done();
};
function(assert, browser, done) {
let { loader } = LoaderWithHookedConsole(module, onMessage);
setPref(DEPRECATE_PREF, true);
// Intercept all console method calls
let seenMessages = 0;
function onMessage(type, message) {
seenMessages++;
assert.equal(type, "error", "Should be an error");
assert.equal(message, "DEPRECATED: The global `postMessage()` function in " +
"content scripts is deprecated in favor of the " +
"`self.postMessage()` function, which works the same. " +
"Replace calls to `postMessage()` with calls to " +
"`self.postMessage()`." +
"For more info on `self.on`, see " +
"<https://addons.mozilla.org/en-US/developers/docs/sdk/latest/dev-guide/addon-development/web-content.html>.",
"Should have seen the deprecation message")
}
assert.notEqual(browser.contentWindow.location.href, "about:blank",
"window is now on the right document");
let window = browser.contentWindow
let worker = loader.require("sdk/content/worker").Worker({
window: window,
contentScript: "new " + function WorkerScope() {
postMessage("success");
},
contentScriptWhen: "ready",
onMessage: function(msg) {
assert.equal("success", msg, "Should have seen the right postMessage call");
assert.equal(1, seenMessages, "Should have seen the deprecation message");
done();
}
});
assert.equal(worker.url, window.location.href,
"worker.url works");
worker.postMessage("hi!");
}
exports.testDeprecateSetting = function (assert, done) {
// Set devtools.errorconsole.deprecation_warnings to false
set(PREFERENCE, false);
let { loader, messages } = LoaderWithHookedConsole(module);
let deprecate = loader.require("sdk/util/deprecate");
// deprecateUsage test
function functionIsDeprecated() {
deprecate.deprecateUsage("foo");
}
functionIsDeprecated();
assert.equal(messages.length, 0,
"no errors dispatched on deprecateUsage");
// deprecateFunction test
function originalFunction() {};
let deprecateFunction = deprecate.deprecateFunction(originalFunction,
"bar");
deprecateFunction();
assert.equal(messages.length, 0,
"no errors dispatched on deprecateFunction");
// deprecateEvent
let { on, emit } = loader.require('sdk/event/core');
let testObj = {};
testObj.on = deprecate.deprecateEvent(on.bind(null, testObj), 'BAD', ['fire']);
testObj.on('fire', () => {
assert.equal(messages.length, 0,
"no errors dispatched on deprecateEvent");
done();
});
emit(testObj, 'fire');
}
exports["test console.log in Panel"] = function(assert, done) {
let text = 'console.log() in Panel works!';
let html = '<script>onload = function log(){\
console.log("' + text + '");\
}</script>';
let { loader } = LoaderWithHookedConsole(module, onMessage);
let { Panel } = loader.require('sdk/panel');
let panel = Panel({
contentURL: 'data:text/html;charset=utf-8,' + encodeURIComponent(html)
});
panel.show();
function onMessage(type, message) {
assert.equal(type, 'log', 'console.log() works');
assert.equal(message, text, 'console.log() works');
panel.destroy();
done();
}
};
exports.testUnloading = function(assert) {
let { loader, messages } = LoaderWithHookedConsole(module);
var ul = loader.require("sdk/system/unload");
var unloadCalled = 0;
function unload() {
unloadCalled++;
throw new Error("error");
}
ul.when(unload);
// This should be ignored, as we already registered it
ul.when(unload);
function unload2() { unloadCalled++; }
ul.when(unload2);
loader.unload();
assert.equal(unloadCalled, 2,
"Unloader functions are called on unload.");
assert.equal(messages.length, 1,
"One unload handler threw exception 1/2");
assert.equal(messages[0].type, "exception",
"One unload handler threw exception 2/2");
};
/* 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 { LoaderWithHookedConsole } = require('sdk/test/loader');
const { loader } = LoaderWithHookedConsole(module);
const app = require("sdk/system/xul-app");
// This test makes sure that require statements used by all AMO hosted
// add-ons will be able to use old require statements.
// Tests are based on following usage data:
// https://docs.google.com/spreadsheet/ccc?key=0ApEBy-GRnGxzdHlRMHJ5RXN1aWJ4RGhINkxSd0FCQXc#gid=0
exports["test compatibility"] = function(assert) {
let { require } = loader;
assert.equal(require("self"),
require("sdk/self"), "sdk/self -> self");
assert.equal(require("tabs"),
require("sdk/tabs"), "sdk/tabs -> tabs");
if (app.is("Firefox")) {
assert.equal(require("widget"),
require("sdk/widget"), "sdk/widget -> widget");
}
assert.equal(require("page-mod"),
require("sdk/page-mod"), "sdk/page-mod -> page-mod");