mozilla-central/toolkit/mozapps/extensions/test/xpcshell/test_proxies.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

/* Any copyright is dedicated to the Public Domain.
*/
// Tests the semantics of extension proxy files and symlinks
var ADDONS = [
{
id: "proxy1@tests.mozilla.org",
dirId: "proxy1@tests.mozilla.com",
type: "proxy",
},
{
id: "proxy2@tests.mozilla.org",
type: "proxy",
},
{
id: "symlink1@tests.mozilla.org",
dirId: "symlink1@tests.mozilla.com",
type: "symlink",
},
{
id: "symlink2@tests.mozilla.org",
type: "symlink",
},
];
const gHaveSymlinks = AppConstants.platform != "win";
function createSymlink(aSource, aDest) {
if (aSource instanceof Ci.nsIFile) {
aSource = aSource.path;
}
if (aDest instanceof Ci.nsIFile) {
aDest = aDest.path;
}
const ln = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
ln.initWithPath("/bin/ln");
const lnProcess = Cc["@mozilla.org/process/util;1"].createInstance(
Ci.nsIProcess
);
lnProcess.init(ln);
const args = ["-s", aSource, aDest];
lnProcess.run(true, args, args.length);
Assert.equal(lnProcess.exitValue, 0);
}
async function promiseWriteFile(aFile, aData) {
if (!(await IOUtils.exists(aFile.parent.path))) {
await IOUtils.makeDirectory(aFile.parent.path);
}
return IOUtils.writeUTF8(aFile.path, aData);
}
function checkAddonsExist() {
for (let addon of ADDONS) {
let file = addon.directory.clone();
file.append("manifest.json");
Assert.ok(file.exists());
}
}
const profileDir = gProfD.clone();
profileDir.append("extensions");
function run_test() {
createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "2", "2");
// Unpacked extensions are never signed, so this can only run with
// signature checks disabled.
Services.prefs.setBoolPref(PREF_XPI_SIGNATURES_REQUIRED, false);
add_task(run_proxy_tests);
if (gHaveSymlinks) {
add_task(run_symlink_tests);
}
run_next_test();
}
async function run_proxy_tests() {
if (!gHaveSymlinks) {
ADDONS = ADDONS.filter(a => a.type != "symlink");
}
for (let addon of ADDONS) {
addon.directory = gTmpD.clone();
addon.directory.append(addon.id);
addon.proxyFile = profileDir.clone();
addon.proxyFile.append(addon.dirId || addon.id);
let files = ExtensionTestCommon.generateFiles({
manifest: {
name: addon.id,
browser_specific_settings: { gecko: { id: addon.id } },
},
});
let path = PathUtils.join(gTmpD.path, addon.id);
await AddonTestUtils.promiseWriteFilesToDir(path, files);
if (addon.type == "proxy") {
await promiseWriteFile(addon.proxyFile, addon.directory.path);
} else if (addon.type == "symlink") {
await createSymlink(addon.directory, addon.proxyFile);
}
}
await promiseStartupManager();
// Check that all add-ons original sources still exist after invalid
// add-ons have been removed at startup.
checkAddonsExist();
let addons = await AddonManager.getAddonsByIDs(ADDONS.map(addon => addon.id));
try {
for (let [i, addon] of addons.entries()) {
// Ensure that valid proxied add-ons were installed properly on
// platforms that support the installation method.
print(
ADDONS[i].id,
ADDONS[i].dirId,
ADDONS[i].dirId != null,
ADDONS[i].type == "symlink"
);
Assert.equal(addon == null, ADDONS[i].dirId != null);
if (addon != null) {
let fixURL = url => {
if (AppConstants.platform == "macosx") {
return url.replace(RegExp(`^file:///private/`), "file:///");
}
return url;
};
// Check that proxied add-ons do not have upgrade permissions.
Assert.equal(addon.permissions & AddonManager.PERM_CAN_UPGRADE, 0);
// Check that getResourceURI points to the right place.
Assert.equal(
Services.io.newFileURI(ADDONS[i].directory).spec,
fixURL(addon.getResourceURI().spec),
`Base resource URL resolves as expected`
);
let file = ADDONS[i].directory.clone();
file.append("manifest.json");
Assert.equal(
Services.io.newFileURI(file).spec,
fixURL(addon.getResourceURI("manifest.json").spec),
`Resource URLs resolve as expected`
);
await addon.uninstall();
}
}
// Check that original sources still exist after explicit uninstall.
await promiseRestartManager();
checkAddonsExist();
await promiseShutdownManager();
// Check that all of the proxy files have been removed and remove
// the original targets.
for (let addon of ADDONS) {
equal(
addon.proxyFile.exists(),
addon.dirId != null,
`Proxy file ${addon.proxyFile.path} should exist?`
);
addon.directory.remove(true);
try {
addon.proxyFile.remove(false);
} catch (e) {}
}
} catch (e) {
do_throw(e);
}
}
// Check that symlinks are not followed out of a directory tree
// when deleting an add-on.
async function run_symlink_tests() {
const ID = "unpacked@test.mozilla.org";
let tempDirectory = gTmpD.clone();
tempDirectory.append(ID);
let tempFile = tempDirectory.clone();
tempFile.append("test.txt");
tempFile.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o644);
let addonDirectory = profileDir.clone();
addonDirectory.append(ID);
let files = ExtensionTestCommon.generateFiles({
manifest: { browser_specific_settings: { gecko: { id: ID } } },
});
await AddonTestUtils.promiseWriteFilesToDir(addonDirectory.path, files);
let symlink = addonDirectory.clone();
symlink.append(tempDirectory.leafName);
await createSymlink(tempDirectory, symlink);
// Make sure that the symlink was created properly.
let file = symlink.clone();
file.append(tempFile.leafName);
file.normalize();
Assert.equal(file.path.replace(/^\/private\//, "/"), tempFile.path);
await promiseStartupManager();
let addon = await AddonManager.getAddonByID(ID);
Assert.notEqual(addon, null);
await addon.uninstall();
await promiseRestartManager();
await promiseShutdownManager();
// Check that the install directory is gone.
Assert.ok(!addonDirectory.exists());
// Check that the temp file is not gone.
Assert.ok(tempFile.exists());
tempDirectory.remove(true);
}