diff options
Diffstat (limited to 'dom/plugins/test/unit')
| -rw-r--r-- | dom/plugins/test/unit/head_plugins.js | 195 | ||||
| -rw-r--r-- | dom/plugins/test/unit/test_allowed_types.js | 142 | ||||
| -rw-r--r-- | dom/plugins/test/unit/test_bug471245.js | 23 | ||||
| -rw-r--r-- | dom/plugins/test/unit/test_bug813245.js | 87 | ||||
| -rw-r--r-- | dom/plugins/test/unit/test_bug854467.js | 40 | ||||
| -rw-r--r-- | dom/plugins/test/unit/test_nice_plugin_name.js | 80 | ||||
| -rw-r--r-- | dom/plugins/test/unit/test_persist_in_prefs.js | 76 | ||||
| -rw-r--r-- | dom/plugins/test/unit/test_plugin_default_state.js | 31 | ||||
| -rw-r--r-- | dom/plugins/test/unit/test_plugin_default_state_xpi.js | 118 | ||||
| -rw-r--r-- | dom/plugins/test/unit/xpcshell.ini | 29 |
10 files changed, 821 insertions, 0 deletions
diff --git a/dom/plugins/test/unit/head_plugins.js b/dom/plugins/test/unit/head_plugins.js new file mode 100644 index 000000000..4d32a52bf --- /dev/null +++ b/dom/plugins/test/unit/head_plugins.js @@ -0,0 +1,195 @@ +/* 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/. + */ + +var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import("resource://gre/modules/Promise.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); + +const gIsWindows = mozinfo.os == "win"; +const gIsOSX = mozinfo.os == "mac"; +const gIsLinux = mozinfo.os == "linux"; +const gDirSvc = Cc["@mozilla.org/file/directory_service;1"].getService(Ci.nsIProperties); + +function allow_all_plugins() { + Services.prefs.setBoolPref("plugin.load_flash_only", false); +} + +// Finds the test plugin library +function get_test_plugin(secondplugin=false) { + var pluginEnum = gDirSvc.get("APluginsDL", Ci.nsISimpleEnumerator); + while (pluginEnum.hasMoreElements()) { + let dir = pluginEnum.getNext().QueryInterface(Ci.nsILocalFile); + let name = get_platform_specific_plugin_name(secondplugin); + let plugin = dir.clone(); + plugin.append(name); + if (plugin.exists()) { + plugin.normalize(); + return plugin; + } + } + return null; +} + +// Finds the test nsIPluginTag +function get_test_plugintag(aName="Test Plug-in") { + const Cc = Components.classes; + const Ci = Components.interfaces; + + var name = aName || "Test Plug-in"; + var host = Cc["@mozilla.org/plugin/host;1"]. + getService(Ci.nsIPluginHost); + var tags = host.getPluginTags(); + + for (var i = 0; i < tags.length; i++) { + if (tags[i].name == name) + return tags[i]; + } + return null; +} + +// Creates a fake ProfDS directory key, copied from do_get_profile +function do_get_profile_startup() { + let env = Components.classes["@mozilla.org/process/environment;1"] + .getService(Components.interfaces.nsIEnvironment); + // the python harness sets this in the environment for us + let profd = env.get("XPCSHELL_TEST_PROFILE_DIR"); + let file = Components.classes["@mozilla.org/file/local;1"] + .createInstance(Components.interfaces.nsILocalFile); + file.initWithPath(profd); + + let dirSvc = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties); + let provider = { + getFile: function(prop, persistent) { + persistent.value = true; + if (prop == "ProfDS") { + return file.clone(); + } + throw Components.results.NS_ERROR_FAILURE; + }, + QueryInterface: function(iid) { + if (iid.equals(Components.interfaces.nsIDirectoryServiceProvider) || + iid.equals(Components.interfaces.nsISupports)) { + return this; + } + throw Components.results.NS_ERROR_NO_INTERFACE; + } + }; + dirSvc.QueryInterface(Components.interfaces.nsIDirectoryService) + .registerProvider(provider); + return file.clone(); +} + +function get_platform_specific_plugin_name(secondplugin=false) { + if (secondplugin) { + if (gIsWindows) return "npsecondtest.dll"; + if (gIsOSX) return "SecondTest.plugin"; + if (gIsLinux) return "libnpsecondtest.so"; + } else { + if (gIsWindows) return "nptest.dll"; + if (gIsOSX) return "Test.plugin"; + if (gIsLinux) return "libnptest.so"; + } + return null; +} + +function get_platform_specific_plugin_suffix() { + if (gIsWindows) return ".dll"; + else if (gIsOSX) return ".plugin"; + else if (gIsLinux) return ".so"; + else return null; +} + +function get_test_plugin_no_symlink() { + let dirSvc = Cc["@mozilla.org/file/directory_service;1"] + .getService(Ci.nsIProperties); + let pluginEnum = dirSvc.get("APluginsDL", Ci.nsISimpleEnumerator); + while (pluginEnum.hasMoreElements()) { + let dir = pluginEnum.getNext().QueryInterface(Ci.nsILocalFile); + let plugin = dir.clone(); + plugin.append(get_platform_specific_plugin_name()); + if (plugin.exists()) { + return plugin; + } + } + return null; +} + +var gGlobalScope = this; +function loadAddonManager() { + let ns = {}; + Cu.import("resource://gre/modules/Services.jsm", ns); + let head = "../../../../toolkit/mozapps/extensions/test/xpcshell/head_addons.js"; + let file = do_get_file(head); + let uri = ns.Services.io.newFileURI(file); + ns.Services.scriptloader.loadSubScript(uri.spec, gGlobalScope); + createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2"); + startupManager(); +} + +// Install addon and return a Promise<boolean> that is +// resolve with true on success, false otherwise. +function installAddon(relativePath) { + let deferred = Promise.defer(); + let success = () => deferred.resolve(true); + let fail = () => deferred.resolve(false); + let listener = { + onDownloadCancelled: fail, + onDownloadFailed: fail, + onInstallCancelled: fail, + onInstallFailed: fail, + onInstallEnded: success, + }; + + let installCallback = install => { + install.addListener(listener); + install.install(); + }; + + let file = do_get_file(relativePath, false); + AddonManager.getInstallForFile(file, installCallback, + "application/x-xpinstall"); + + return deferred.promise; +} + +// Uninstall addon and return a Promise<boolean> that is +// resolve with true on success, false otherwise. +function uninstallAddon(id) { + let deferred = Promise.defer(); + + AddonManager.getAddonByID(id, addon => { + if (!addon) { + deferred.resolve(false); + } + + let listener = {}; + let handler = addon => { + if (addon.id !== id) { + return; + } + + AddonManager.removeAddonListener(listener); + deferred.resolve(true); + }; + + listener.onUninstalled = handler; + listener.onDisabled = handler; + + AddonManager.addAddonListener(listener); + addon.uninstall(); + }); + + return deferred.promise; +} + +// Returns a Promise<Addon> that is resolved with +// the corresponding addon or rejected. +function getAddonByID(id) { + let deferred = Promise.defer(); + AddonManager.getAddonByID(id, addon => deferred.resolve(addon)); + return deferred.promise; +} diff --git a/dom/plugins/test/unit/test_allowed_types.js b/dom/plugins/test/unit/test_allowed_types.js new file mode 100644 index 000000000..09b30b31a --- /dev/null +++ b/dom/plugins/test/unit/test_allowed_types.js @@ -0,0 +1,142 @@ +/* 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/. + */ + +Components.utils.import("resource://gre/modules/Services.jsm"); + +function run_test() { + const pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost); + const pluginDefaultState = Services.prefs.getIntPref("plugin.default.state"); + + Services.prefs.setBoolPref("plugin.load_flash_only", false); + + function reload_plugins_with_allowed_types(allowed_types) { + if (typeof allowed_types === "undefined") { + // If we didn't get an allowed_types string, then unset the pref, + // so the caller can test the behavior when the pref isn't set. + Services.prefs.clearUserPref("plugin.allowed_types"); + } else { + Services.prefs.setCharPref("plugin.allowed_types", allowed_types); + } + pluginHost.reloadPlugins(); + } + + function get_status_for_type(type) { + try { + return pluginHost.getStateForType(type); + } catch(ex) { + // If the type is not allowed, then nsIPluginHost.getStateForType throws + // NS_ERROR_NOT_AVAILABLE, for which we return undefined to make it easier + // to write assertions about the API. + if (ex.result === Cr.NS_ERROR_NOT_AVAILABLE) { + return undefined; + } + throw ex; + } + } + + // If allowed_types isn't set, then all plugin types are enabled. + reload_plugins_with_allowed_types(); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + // If allowed_types is set to the empty string, then all plugin types are enabled. + reload_plugins_with_allowed_types(""); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + // If allowed_types is set to anything other than the empty string, + // then only types that exactly match its comma-separated entries are enabled, + // so a single space disables all types. + reload_plugins_with_allowed_types(" "); + do_check_eq(get_status_for_type("application/x-test"), undefined); + do_check_eq(get_status_for_type("application/x-Second-Test"), undefined); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + // The rest of the assertions test various values of allowed_types to ensure + // that the correct types are enabled. + + reload_plugins_with_allowed_types("application/x-test"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), undefined); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-Second-Test"); + do_check_eq(get_status_for_type("application/x-test"), undefined); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-nonexistent"); + do_check_eq(get_status_for_type("application/x-test"), undefined); + do_check_eq(get_status_for_type("application/x-Second-Test"), undefined); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-test,application/x-Second-Test"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-Second-Test,application/x-test"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-test,application/x-nonexistent"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), undefined); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-nonexistent,application/x-test"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), undefined); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-test,application/x-Second-Test,application/x-nonexistent"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-test,application/x-nonexistent,application/x-Second-Test"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-Second-Test,application/x-test,application/x-nonexistent"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-Second-Test,application/x-nonexistent,application/x-test"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-nonexistent,application/x-test,application/x-Second-Test"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + reload_plugins_with_allowed_types("application/x-nonexistent,application/x-Second-Test,application/x-test"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-Second-Test"), pluginDefaultState); + do_check_eq(get_status_for_type("application/x-nonexistent"), undefined); + + // Plugin types are case-insensitive, so matching should be too. + reload_plugins_with_allowed_types("APPLICATION/X-TEST"); + do_check_eq(get_status_for_type("application/x-test"), pluginDefaultState); + reload_plugins_with_allowed_types("application/x-test"); + do_check_eq(get_status_for_type("APPLICATION/X-TEST"), pluginDefaultState); + + // Types must match exactly, so supersets should not enable subset types. + reload_plugins_with_allowed_types("application/x-test-superset"); + do_check_eq(get_status_for_type("application/x-test"), undefined); + reload_plugins_with_allowed_types("superset-application/x-test"); + do_check_eq(get_status_for_type("application/x-test"), undefined); + + // Clean up. + Services.prefs.clearUserPref("plugin.allowed_types"); + Services.prefs.clearUserPref("plugin.importedState"); +} diff --git a/dom/plugins/test/unit/test_bug471245.js b/dom/plugins/test/unit/test_bug471245.js new file mode 100644 index 000000000..8e38afcdc --- /dev/null +++ b/dom/plugins/test/unit/test_bug471245.js @@ -0,0 +1,23 @@ +/* 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/. + */ + +Components.utils.import("resource://gre/modules/Services.jsm"); + +function run_test() { + allow_all_plugins(); + do_get_profile_startup(); + + var plugin = get_test_plugintag(); + do_check_true(plugin == null); + + // Initialises a profile folder + do_get_profile(); + + var plugin = get_test_plugintag(); + do_check_false(plugin == null); + + // Clean up + Services.prefs.clearUserPref("plugin.importedState"); +} diff --git a/dom/plugins/test/unit/test_bug813245.js b/dom/plugins/test/unit/test_bug813245.js new file mode 100644 index 000000000..069e4a014 --- /dev/null +++ b/dom/plugins/test/unit/test_bug813245.js @@ -0,0 +1,87 @@ +/* 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/. + */ + +Components.utils.import("resource://gre/modules/Services.jsm"); + +// Plugin registry uses different field delimeters on different platforms +var DELIM = mozinfo.os == "win" ? "|" : ":"; + +var gProfD = do_get_profile_startup(); + +// Writes out some plugin registry to the profile +function write_registry(version, info) { + let runtime = Cc["@mozilla.org/xre/runtime;1"].getService(Ci.nsIXULRuntime); + + var header = "Generated File. Do not edit.\n\n"; + header += "[HEADER]\n"; + header += "Version" + DELIM + version + DELIM + "$\n"; + header += "Arch" + DELIM + runtime.XPCOMABI + DELIM + "$\n"; + header += "\n"; + header += "[PLUGINS]\n"; + + var registry = gProfD.clone(); + registry.append("pluginreg.dat"); + var foStream = Components.classes["@mozilla.org/network/file-output-stream;1"] + .createInstance(Components.interfaces.nsIFileOutputStream); + // write, create, truncate + foStream.init(registry, 0x02 | 0x08 | 0x20, 0o666, 0); + + var charset = "UTF-8"; // Can be any character encoding name that Mozilla supports + var os = Cc["@mozilla.org/intl/converter-output-stream;1"]. + createInstance(Ci.nsIConverterOutputStream); + os.init(foStream, charset, 0, 0x0000); + + os.writeString(header); + os.writeString(info); + os.close(); +} + +function run_test() { + allow_all_plugins(); + var plugin = get_test_plugintag(); + do_check_true(plugin == null); + + var file = get_test_plugin(); + if (!file) { + do_throw("Plugin library not found"); + } + + // write plugin registry data + let registry = ""; + + if (gIsOSX) { + registry += file.leafName + DELIM + "$\n"; + registry += file.path + DELIM + "$\n"; + } else { + registry += file.path + DELIM + "$\n"; + registry += DELIM + "$\n"; + } + registry += "0.0.0.0" + DELIM + "$\n"; + registry += "16725225600" + DELIM + "0" + DELIM + "5" + DELIM + "$\n"; + registry += "Plug-in for testing purposes." + DELIM + "$\n"; + registry += "Test Plug-in" + DELIM + "$\n"; + registry += "999999999999999999999999999999999999999999999999|0|5|$\n"; + registry += "0" + DELIM + "application/x-test" + DELIM + "Test mimetype" + + DELIM + "tst" + DELIM + "$\n"; + + registry += "\n"; + registry += "[INVALID]\n"; + registry += "\n"; + write_registry("0.15", registry); + + // Initialise profile folder + do_get_profile(); + + var plugin = get_test_plugintag(); + if (!plugin) + do_throw("Plugin tag not found"); + + // The plugin registry should have been rejected. + // If not, the test plugin version would be 0.0.0.0 + do_check_eq(plugin.version, "1.0.0.0"); + + // Clean up + Services.prefs.clearUserPref("plugin.importedState"); +} diff --git a/dom/plugins/test/unit/test_bug854467.js b/dom/plugins/test/unit/test_bug854467.js new file mode 100644 index 000000000..0487dffc6 --- /dev/null +++ b/dom/plugins/test/unit/test_bug854467.js @@ -0,0 +1,40 @@ +/* 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/. + */ + +function check_state(aTag, aExpectedClicktoplay, aExpectedDisabled) { + do_check_eq(aTag.clicktoplay, aExpectedClicktoplay); + do_check_eq(aTag.disabled, aExpectedDisabled); +} + +function run_test() { + allow_all_plugins(); + let tag = get_test_plugintag(); + tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED; + check_state(tag, false, false); + + /* test going to click-to-play from always enabled and back */ + tag.enabledState = Ci.nsIPluginTag.STATE_CLICKTOPLAY; + check_state(tag, true, false); + tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED; + check_state(tag, false, false); + + /* test going to disabled from always enabled and back */ + tag.enabledState = Ci.nsIPluginTag.STATE_DISABLED; + check_state(tag, false, true); + tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED; + check_state(tag, false, false); + + /* test going to click-to-play from disabled and back */ + tag.enabledState = Ci.nsIPluginTag.STATE_DISABLED; + check_state(tag, false, true); + tag.enabledState = Ci.nsIPluginTag.STATE_CLICKTOPLAY; + check_state(tag, true, false); + tag.enabledState = Ci.nsIPluginTag.STATE_DISABLED; + check_state(tag, false, true); + + /* put everything back to normal and check that that succeeded */ + tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED; + check_state(tag, false, false); +} diff --git a/dom/plugins/test/unit/test_nice_plugin_name.js b/dom/plugins/test/unit/test_nice_plugin_name.js new file mode 100644 index 000000000..32d2870af --- /dev/null +++ b/dom/plugins/test/unit/test_nice_plugin_name.js @@ -0,0 +1,80 @@ +/* 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/. + */ + +const XULAPPINFO_CONTRACTID = "@mozilla.org/xre/app-info;1"; +const XULAPPINFO_CID = Components.ID("{c763b610-9d49-455a-bbd2-ede71682a1ac}"); + +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +var gAppInfo = null; + +function createAppInfo(ID, name, version, platformVersion="1.0") { + let tmp = {}; + Cu.import("resource://testing-common/AppInfo.jsm", tmp); + tmp.updateAppInfo({ + ID, name, version, platformVersion, + crashReporter: true + }); + gAppInfo = tmp.getAppInfo(); +} + +var gPluginHost = null; + +function test_expected_permission_string(aPermString) { + gPluginHost.reloadPlugins(false); + let plugin = get_test_plugintag(); + do_check_false(plugin == null); + do_check_eq(gPluginHost.getPermissionStringForType("application/x-test"), + aPermString); +} + +function run_test() { + allow_all_plugins(); + do_check_true(gIsWindows || gIsOSX || gIsLinux); + do_check_true(!(gIsWindows && gIsOSX) && !(gIsWindows && gIsLinux) && + !(gIsOSX && gIsLinux)); + + createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9"); + gPluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost); + + let expectedDefaultPermissionString = null; + if (gIsWindows) expectedDefaultPermissionString = "plugin:nptest"; + if (gIsOSX) expectedDefaultPermissionString = "plugin:test"; + if (gIsLinux) expectedDefaultPermissionString = "plugin:libnptest"; + test_expected_permission_string(expectedDefaultPermissionString); + + let suffix = get_platform_specific_plugin_suffix(); + let pluginFile = get_test_plugin_no_symlink(); + let pluginDir = pluginFile.parent; + pluginFile.copyTo(null, "npblah235" + suffix); + let pluginCopy = pluginDir.clone(); + pluginCopy.append("npblah235" + suffix); + let tempDir = do_get_tempdir(); + pluginFile.moveTo(tempDir, null); + test_expected_permission_string("plugin:npblah"); + + pluginCopy.moveTo(null, "npasdf-3.2.2" + suffix); + test_expected_permission_string("plugin:npasdf"); + + pluginCopy.moveTo(null, "npasdf_##29387!{}{[][" + suffix); + test_expected_permission_string("plugin:npasdf"); + + pluginCopy.moveTo(null, "npqtplugin7" + suffix); + test_expected_permission_string("plugin:npqtplugin"); + + pluginCopy.moveTo(null, "npFoo3d" + suffix); + test_expected_permission_string("plugin:npfoo3d"); + + pluginCopy.moveTo(null, "NPSWF32_11_5_502_146" + suffix); + test_expected_permission_string("plugin:npswf"); + + pluginCopy.remove(true); + pluginFile.moveTo(pluginDir, null); + test_expected_permission_string(expectedDefaultPermissionString); + + // Clean up + Services.prefs.clearUserPref("plugin.importedState"); +} diff --git a/dom/plugins/test/unit/test_persist_in_prefs.js b/dom/plugins/test/unit/test_persist_in_prefs.js new file mode 100644 index 000000000..ede0074d3 --- /dev/null +++ b/dom/plugins/test/unit/test_persist_in_prefs.js @@ -0,0 +1,76 @@ +/* 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/. + */ + +Components.utils.import("resource://gre/modules/Services.jsm"); + +// Plugin registry uses different field delimeters on different platforms +var DELIM = mozinfo.os == "win" ? "|" : ":"; + +var gProfD = do_get_profile_startup(); + +function run_test() { + allow_all_plugins(); + + do_check_true(gIsWindows || gIsOSX || gIsLinux); + + let file = get_test_plugin_no_symlink(); + if (!file) + do_throw("Plugin library not found"); + + const pluginDir = file.parent; + const tempDir = do_get_tempdir(); + const suffix = get_platform_specific_plugin_suffix(); + const pluginName = file.leafName.substring(0, file.leafName.length - suffix.length).toLowerCase(); + const pluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost); + const statePref = "plugin.state." + pluginName; + + // Initialise profile folder + do_get_profile(); + + let plugin = get_test_plugintag(); + if (!plugin) + do_throw("Plugin tag not found"); + + plugin.enabledState = Ci.nsIPluginTag.STATE_DISABLED; + + // prepare a copy of the plugin and backup the original + file.copyTo(null, "nptestcopy" + suffix); + let copy = pluginDir.clone(); + copy.append("nptestcopy" + suffix); + file.moveTo(tempDir, null); + + // test that the settings persist through a few variations of test-plugin names + let testNames = [ + pluginName + "2", + pluginName.toUpperCase() + "_11_5_42_2323", + pluginName + "-5.2.7" + ]; + testNames.forEach(function(leafName) { + dump("Checking " + leafName + ".\n"); + copy.moveTo(null, leafName + suffix); + pluginHost.reloadPlugins(false); + plugin = get_test_plugintag(); + do_check_false(plugin == null); + do_check_true(plugin.disabled); + do_check_false(plugin.clicktoplay); + }); + + // check that the state persists even if the plugin is not always present + copy.moveTo(tempDir, null); + pluginHost.reloadPlugins(false); + copy.moveTo(pluginDir, null); + pluginHost.reloadPlugins(false); + + plugin = get_test_plugintag(); + do_check_false(plugin == null); + do_check_true(plugin.disabled); + do_check_false(plugin.clicktoplay); + + // clean up + Services.prefs.clearUserPref(statePref); + Services.prefs.clearUserPref("plugin.importedState"); + copy.remove(true); + file.moveTo(pluginDir, null); +} diff --git a/dom/plugins/test/unit/test_plugin_default_state.js b/dom/plugins/test/unit/test_plugin_default_state.js new file mode 100644 index 000000000..cb68c61e7 --- /dev/null +++ b/dom/plugins/test/unit/test_plugin_default_state.js @@ -0,0 +1,31 @@ +Components.utils.import("resource://gre/modules/Services.jsm"); + +function run_test() { + allow_all_plugins(); + let pluginDefaultState = Services.prefs.getIntPref("plugin.default.state"); + // if this fails, we just have to switch around the values we're testing + do_check_neq(pluginDefaultState, Ci.nsIPluginTag.STATE_DISABLED); + let nonDefaultState = (pluginDefaultState != Ci.nsIPluginTag.STATE_ENABLED ? + Ci.nsIPluginTag.STATE_ENABLED : + Ci.nsIPluginTag.STATE_CLICKTOPLAY); + let ph = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost); + let testPlugin = get_test_plugintag(); + // the test plugin should have the default enabledState + do_check_eq(testPlugin.enabledState, pluginDefaultState); + + let secondTestPlugin = get_test_plugintag("Second Test Plug-in"); + // set an enabledState for the second test plugin + secondTestPlugin.enabledState = Ci.nsIPluginTag.STATE_DISABLED; + // change what the default enabledState is + Services.prefs.setIntPref("plugin.default.state", nonDefaultState); + // the test plugin should follow the default (it has no individual pref yet) + do_check_eq(testPlugin.enabledState, nonDefaultState); + // the second test plugin should retain its preferred state + do_check_eq(secondTestPlugin.enabledState, Ci.nsIPluginTag.STATE_DISABLED); + + // clean up + testPlugin.enabledState = pluginDefaultState; + secondTestPlugin.enabledState = pluginDefaultState; + Services.prefs.clearUserPref("plugin.default.state"); + Services.prefs.clearUserPref("plugin.importedState"); +} diff --git a/dom/plugins/test/unit/test_plugin_default_state_xpi.js b/dom/plugins/test/unit/test_plugin_default_state_xpi.js new file mode 100644 index 000000000..f1aeb3ac9 --- /dev/null +++ b/dom/plugins/test/unit/test_plugin_default_state_xpi.js @@ -0,0 +1,118 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/Promise.jsm"); + +const ADDON_ID = "test-plugin-from-xpi@tests.mozilla.org"; +const XRE_EXTENSIONS_DIR_LIST = "XREExtDL"; +const NS_APP_PLUGINS_DIR_LIST = "APluginsDL"; + +const gPluginHost = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost); +const gXPCOMABI = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime).XPCOMABI; +var gProfileDir = null; + +function getAddonRoot(profileDir, id) { + let dir = profileDir.clone(); + dir.append("extensions"); + Assert.ok(dir.exists(), "Extensions dir should exist: " + dir.path); + dir.append(id); + return dir; +} + +function getTestaddonFilename() { + let abiPart = ""; + if (gIsOSX) { + abiPart = "_" + gXPCOMABI; + } + return "testaddon" + abiPart + ".xpi"; +} + +function run_test() { + allow_all_plugins(); + loadAddonManager(); + gProfileDir = do_get_profile(); + do_register_cleanup(() => shutdownManager()); + run_next_test(); +} + +add_task(function* test_state() { + // Remove test so we will have only one "Test Plug-in" registered. + // xpcshell tests have plugins in per-test profiles, so that's fine. + let file = get_test_plugin(); + file.remove(true); + file = get_test_plugin(true); + file.remove(true); + + Services.prefs.setIntPref("plugin.default.state", Ci.nsIPluginTag.STATE_CLICKTOPLAY); + Services.prefs.setIntPref("plugin.defaultXpi.state", Ci.nsIPluginTag.STATE_ENABLED); + + let success = yield installAddon(getTestaddonFilename()); + Assert.ok(success, "Should have installed addon."); + let addonDir = getAddonRoot(gProfileDir, ADDON_ID); + + let provider = { + classID: Components.ID("{0af6b2d7-a06c-49b7-babc-636d292b0dbb}"), + QueryInterface: XPCOMUtils.generateQI([Ci.nsIDirectoryServiceProvider, + Ci.nsIDirectoryServiceProvider2]), + + getFile: function (prop, persistant) { + throw Cr.NS_ERROR_FAILURE; + }, + + getFiles: function (prop) { + let result = []; + + switch (prop) { + case XRE_EXTENSIONS_DIR_LIST: + result.push(addonDir); + break; + case NS_APP_PLUGINS_DIR_LIST: + let pluginDir = addonDir.clone(); + pluginDir.append("plugins"); + result.push(pluginDir); + break; + default: + throw Cr.NS_ERROR_FAILURE; + } + + return { + QueryInterface: XPCOMUtils.generateQI([Ci.nsISimpleEnumerator]), + hasMoreElements: () => result.length > 0, + getNext: () => result.shift(), + }; + }, + }; + + let dirSvc = Cc["@mozilla.org/file/directory_service;1"].getService(Ci.nsIProperties); + dirSvc.QueryInterface(Ci.nsIDirectoryService).registerProvider(provider); + + // We installed a non-restartless addon, need to restart the manager. + restartManager(); + gPluginHost.reloadPlugins(); + + Assert.ok(addonDir.exists(), "Addon path should exist: " + addonDir.path); + Assert.ok(addonDir.isDirectory(), "Addon path should be a directory: " + addonDir.path); + let pluginDir = addonDir.clone(); + pluginDir.append("plugins"); + Assert.ok(pluginDir.exists(), "Addon plugins path should exist: " + pluginDir.path); + Assert.ok(pluginDir.isDirectory(), "Addon plugins path should be a directory: " + pluginDir.path); + + let addon = yield getAddonByID(ADDON_ID); + Assert.ok(!addon.appDisabled, "Addon should not be appDisabled"); + Assert.ok(addon.isActive, "Addon should be active"); + Assert.ok(addon.isCompatible, "Addon should be compatible"); + Assert.ok(!addon.userDisabled, "Addon should not be user disabled"); + + let testPlugin = get_test_plugintag(); + Assert.notEqual(testPlugin, null, "Test plugin should have been found"); + Assert.equal(testPlugin.enabledState, Ci.nsIPluginTag.STATE_ENABLED, "Test plugin from addon should have state enabled"); + + pluginDir.append(testPlugin.filename); + Assert.ok(pluginDir.exists(), "Plugin file should exist in addon directory: " + pluginDir.path); + + testPlugin = get_test_plugintag("Second Test Plug-in"); + Assert.notEqual(testPlugin, null, "Second test plugin should have been found"); + Assert.equal(testPlugin.enabledState, Ci.nsIPluginTag.STATE_ENABLED, "Second test plugin from addon should have state enabled"); +}); diff --git a/dom/plugins/test/unit/xpcshell.ini b/dom/plugins/test/unit/xpcshell.ini new file mode 100644 index 000000000..8dae66b20 --- /dev/null +++ b/dom/plugins/test/unit/xpcshell.ini @@ -0,0 +1,29 @@ +[DEFAULT] +skip-if = toolkit == 'android' +head = head_plugins.js +tail = +tags = addons +firefox-appdir = browser +support-files = + !/toolkit/mozapps/extensions/test/xpcshell/head_addons.js + +[test_allowed_types.js] +skip-if = appname == "thunderbird" +reason = plugins are disabled by default in Thunderbird +[test_bug471245.js] +# Bug 676953: test fails consistently on Android +fail-if = os == "android" +[test_bug813245.js] +# Bug 676953: test fails consistently on Android +fail-if = os == "android" +[test_nice_plugin_name.js] +# Bug 676953: test fails consistently on Android +fail-if = os == "android" +[test_persist_in_prefs.js] +skip-if = appname == "thunderbird" +reason = plugins are disabled by default in Thunderbird +[test_bug854467.js] +[test_plugin_default_state.js] +skip-if = appname == "thunderbird" +reason = plugins are disabled by default in Thunderbird +[test_plugin_default_state_xpi.js] |