Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
/* 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
function run_test() {
//* *************************************************************************//
// Constants
const handlerSvc = Cc["@mozilla.org/uriloader/handler-service;1"].getService(
Ci.nsIHandlerService
);
const mimeSvc = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
const protoSvc = Cc[
"@mozilla.org/uriloader/external-protocol-service;1"
].getService(Ci.nsIExternalProtocolService);
const prefSvc = Services.prefs;
let noMailto = false;
if (mozinfo.os == "win") {
// Check mailto handler from registry.
// If registry entry is nothing, no mailto handler
let regSvc = Cc["@mozilla.org/windows-registry-key;1"].createInstance(
Ci.nsIWindowsRegKey
);
try {
regSvc.open(regSvc.ROOT_KEY_CLASSES_ROOT, "mailto", regSvc.ACCESS_READ);
noMailto = false;
} catch (ex) {
noMailto = true;
}
regSvc.close();
}
if (mozinfo.os == "linux") {
// Check mailto handler from GIO
// If there isn't one, then we have no mailto handler
let gIOSvc = Cc["@mozilla.org/gio-service;1"].createInstance(
Ci.nsIGIOService
);
try {
gIOSvc.getAppForURIScheme("mailto");
noMailto = false;
} catch (ex) {
noMailto = true;
}
}
//* *************************************************************************//
// Sample Data
// It doesn't matter whether or not this nsIFile is actually executable,
// only that it has a path and exists. Since we don't know any executable
// that exists on all platforms (except possibly the application being
// tested, but there doesn't seem to be a way to get a reference to that
// from the directory service), we use the temporary directory itself.
var executable = Services.dirsvc.get("TmpD", Ci.nsIFile);
// XXX We could, of course, create an actual executable in the directory:
// executable.append("localhandler");
// if (!executable.exists())
// executable.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o755);
var localHandler = Cc[
"@mozilla.org/uriloader/local-handler-app;1"
].createInstance(Ci.nsILocalHandlerApp);
localHandler.name = "Local Handler";
localHandler.executable = executable;
var webHandler = Cc[
"@mozilla.org/uriloader/web-handler-app;1"
].createInstance(Ci.nsIWebHandlerApp);
webHandler.name = "Web Handler";
// FIXME: these tests create and manipulate enough variables that it would
// make sense to move each test into its own scope so we don't run the risk
// of one test stomping on another's data.
//* *************************************************************************//
// Test Default Properties
// Get a handler info for a MIME type that neither the application nor
// the OS knows about and make sure its properties are set to the proper
// default values.
var handlerInfo = mimeSvc.getFromTypeAndExtension("nonexistent/type", null);
// Make sure it's also an nsIHandlerInfo.
Assert.ok(handlerInfo instanceof Ci.nsIHandlerInfo);
Assert.equal(handlerInfo.type, "nonexistent/type");
// Deprecated property, but we should still make sure it's set correctly.
Assert.equal(handlerInfo.MIMEType, "nonexistent/type");
// These properties are the ones the handler service knows how to store.
Assert.equal(handlerInfo.preferredAction, Ci.nsIHandlerInfo.saveToDisk);
Assert.equal(handlerInfo.preferredApplicationHandler, null);
Assert.equal(handlerInfo.possibleApplicationHandlers.length, 0);
Assert.equal(
handlerInfo.alwaysAskBeforeHandling,
prefSvc.getBoolPref(
"browser.download.always_ask_before_handling_new_types",
false
)
);
// These properties are initialized to default values by the service,
// so we might as well make sure they're initialized to the right defaults.
Assert.equal(handlerInfo.description, "");
Assert.equal(handlerInfo.hasDefaultHandler, false);
Assert.equal(handlerInfo.defaultDescription, "");
const kExternalWarningDefault =
"network.protocol-handler.warn-external-default";
prefSvc.setBoolPref(kExternalWarningDefault, true);
// XXX add more thorough protocol info property checking
// no OS default handler exists
var protoInfo = protoSvc.getProtocolHandlerInfo("x-moz-rheet");
Assert.equal(protoInfo.preferredAction, protoInfo.alwaysAsk);
Assert.ok(protoInfo.alwaysAskBeforeHandling);
// OS default exists, injected default does not exist,
// explicit warning pref: false
const kExternalWarningPrefPrefix = "network.protocol-handler.warn-external.";
prefSvc.setBoolPref(kExternalWarningPrefPrefix + "http", false);
protoInfo = protoSvc.getProtocolHandlerInfo("http");
Assert.equal(0, protoInfo.possibleApplicationHandlers.length);
// NOTE: this assertion will fail if the system executing the test does not
// have a handler registered for the http protocol. This is very unlikely to
// actually happen except on certain configurations of Linux, but one of
// those configurations is the default WSL Ubuntu install. So, if you are
// running this test locally and seeing a failure here, it might not be
// anything to really worry about.
Assert.ok(!protoInfo.alwaysAskBeforeHandling);
// OS default exists, injected default does not exist,
// explicit warning pref: true
prefSvc.setBoolPref(kExternalWarningPrefPrefix + "http", true);
protoInfo = protoSvc.getProtocolHandlerInfo("http");
// OS handler isn't included in possibleApplicationHandlers, so length is 0
// Once they become instances of nsILocalHandlerApp, this number will need
// to change.
Assert.equal(0, protoInfo.possibleApplicationHandlers.length);
Assert.ok(protoInfo.alwaysAskBeforeHandling);
// OS default exists, injected default exists, explicit warning pref: false
prefSvc.setBoolPref(kExternalWarningPrefPrefix + "mailto", false);
protoInfo = protoSvc.getProtocolHandlerInfo("mailto");
if (AppConstants.MOZ_APP_NAME == "thunderbird") {
Assert.equal(0, protoInfo.possibleApplicationHandlers.length);
} else {
Assert.equal(1, protoInfo.possibleApplicationHandlers.length);
}
// Win7+ or Linux's GIO might not have a default mailto: handler
if (noMailto) {
Assert.ok(protoInfo.alwaysAskBeforeHandling);
} else {
Assert.ok(!protoInfo.alwaysAskBeforeHandling);
}
// OS default exists, injected default exists, explicit warning pref: true
prefSvc.setBoolPref(kExternalWarningPrefPrefix + "mailto", true);
protoInfo = protoSvc.getProtocolHandlerInfo("mailto");
if (AppConstants.MOZ_APP_NAME == "thunderbird") {
Assert.equal(0, protoInfo.possibleApplicationHandlers.length);
} else {
Assert.equal(1, protoInfo.possibleApplicationHandlers.length);
// Win7+ or Linux's GIO may have no default mailto: handler, so we'd ask
// anyway. Otherwise, the default handlers will not have stored preferred
// actions etc., so re-requesting them after the warning pref has changed
// will use the updated pref value. So both when we have and do not have
// a default mailto: handler, we'll ask:
Assert.ok(protoInfo.alwaysAskBeforeHandling);
// As soon as anyone actually stores updated defaults into the profile
// database, that default will stop tracking the warning pref.
}
// Now set the value stored in RDF to true, and the pref to false, to make
// sure we still get the right value. (Basically, same thing as above but
// with the values reversed.)
prefSvc.setBoolPref(kExternalWarningPrefPrefix + "mailto", false);
protoInfo.alwaysAskBeforeHandling = true;
handlerSvc.store(protoInfo);
protoInfo = protoSvc.getProtocolHandlerInfo("mailto");
if (AppConstants.MOZ_APP_NAME == "thunderbird") {
Assert.equal(0, protoInfo.possibleApplicationHandlers.length);
} else {
Assert.equal(1, protoInfo.possibleApplicationHandlers.length);
Assert.ok(protoInfo.alwaysAskBeforeHandling);
}
//* *************************************************************************//
// Test Round-Trip Data Integrity
// Test round-trip data integrity by setting the properties of the handler
// info object to different values, telling the handler service to store the
// object, and then retrieving a new info object for the same type and making
// sure its properties are identical.
handlerInfo.preferredAction = Ci.nsIHandlerInfo.useHelperApp;
handlerInfo.preferredApplicationHandler = localHandler;
handlerInfo.alwaysAskBeforeHandling = false;
handlerSvc.store(handlerInfo);
handlerInfo = mimeSvc.getFromTypeAndExtension("nonexistent/type", null);
Assert.equal(handlerInfo.preferredAction, Ci.nsIHandlerInfo.useHelperApp);
Assert.notEqual(handlerInfo.preferredApplicationHandler, null);
var preferredHandler = handlerInfo.preferredApplicationHandler;
Assert.equal(typeof preferredHandler, "object");
Assert.equal(preferredHandler.name, "Local Handler");
Assert.ok(preferredHandler instanceof Ci.nsILocalHandlerApp);
preferredHandler.QueryInterface(Ci.nsILocalHandlerApp);
Assert.equal(preferredHandler.executable.path, localHandler.executable.path);
Assert.ok(!handlerInfo.alwaysAskBeforeHandling);
// Make sure the handler service's enumerate method lists all known handlers.
var handlerInfo2 = mimeSvc.getFromTypeAndExtension("nonexistent/type2", null);
handlerSvc.store(handlerInfo2);
var handlerTypes = ["nonexistent/type", "nonexistent/type2"];
handlerTypes.push("mailto");
for (let handler of handlerSvc.enumerate()) {
Assert.notEqual(handlerTypes.indexOf(handler.type), -1);
handlerTypes.splice(handlerTypes.indexOf(handler.type), 1);
}
Assert.equal(handlerTypes.length, 0);
// Make sure the handler service's remove method removes a handler record.
handlerSvc.remove(handlerInfo2);
let handlers = handlerSvc.enumerate();
while (handlers.hasMoreElements()) {
Assert.notEqual(
handlers.getNext().QueryInterface(Ci.nsIHandlerInfo).type,
handlerInfo2.type
);
}
// Make sure we can store and retrieve a handler info object with no preferred
// handler.
var noPreferredHandlerInfo = mimeSvc.getFromTypeAndExtension(
"nonexistent/no-preferred-handler",
null
);
handlerSvc.store(noPreferredHandlerInfo);
noPreferredHandlerInfo = mimeSvc.getFromTypeAndExtension(
"nonexistent/no-preferred-handler",
null
);
Assert.equal(noPreferredHandlerInfo.preferredApplicationHandler, null);
// Make sure that the handler service removes an existing handler record
// if we store a handler info object with no preferred handler.
var removePreferredHandlerInfo = mimeSvc.getFromTypeAndExtension(
"nonexistent/rem-preferred-handler",
null
);
removePreferredHandlerInfo.preferredApplicationHandler = localHandler;
handlerSvc.store(removePreferredHandlerInfo);
removePreferredHandlerInfo = mimeSvc.getFromTypeAndExtension(
"nonexistent/rem-preferred-handler",
null
);
removePreferredHandlerInfo.preferredApplicationHandler = null;
handlerSvc.store(removePreferredHandlerInfo);
removePreferredHandlerInfo = mimeSvc.getFromTypeAndExtension(
"nonexistent/rem-preferred-handler",
null
);
Assert.equal(removePreferredHandlerInfo.preferredApplicationHandler, null);
// Make sure we can store and retrieve a handler info object with possible
// handlers. We test both adding and removing handlers.
// Get a handler info and make sure it has no possible handlers.
var possibleHandlersInfo = mimeSvc.getFromTypeAndExtension(
"nonexistent/possible-handlers",
null
);
Assert.equal(possibleHandlersInfo.possibleApplicationHandlers.length, 0);
// Store and re-retrieve the handler and make sure it still has no possible
// handlers.
handlerSvc.store(possibleHandlersInfo);
possibleHandlersInfo = mimeSvc.getFromTypeAndExtension(
"nonexistent/possible-handlers",
null
);
Assert.equal(possibleHandlersInfo.possibleApplicationHandlers.length, 0);
// Add two handlers, store the object, re-retrieve it, and make sure it has
// two handlers.
possibleHandlersInfo.possibleApplicationHandlers.appendElement(localHandler);
possibleHandlersInfo.possibleApplicationHandlers.appendElement(webHandler);
handlerSvc.store(possibleHandlersInfo);
possibleHandlersInfo = mimeSvc.getFromTypeAndExtension(
"nonexistent/possible-handlers",
null
);
Assert.equal(possibleHandlersInfo.possibleApplicationHandlers.length, 2);
// Figure out which is the local and which is the web handler and the index
// in the array of the local handler, which is the one we're going to remove
// to test removal of a handler.
var handler1 =
possibleHandlersInfo.possibleApplicationHandlers.queryElementAt(
0,
Ci.nsIHandlerApp
);
var handler2 =
possibleHandlersInfo.possibleApplicationHandlers.queryElementAt(
1,
Ci.nsIHandlerApp
);
var localPossibleHandler, webPossibleHandler, localIndex;
if (handler1 instanceof Ci.nsILocalHandlerApp) {
[localPossibleHandler, webPossibleHandler, localIndex] = [
handler1,
handler2,
0,
];
} else {
[localPossibleHandler, webPossibleHandler, localIndex] = [
handler2,
handler1,
1,
];
}
localPossibleHandler.QueryInterface(Ci.nsILocalHandlerApp);
webPossibleHandler.QueryInterface(Ci.nsIWebHandlerApp);
// Make sure the two handlers are the ones we stored.
Assert.equal(localPossibleHandler.name, localHandler.name);
Assert.ok(localPossibleHandler.equals(localHandler));
Assert.equal(webPossibleHandler.name, webHandler.name);
Assert.ok(webPossibleHandler.equals(webHandler));
// Remove a handler, store the object, re-retrieve it, and make sure
// it only has one handler.
possibleHandlersInfo.possibleApplicationHandlers.removeElementAt(localIndex);
handlerSvc.store(possibleHandlersInfo);
possibleHandlersInfo = mimeSvc.getFromTypeAndExtension(
"nonexistent/possible-handlers",
null
);
Assert.equal(possibleHandlersInfo.possibleApplicationHandlers.length, 1);
// Make sure the handler is the one we didn't remove.
webPossibleHandler =
possibleHandlersInfo.possibleApplicationHandlers.queryElementAt(
0,
Ci.nsIWebHandlerApp
);
Assert.equal(webPossibleHandler.name, webHandler.name);
Assert.ok(webPossibleHandler.equals(webHandler));
// ////////////////////////////////////////////////////
// handler info command line parameters and equality
var localApp = Cc[
"@mozilla.org/uriloader/local-handler-app;1"
].createInstance(Ci.nsILocalHandlerApp);
var handlerApp = localApp.QueryInterface(Ci.nsIHandlerApp);
Assert.ok(handlerApp.equals(localApp));
localApp.executable = executable;
Assert.equal(0, localApp.parameterCount);
localApp.appendParameter("-test1");
Assert.equal(1, localApp.parameterCount);
localApp.appendParameter("-test2");
Assert.equal(2, localApp.parameterCount);
Assert.ok(localApp.parameterExists("-test1"));
Assert.ok(localApp.parameterExists("-test2"));
Assert.ok(!localApp.parameterExists("-false"));
localApp.clearParameters();
Assert.equal(0, localApp.parameterCount);
var localApp2 = Cc[
"@mozilla.org/uriloader/local-handler-app;1"
].createInstance(Ci.nsILocalHandlerApp);
localApp2.executable = executable;
localApp.clearParameters();
Assert.ok(localApp.equals(localApp2));
// equal:
// cut -d 1 -f 2
// cut -d 1 -f 2
localApp.appendParameter("-test1");
localApp.appendParameter("-test2");
localApp.appendParameter("-test3");
localApp2.appendParameter("-test1");
localApp2.appendParameter("-test2");
localApp2.appendParameter("-test3");
Assert.ok(localApp.equals(localApp2));
// not equal:
// cut -d 1 -f 2
// cut -f 1 -d 2
localApp.clearParameters();
localApp2.clearParameters();
localApp.appendParameter("-test1");
localApp.appendParameter("-test2");
localApp.appendParameter("-test3");
localApp2.appendParameter("-test2");
localApp2.appendParameter("-test1");
localApp2.appendParameter("-test3");
Assert.ok(!localApp2.equals(localApp));
var str;
str = localApp.getParameter(0);
Assert.equal(str, "-test1");
str = localApp.getParameter(1);
Assert.equal(str, "-test2");
str = localApp.getParameter(2);
Assert.equal(str, "-test3");
// FIXME: test round trip integrity for a protocol.
// FIXME: test round trip integrity for a handler info with a web handler.
//* *************************************************************************//
// getTypeFromExtension tests
// test nonexistent extension
var lolType = handlerSvc.getTypeFromExtension("lolcat");
Assert.equal(lolType, "");
// add a handler for the extension
var lolHandler = mimeSvc.getFromTypeAndExtension("application/lolcat", null);
Assert.ok(!lolHandler.extensionExists("lolcat"));
lolHandler.preferredAction = Ci.nsIHandlerInfo.useHelperApp;
lolHandler.preferredApplicationHandler = localHandler;
lolHandler.alwaysAskBeforeHandling = false;
lolHandler.appendExtension("lolcat");
// store the handler
Assert.ok(!handlerSvc.exists(lolHandler));
handlerSvc.store(lolHandler);
Assert.ok(handlerSvc.exists(lolHandler));
// test now-existent extension
lolType = handlerSvc.getTypeFromExtension("lolcat");
Assert.equal(lolType, "application/lolcat");
// test mailcap entries with needsterminal are ignored on non-Windows non-Mac.
if (mozinfo.os != "win" && mozinfo.os != "mac") {
prefSvc.setStringPref(
"helpers.private_mailcap_file",
do_get_file("mailcap").path
);
handlerInfo = mimeSvc.getFromTypeAndExtension("text/plain", null);
Assert.equal(handlerInfo.preferredAction, Ci.nsIHandlerInfo.saveToDisk);
Assert.equal(handlerInfo.defaultDescription, "sed");
}
}