The Tor Browser / file revision

 /* Any copyright is dedicated to the Public Domain.

  * http://creativecommons.org/publicdomain/zero/1.0/

  */

 // This verifies that add-on update checks work

 const PREF_MATCH_OS_LOCALE = "intl.locale.matchOS";

 const PREF_SELECTED_LOCALE = "general.useragent.locale";

 const PREF_GETADDONS_CACHE_ENABLED = "extensions.getAddons.cache.enabled";

 // The test extension uses an insecure update url.

 Services.prefs.setBoolPref("extensions.checkUpdateSecurity", false);

 // This test requires lightweight themes update to be enabled even if the app

 // doesn't support lightweight themes.

 Services.prefs.setBoolPref("lightweightThemes.update.enabled", true);

 Components.utils.import("resource://gre/modules/LightweightThemeManager.jsm");

 const PARAMS = "?%REQ_VERSION%/%ITEM_ID%/%ITEM_VERSION%/%ITEM_MAXAPPVERSION%/" +

                "%ITEM_STATUS%/%APP_ID%/%APP_VERSION%/%CURRENT_APP_VERSION%/" +

                "%APP_OS%/%APP_ABI%/%APP_LOCALE%/%UPDATE_TYPE%";

 var gInstallDate;

 Components.utils.import("resource://testing-common/httpd.js");

 var testserver = new HttpServer();

 testserver.start(-1);

 gPort = testserver.identity.primaryPort;

 mapFile("/data/test_update.rdf", testserver);

 mapFile("/data/test_update.xml", testserver);

 testserver.registerDirectory("/addons/", do_get_file("addons"));

 const profileDir = gProfD.clone();

 profileDir.append("extensions");

 function run_test() {

   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");

   Services.prefs.setBoolPref(PREF_MATCH_OS_LOCALE, false);

   Services.prefs.setCharPref(PREF_SELECTED_LOCALE, "fr-FR");

   Services.prefs.setBoolPref(PREF_EM_STRICT_COMPATIBILITY, true);

   writeInstallRDFForExtension({

     id: "addon1@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "1"

     }],

     name: "Test Addon 1",

   }, profileDir);

   writeInstallRDFForExtension({

     id: "addon2@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "0",

       maxVersion: "0"

     }],

     name: "Test Addon 2",

   }, profileDir);

   writeInstallRDFForExtension({

     id: "addon3@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "5",

       maxVersion: "5"

     }],

     name: "Test Addon 3",

   }, profileDir);

   startupManager();

   do_test_pending();

   run_test_1();

 }

 function end_test() {

   Services.prefs.clearUserPref(PREF_EM_STRICT_COMPATIBILITY);

   testserver.stop(do_test_finished);

 }

 // Verify that an update is available and can be installed.

 function run_test_1() {

   AddonManager.getAddonByID("addon1@tests.mozilla.org", function(a1) {

     do_check_neq(a1, null);

     do_check_eq(a1.version, "1.0");

     do_check_eq(a1.applyBackgroundUpdates, AddonManager.AUTOUPDATE_DEFAULT);

     do_check_eq(a1.releaseNotesURI, null);

     a1.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DEFAULT;

     prepare_test({

       "addon1@tests.mozilla.org": [

         ["onPropertyChanged", ["applyBackgroundUpdates"]]

       ]

     });

     a1.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DISABLE;

     check_test_completed();

     a1.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DISABLE;

     prepare_test({}, [

       "onNewInstall",

     ]);

     a1.findUpdates({

       onNoCompatibilityUpdateAvailable: function(addon) {

         do_throw("Should not have seen onNoCompatibilityUpdateAvailable notification");

       },

       onUpdateAvailable: function(addon, install) {

         ensure_test_completed();

         AddonManager.getAllInstalls(function(aInstalls) {

           do_check_eq(aInstalls.length, 1);

           do_check_eq(aInstalls[0], install);

           do_check_eq(addon, a1);

           do_check_eq(install.name, addon.name);

           do_check_eq(install.version, "2.0");

           do_check_eq(install.state, AddonManager.STATE_AVAILABLE);

           do_check_eq(install.existingAddon, addon);

           do_check_eq(install.releaseNotesURI.spec, "http://example.com/updateInfo.xhtml");

           // Verify that another update check returns the same AddonInstall

           a1.findUpdates({

             onNoCompatibilityUpdateAvailable: function(addon) {

               do_throw("Should not have seen onNoCompatibilityUpdateAvailable notification");

             },

             onUpdateAvailable: function(newAddon, newInstall) {

               AddonManager.getAllInstalls(function(aInstalls) {

                 do_check_eq(aInstalls.length, 1);

                 do_check_eq(aInstalls[0], install);

                 do_check_eq(newAddon, addon);

                 do_check_eq(newInstall, install);

                 prepare_test({}, [

                   "onDownloadStarted",

                   "onDownloadEnded",

                 ], check_test_1);

                 install.install();

               });

             },

             onNoUpdateAvailable: function(addon) {

               do_throw("Should not have seen onNoUpdateAvailable notification");

             }

           }, AddonManager.UPDATE_WHEN_USER_REQUESTED);

         });

       },

       onNoUpdateAvailable: function(addon) {

         do_throw("Should not have seen onNoUpdateAvailable notification");

       }

     }, AddonManager.UPDATE_WHEN_USER_REQUESTED);

   });

 }

 function check_test_1(install) {

   ensure_test_completed();

   do_check_eq(install.state, AddonManager.STATE_DOWNLOADED);

   run_test_2(install);

   return false;

 }

 // Continue installing the update.

 function run_test_2(install) {

   // Verify that another update check returns no new update

   install.existingAddon.findUpdates({

     onNoCompatibilityUpdateAvailable: function(addon) {

       do_throw("Should not have seen onNoCompatibilityUpdateAvailable notification");

     },

     onUpdateAvailable: function(addon, install) {

       do_throw("Should find no available update when one is already downloading");

     },

     onNoUpdateAvailable: function(addon) {

       AddonManager.getAllInstalls(function(aInstalls) {

         do_check_eq(aInstalls.length, 1);

         do_check_eq(aInstalls[0], install);

         prepare_test({

           "addon1@tests.mozilla.org": [

             "onInstalling"

           ]

         }, [

           "onInstallStarted",

           "onInstallEnded",

         ], check_test_2);

         install.install();

       });

     }

   }, AddonManager.UPDATE_WHEN_USER_REQUESTED);

 }

 function check_test_2() {

   ensure_test_completed();

   AddonManager.getAddonByID("addon1@tests.mozilla.org", callback_soon(function(olda1) {

     do_check_neq(olda1, null);

     do_check_eq(olda1.version, "1.0");

     do_check_true(isExtensionInAddonsList(profileDir, olda1.id));

     shutdownManager();

     startupManager();

     do_check_true(isExtensionInAddonsList(profileDir, olda1.id));

     AddonManager.getAddonByID("addon1@tests.mozilla.org", function(a1) {

       do_check_neq(a1, null);

       do_check_eq(a1.version, "2.0");

       do_check_true(isExtensionInAddonsList(profileDir, a1.id));

       do_check_eq(a1.applyBackgroundUpdates, AddonManager.AUTOUPDATE_DISABLE);

       do_check_eq(a1.releaseNotesURI.spec, "http://example.com/updateInfo.xhtml");

       a1.uninstall();

       do_execute_soon(run_test_3);

     });

   }));

 }

 // Check that an update check finds compatibility updates and applies them

 function run_test_3() {

   restartManager();

   AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {

     do_check_neq(a2, null);

     do_check_false(a2.isActive);

     do_check_false(a2.isCompatible);

     do_check_true(a2.appDisabled);

     do_check_true(a2.isCompatibleWith("0"));

     a2.findUpdates({

       onCompatibilityUpdateAvailable: function(addon) {

         do_check_true(a2.isCompatible);

         do_check_false(a2.appDisabled);

         do_check_false(a2.isActive);

       },

       onUpdateAvailable: function(addon, install) {

         do_throw("Should not have seen an available update");

       },

       onNoUpdateAvailable: function(addon) {

         do_check_eq(addon, a2);

         do_execute_soon(check_test_3);

       }

     }, AddonManager.UPDATE_WHEN_USER_REQUESTED);

   });

 }

 function check_test_3() {

   restartManager();

   AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {

     do_check_neq(a2, null);

     do_check_true(a2.isActive);

     do_check_true(a2.isCompatible);

     do_check_false(a2.appDisabled);

     a2.uninstall();

     run_test_4();

   });

 }

 // Checks that we see no compatibility information when there is none.

 function run_test_4() {

   AddonManager.getAddonByID("addon3@tests.mozilla.org", function(a3) {

     do_check_neq(a3, null);

     do_check_false(a3.isActive);

     do_check_false(a3.isCompatible);

     do_check_true(a3.appDisabled);

     do_check_true(a3.isCompatibleWith("5"));

     do_check_false(a3.isCompatibleWith("2"));

     a3.findUpdates({

       sawUpdate: false,

       onCompatibilityUpdateAvailable: function(addon) {

         do_throw("Should not have seen compatibility information");

       },

       onNoCompatibilityUpdateAvailable: function(addon) {

         this.sawUpdate = true;

       },

       onUpdateAvailable: function(addon, install) {

         do_throw("Should not have seen an available update");

       },

       onNoUpdateAvailable: function(addon) {

         do_check_true(this.sawUpdate);

         run_test_5();

       }

     }, AddonManager.UPDATE_WHEN_USER_REQUESTED);

   });

 }

 // Checks that compatibility info for future apps are detected but don't make

 // the item compatibile.

 function run_test_5() {

   AddonManager.getAddonByID("addon3@tests.mozilla.org", function(a3) {

     do_check_neq(a3, null);

     do_check_false(a3.isActive);

     do_check_false(a3.isCompatible);

     do_check_true(a3.appDisabled);

     do_check_true(a3.isCompatibleWith("5"));

     do_check_false(a3.isCompatibleWith("2"));

     a3.findUpdates({

       sawUpdate: false,

       onCompatibilityUpdateAvailable: function(addon) {

         do_check_false(a3.isCompatible);

         do_check_true(a3.appDisabled);

         do_check_false(a3.isActive);

         this.sawUpdate = true;

       },

       onNoCompatibilityUpdateAvailable: function(addon) {

         do_throw("Should have seen some compatibility information");

       },

       onUpdateAvailable: function(addon, install) {

         do_throw("Should not have seen an available update");

       },

       onNoUpdateAvailable: function(addon) {

         do_check_true(this.sawUpdate);

         do_execute_soon(check_test_5);

       }

     }, AddonManager.UPDATE_WHEN_USER_REQUESTED, "3.0");

   });

 }

 function check_test_5() {

   restartManager();

   AddonManager.getAddonByID("addon3@tests.mozilla.org", function(a3) {

     do_check_neq(a3, null);

     do_check_false(a3.isActive);

     do_check_false(a3.isCompatible);

     do_check_true(a3.appDisabled);

     a3.uninstall();

     do_execute_soon(run_test_6);

   });

 }

 // Test that background update checks work

 function run_test_6() {

   restartManager();

   writeInstallRDFForExtension({

     id: "addon1@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "1"

     }],

     name: "Test Addon 1",

   }, profileDir);

   restartManager();

   prepare_test({}, [

     "onNewInstall",

     "onDownloadStarted",

     "onDownloadEnded"

   ], continue_test_6);

   // Fake a timer event to cause a background update and wait for the magic to

   // happen

   gInternalManager.notify(null);

 }

 function continue_test_6(install) {

   do_check_neq(install.existingAddon, null);

   do_check_eq(install.existingAddon.id, "addon1@tests.mozilla.org");

   prepare_test({

     "addon1@tests.mozilla.org": [

       "onInstalling"

     ]

   }, [

     "onInstallStarted",

     "onInstallEnded",

   ], callback_soon(check_test_6));

 }

 function check_test_6(install) {

   do_check_eq(install.existingAddon.pendingUpgrade.install, install);

   restartManager();

   AddonManager.getAddonByID("addon1@tests.mozilla.org", function(a1) {

     do_check_neq(a1, null);

     do_check_eq(a1.version, "2.0");

     do_check_eq(a1.releaseNotesURI.spec, "http://example.com/updateInfo.xhtml");

     a1.uninstall();

     do_execute_soon(run_test_7);

   });

 }

 // Test that background update checks work for lightweight themes

 function run_test_7() {

   restartManager();

   LightweightThemeManager.currentTheme = {

     id: "1",

     version: "1",

     name: "Test LW Theme",

     description: "A test theme",

     author: "Mozilla",

     homepageURL: "http://localhost:" + gPort + "/data/index.html",

     headerURL: "http://localhost:" + gPort + "/data/header.png",

     footerURL: "http://localhost:" + gPort + "/data/footer.png",

     previewURL: "http://localhost:" + gPort + "/data/preview.png",

     iconURL: "http://localhost:" + gPort + "/data/icon.png",

     updateURL: "http://localhost:" + gPort + "/data/lwtheme.js"

   };

   // XXX The lightweight theme manager strips non-https updateURLs so hack it

   // back in.

   let themes = JSON.parse(Services.prefs.getCharPref("lightweightThemes.usedThemes"));

   do_check_eq(themes.length, 1);

   themes[0].updateURL = "http://localhost:" + gPort + "/data/lwtheme.js";

   Services.prefs.setCharPref("lightweightThemes.usedThemes", JSON.stringify(themes));

   testserver.registerPathHandler("/data/lwtheme.js", function(request, response) {

     response.write(JSON.stringify({

       id: "1",

       version: "2",

       name: "Updated Theme",

       description: "A test theme",

       author: "Mozilla",

       homepageURL: "http://localhost:" + gPort + "/data/index2.html",

       headerURL: "http://localhost:" + gPort + "/data/header.png",

       footerURL: "http://localhost:" + gPort + "/data/footer.png",

       previewURL: "http://localhost:" + gPort + "/data/preview.png",

       iconURL: "http://localhost:" + gPort + "/data/icon2.png",

       updateURL: "http://localhost:" + gPort + "/data/lwtheme.js"

     }));

   });

   AddonManager.getAddonByID("1@personas.mozilla.org", function(p1) {

     do_check_neq(p1, null);

     do_check_eq(p1.version, "1");

     do_check_eq(p1.name, "Test LW Theme");

     do_check_true(p1.isActive);

     do_check_eq(p1.installDate.getTime(), p1.updateDate.getTime());

     // 5 seconds leeway seems like a lot, but tests can run slow and really if

     // this is within 5 seconds it is fine. If it is going to be wrong then it

     // is likely to be hours out at least

     do_check_true((Date.now() - p1.installDate.getTime()) < 5000);

     gInstallDate = p1.installDate.getTime();

     prepare_test({

       "1@personas.mozilla.org": [

         ["onInstalling", false],

         "onInstalled"

       ]

     }, [

       "onExternalInstall"

     ], check_test_7);

     // Fake a timer event to cause a background update and wait for the magic to

     // happen

     gInternalManager.notify(null);

   });

 }

 function check_test_7() {

   AddonManager.getAddonByID("1@personas.mozilla.org", function(p1) {

     do_check_neq(p1, null);

     do_check_eq(p1.version, "2");

     do_check_eq(p1.name, "Updated Theme");

     do_check_eq(p1.installDate.getTime(), gInstallDate);

     do_check_true(p1.installDate.getTime() < p1.updateDate.getTime());

     // 5 seconds leeway seems like a lot, but tests can run slow and really if

     // this is within 5 seconds it is fine. If it is going to be wrong then it

     // is likely to be hours out at least

     do_check_true((Date.now() - p1.updateDate.getTime()) < 5000);

     gInstallDate = p1.installDate.getTime();

     do_execute_soon(run_test_8);

   });

 }

 // Verify the parameter escaping in update urls.

 function run_test_8() {

   writeInstallRDFForExtension({

     id: "addon1@tests.mozilla.org",

     version: "5.0",

     updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "2"

     }],

     name: "Test Addon 1",

   }, profileDir);

   writeInstallRDFForExtension({

     id: "addon2@tests.mozilla.org",

     version: "67.0.5b1",

     updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,

     targetApplications: [{

       id: "toolkit@mozilla.org",

       minVersion: "0",

       maxVersion: "3"

     }],

     name: "Test Addon 2",

   }, profileDir);

   writeInstallRDFForExtension({

     id: "addon3@tests.mozilla.org",

     version: "1.3+",

     updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "0",

       maxVersion: "0"

     }, {

       id: "toolkit@mozilla.org",

       minVersion: "0",

       maxVersion: "3"

     }],

     name: "Test Addon 3",

   }, profileDir);

   writeInstallRDFForExtension({

     id: "addon4@tests.mozilla.org",

     version: "0.5ab6",

     updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "5"

     }],

     name: "Test Addon 4",

   }, profileDir);

   writeInstallRDFForExtension({

     id: "addon5@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "1"

     }],

     name: "Test Addon 5",

   }, profileDir);

   writeInstallRDFForExtension({

     id: "addon6@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "1"

     }],

     name: "Test Addon 6",

   }, profileDir);

   restartManager();

   AddonManager.getAddonByID("addon2@tests.mozilla.org", callback_soon(function(a2) {

     a2.userDisabled = true;

     restartManager();

     testserver.registerPathHandler("/data/param_test.rdf", function(request, response) {

       do_check_neq(request.queryString, "");

       let [req_version, item_id, item_version,

            item_maxappversion, item_status,

            app_id, app_version, current_app_version,

            app_os, app_abi, app_locale, update_type] =

            [decodeURIComponent(a) for each (a in request.queryString.split("/"))];

       do_check_eq(req_version, "2");

       switch(item_id) {

       case "addon1@tests.mozilla.org":

         do_check_eq(item_version, "5.0");

         do_check_eq(item_maxappversion, "2");

         do_check_eq(item_status, "userEnabled");

         do_check_eq(app_version, "1");

         do_check_eq(update_type, "97");

         break;

       case "addon2@tests.mozilla.org":

         do_check_eq(item_version, "67.0.5b1");

         do_check_eq(item_maxappversion, "3");

         do_check_eq(item_status, "userDisabled");

         do_check_eq(app_version, "1");

         do_check_eq(update_type, "49");

         break;

       case "addon3@tests.mozilla.org":

         do_check_eq(item_version, "1.3+");

         do_check_eq(item_maxappversion, "0");

         do_check_eq(item_status, "userEnabled,incompatible");

         do_check_eq(app_version, "1");

         do_check_eq(update_type, "112");

         break;

       case "addon4@tests.mozilla.org":

         do_check_eq(item_version, "0.5ab6");

         do_check_eq(item_maxappversion, "5");

         do_check_eq(item_status, "userEnabled");

         do_check_eq(app_version, "2");

         do_check_eq(update_type, "98");

         break;

       case "addon5@tests.mozilla.org":

         do_check_eq(item_version, "1.0");

         do_check_eq(item_maxappversion, "1");

         do_check_eq(item_status, "userEnabled");

         do_check_eq(app_version, "1");

         do_check_eq(update_type, "35");

         break;

       case "addon6@tests.mozilla.org":

         do_check_eq(item_version, "1.0");

         do_check_eq(item_maxappversion, "1");

         do_check_eq(item_status, "userEnabled");

         do_check_eq(app_version, "1");

         do_check_eq(update_type, "99");

         break;

       default:

         do_throw("Update request for unexpected add-on " + item_id);

       }

       do_check_eq(app_id, "xpcshell@tests.mozilla.org");

       do_check_eq(current_app_version, "1");

       do_check_eq(app_os, "XPCShell");

       do_check_eq(app_abi, "noarch-spidermonkey");

       do_check_eq(app_locale, "fr-FR");

       request.setStatusLine(null, 500, "Server Error");

     });

     AddonManager.getAddonsByIDs(["addon1@tests.mozilla.org",

                                  "addon2@tests.mozilla.org",

                                  "addon3@tests.mozilla.org",

                                  "addon4@tests.mozilla.org",

                                  "addon5@tests.mozilla.org",

                                  "addon6@tests.mozilla.org"],

                                  function([a1, a2, a3, a4, a5, a6]) {

       let count = 6;

       function run_next_test() {

         a1.uninstall();

         a2.uninstall();

         a3.uninstall();

         a4.uninstall();

         a5.uninstall();

         a6.uninstall();

         restartManager();

         run_test_9();

       }

       let compatListener = {

         onUpdateFinished: function(addon, error) {

           if (--count == 0)

             do_execute_soon(run_next_test);

         }

       };

       let updateListener = {

         onUpdateAvailable: function(addon, update) {

           // Dummy so the update checker knows we care about new versions

         },

         onUpdateFinished: function(addon, error) {

           if (--count == 0)

             do_execute_soon(run_next_test);

         }

       };

       a1.findUpdates(updateListener, AddonManager.UPDATE_WHEN_USER_REQUESTED);

       a2.findUpdates(compatListener, AddonManager.UPDATE_WHEN_ADDON_INSTALLED);

       a3.findUpdates(updateListener, AddonManager.UPDATE_WHEN_PERIODIC_UPDATE);

       a4.findUpdates(updateListener, AddonManager.UPDATE_WHEN_NEW_APP_DETECTED, "2");

       a5.findUpdates(compatListener, AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED);

       a6.findUpdates(updateListener, AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED);

     });

   }));

 }

 // Tests that if an install.rdf claims compatibility then the add-on will be

 // seen as compatible regardless of what the update.rdf says.

 function run_test_9() {

   writeInstallRDFForExtension({

     id: "addon4@tests.mozilla.org",

     version: "5.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "0",

       maxVersion: "1"

     }],

     name: "Test Addon 1",

   }, profileDir);

   restartManager();

   AddonManager.getAddonByID("addon4@tests.mozilla.org", function(a4) {

     do_check_true(a4.isActive);

     do_check_true(a4.isCompatible);

     run_test_10();

   });

 }

 // Tests that a normal update check won't decrease a targetApplication's

 // maxVersion.

 function run_test_10() {

   AddonManager.getAddonByID("addon4@tests.mozilla.org", function(a4) {

     a4.findUpdates({

       onUpdateFinished: function(addon) {

         do_check_true(addon.isCompatible);

         run_test_11();

       }

     }, AddonManager.UPDATE_WHEN_PERIODIC_UPDATE);

   });

 }

 // Tests that an update check for a new application will decrease a

 // targetApplication's maxVersion.

 function run_test_11() {

   AddonManager.getAddonByID("addon4@tests.mozilla.org", function(a4) {

     a4.findUpdates({

       onUpdateFinished: function(addon) {

         do_check_false(addon.isCompatible);

         do_execute_soon(run_test_12);

       }

     }, AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED);

   });

 }

 // Check that the decreased maxVersion applied and disables the add-on

 function run_test_12() {

   restartManager();

   AddonManager.getAddonByID("addon4@tests.mozilla.org", function(a4) {

     do_check_false(a4.isActive);

     do_check_false(a4.isCompatible);

     a4.uninstall();

     do_execute_soon(run_test_13);

   });

 }

 // Tests that no compatibility update is passed to the listener when there is

 // compatibility info for the current version of the app but not for the

 // version of the app that the caller requested an update check for.

 function run_test_13() {

   restartManager();

   // Not initially compatible but the update check will make it compatible

   writeInstallRDFForExtension({

     id: "addon7@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "0",

       maxVersion: "0"

     }],

     name: "Test Addon 7",

   }, profileDir);

   restartManager();

   AddonManager.getAddonByID("addon7@tests.mozilla.org", function(a7) {

     do_check_neq(a7, null);

     do_check_false(a7.isActive);

     do_check_false(a7.isCompatible);

     do_check_true(a7.appDisabled);

     do_check_true(a7.isCompatibleWith("0"));

     a7.findUpdates({

       sawUpdate: false,

       onCompatibilityUpdateAvailable: function(addon) {

         do_throw("Should have not have seen compatibility information");

       },

       onUpdateAvailable: function(addon, install) {

         do_throw("Should not have seen an available update");

       },

       onUpdateFinished: function(addon) {

         do_check_true(addon.isCompatible);

         do_execute_soon(check_test_13);

       }

     }, AddonManager.UPDATE_WHEN_NEW_APP_DETECTED, "3.0");

   });

 }

 function check_test_13() {

   restartManager();

   AddonManager.getAddonByID("addon7@tests.mozilla.org", function(a7) {

     do_check_neq(a7, null);

     do_check_true(a7.isActive);

     do_check_true(a7.isCompatible);

     do_check_false(a7.appDisabled);

     a7.uninstall();

     do_execute_soon(run_test_14);

   });

 }

 // Test that background update checks doesn't update an add-on that isn't

 // allowed to update automatically.

 function run_test_14() {

   restartManager();

   // Have an add-on there that will be updated so we see some events from it

   writeInstallRDFForExtension({

     id: "addon1@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "1"

     }],

     name: "Test Addon 1",

   }, profileDir);

   writeInstallRDFForExtension({

     id: "addon8@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "1"

     }],

     name: "Test Addon 8",

   }, profileDir);

   restartManager();

   AddonManager.getAddonByID("addon8@tests.mozilla.org", function(a8) {

     a8.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DISABLE;

     // The background update check will find updates for both add-ons but only

     // proceed to install one of them.

     AddonManager.addInstallListener({

       onNewInstall: function(aInstall) {

         if (aInstall.existingAddon.id != "addon1@tests.mozilla.org" &&

             aInstall.existingAddon.id != "addon8@tests.mozilla.org")

           do_throw("Saw unexpected onNewInstall for " + aInstall.existingAddon.id);

       },

       onDownloadStarted: function(aInstall) {

         do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");

       },

       onDownloadEnded: function(aInstall) {

         do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");

       },

       onDownloadFailed: function(aInstall) {

         do_throw("Should not have seen onDownloadFailed event");

       },

       onDownloadCancelled: function(aInstall) {

         do_throw("Should not have seen onDownloadCancelled event");

       },

       onInstallStarted: function(aInstall) {

         do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");

       },

       onInstallEnded: function(aInstall) {

         do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");

         do_check_eq(aInstall.existingAddon.pendingUpgrade.install, aInstall);

         do_execute_soon(check_test_14);

       },

       onInstallFailed: function(aInstall) {

         do_throw("Should not have seen onInstallFailed event");

       },

       onInstallCancelled: function(aInstall) {

         do_throw("Should not have seen onInstallCancelled event");

       },

     });

     // Fake a timer event

     gInternalManager.notify(null);

   });

 }

 function check_test_14() {

   restartManager();

   AddonManager.getAddonsByIDs(["addon1@tests.mozilla.org",

                                "addon8@tests.mozilla.org"], function([a1, a8]) {

     do_check_neq(a1, null);

     do_check_eq(a1.version, "2.0");

     a1.uninstall();

     do_check_neq(a8, null);

     do_check_eq(a8.version, "1.0");

     a8.uninstall();

     do_execute_soon(run_test_15);

   });

 }

 // Test that background update checks doesn't update an add-on that is

 // pending uninstall

 function run_test_15() {

   restartManager();

   // Have an add-on there that will be updated so we see some events from it

   writeInstallRDFForExtension({

     id: "addon1@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "1"

     }],

     name: "Test Addon 1",

   }, profileDir);

   writeInstallRDFForExtension({

     id: "addon8@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "1",

       maxVersion: "1"

     }],

     name: "Test Addon 8",

   }, profileDir);

   restartManager();

   AddonManager.getAddonByID("addon8@tests.mozilla.org", function(a8) {

     a8.uninstall();

     do_check_false(hasFlag(a8.permissions, AddonManager.PERM_CAN_UPGRADE));

     // The background update check will find updates for both add-ons but only

     // proceed to install one of them.

     AddonManager.addInstallListener({

       onNewInstall: function(aInstall) {

         if (aInstall.existingAddon.id != "addon1@tests.mozilla.org" &&

             aInstall.existingAddon.id != "addon8@tests.mozilla.org")

           do_throw("Saw unexpected onNewInstall for " + aInstall.existingAddon.id);

       },

       onDownloadStarted: function(aInstall) {

         do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");

       },

       onDownloadEnded: function(aInstall) {

         do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");

       },

       onDownloadFailed: function(aInstall) {

         do_throw("Should not have seen onDownloadFailed event");

       },

       onDownloadCancelled: function(aInstall) {

         do_throw("Should not have seen onDownloadCancelled event");

       },

       onInstallStarted: function(aInstall) {

         do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");

       },

       onInstallEnded: function(aInstall) {

         do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");

         do_execute_soon(check_test_15);

       },

       onInstallFailed: function(aInstall) {

         do_throw("Should not have seen onInstallFailed event");

       },

       onInstallCancelled: function(aInstall) {

         do_throw("Should not have seen onInstallCancelled event");

       },

     });

     // Fake a timer event

     gInternalManager.notify(null);

   });

 }

 function check_test_15() {

   restartManager();

   AddonManager.getAddonsByIDs(["addon1@tests.mozilla.org",

                                "addon8@tests.mozilla.org"], function([a1, a8]) {

     do_check_neq(a1, null);

     do_check_eq(a1.version, "2.0");

     a1.uninstall();

     do_check_eq(a8, null);

     do_execute_soon(run_test_16);

   });

 }

 // Test that the update check correctly observes the

 // extensions.strictCompatibility pref and compatibility overrides.

 function run_test_16() {

   restartManager();

   writeInstallRDFForExtension({

     id: "addon9@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "0.1",

       maxVersion: "0.2"

     }],

     name: "Test Addon 9",

   }, profileDir);

   restartManager();

   AddonManager.addInstallListener({

     onNewInstall: function(aInstall) {

       if (aInstall.existingAddon.id != "addon9@tests.mozilla.org")

         do_throw("Saw unexpected onNewInstall for " + aInstall.existingAddon.id);

       do_check_eq(aInstall.version, "2.0");

     },

     onDownloadFailed: function(aInstall) {

       do_execute_soon(run_test_17);

     }

   });

   Services.prefs.setCharPref(PREF_GETADDONS_BYIDS_PERFORMANCE,

                              "http://localhost:" + gPort + "/data/test_update.xml");

   Services.prefs.setBoolPref(PREF_GETADDONS_CACHE_ENABLED, true);

   // Fake a timer event

   gInternalManager.notify(null);

 }

 // Test that the update check correctly observes when an addon opts-in to

 // strict compatibility checking.

 function run_test_17() {

   writeInstallRDFForExtension({

     id: "addon11@tests.mozilla.org",

     version: "1.0",

     updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",

     targetApplications: [{

       id: "xpcshell@tests.mozilla.org",

       minVersion: "0.1",

       maxVersion: "0.2"

     }],

     name: "Test Addon 11",

   }, profileDir);

   restartManager();

   AddonManager.getAddonByID("addon11@tests.mozilla.org", function(a11) {

     do_check_neq(a11, null);

     a11.findUpdates({

       onCompatibilityUpdateAvailable: function() {

         do_throw("Should have not have seen compatibility information");

       },

       onUpdateAvailable: function() {

         do_throw("Should not have seen an available update");

       },

       onUpdateFinished: function() {

         do_execute_soon(end_test);

       }

     }, AddonManager.UPDATE_WHEN_USER_REQUESTED);

   });

 }