The Tor Browser: browser/base/content/test/social/browser

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     3 let AddonManager = Cu.import("resource://gre/modules/AddonManager.jsm", {}).AddonManager;

     4 let SocialService = Cu.import("resource://gre/modules/SocialService.jsm", {}).SocialService;

     6 const ADDON_TYPE_SERVICE     = "service";

     7 const ID_SUFFIX              = "@services.mozilla.org";

     8 const STRING_TYPE_NAME       = "type.%ID%.name";

     9 const XPINSTALL_URL = "chrome://mozapps/content/xpinstall/xpinstallConfirm.xul";

    11 let manifest = { // builtin provider

    12   name: "provider 1",

    13   origin: "https://example.com",

    14   sidebarURL: "https://example.com/browser/browser/base/content/test/social/social_sidebar.html",

    15   workerURL: "https://example.com/browser/browser/base/content/test/social/social_worker.js",

    16   iconURL: "https://example.com/browser/browser/base/content/test/general/moz.png"

    17 };

    18 let manifest2 = { // used for testing install

    19   name: "provider 2",

    20   origin: "https://test1.example.com",

    21   sidebarURL: "https://test1.example.com/browser/browser/base/content/test/social/social_sidebar.html",

    22   workerURL: "https://test1.example.com/browser/browser/base/content/test/social/social_worker.js",

    23   iconURL: "https://test1.example.com/browser/browser/base/content/test/general/moz.png",

    24   version: 1

    25 };

    27 function test() {

    28   waitForExplicitFinish();

    30   let prefname = getManifestPrefname(manifest);

    31   setBuiltinManifestPref(prefname, manifest);

    32   // ensure that manifest2 is NOT showing as builtin

    33   is(SocialService.getOriginActivationType(manifest.origin), "builtin", "manifest is builtin");

    34   is(SocialService.getOriginActivationType(manifest2.origin), "foreign", "manifest2 is not builtin");

    36   Services.prefs.setBoolPref("social.remote-install.enabled", true);

    37   runSocialTests(tests, undefined, undefined, function () {

    38     Services.prefs.clearUserPref("social.remote-install.enabled");

    39     // clear our builtin pref

    40     ok(!Services.prefs.prefHasUserValue(prefname), "manifest is not in user-prefs");

    41     resetBuiltinManifestPref(prefname);

    42     // just in case the tests failed, clear these here as well

    43     Services.prefs.clearUserPref("social.whitelist");

    44     Services.prefs.clearUserPref("social.directories");

    45     finish();

    46   });

    47 }

    49 function installListener(next, aManifest) {

    50   let expectEvent = "onInstalling";

    51   let prefname = getManifestPrefname(aManifest);

    52   // wait for the actual removal to call next

    53   SocialService.registerProviderListener(function providerListener(topic, origin, providers) {

    54     if (topic == "provider-disabled") {

    55       SocialService.unregisterProviderListener(providerListener);

    56       is(origin, aManifest.origin, "provider disabled");

    57       executeSoon(next);

    58     }

    59   });

    61   return {

    62     onInstalling: function(addon) {

    63       is(expectEvent, "onInstalling", "install started");

    64       is(addon.manifest.origin, aManifest.origin, "provider about to be installed");

    65       ok(!Services.prefs.prefHasUserValue(prefname), "manifest is not in user-prefs");

    66       expectEvent = "onInstalled";

    67     },

    68     onInstalled: function(addon) {

    69       is(addon.manifest.origin, aManifest.origin, "provider installed");

    70       ok(addon.installDate.getTime() > 0, "addon has installDate");

    71       ok(addon.updateDate.getTime() > 0, "addon has updateDate");

    72       ok(Services.prefs.prefHasUserValue(prefname), "manifest is in user-prefs");

    73       expectEvent = "onUninstalling";

    74     },

    75     onUninstalling: function(addon) {

    76       is(expectEvent, "onUninstalling", "uninstall started");

    77       is(addon.manifest.origin, aManifest.origin, "provider about to be uninstalled");

    78       ok(Services.prefs.prefHasUserValue(prefname), "manifest is in user-prefs");

    79       expectEvent = "onUninstalled";

    80     },

    81     onUninstalled: function(addon) {

    82       is(expectEvent, "onUninstalled", "provider has been uninstalled");

    83       is(addon.manifest.origin, aManifest.origin, "provider uninstalled");

    84       ok(!Services.prefs.prefHasUserValue(prefname), "manifest is not in user-prefs");

    85       AddonManager.removeAddonListener(this);

    86     }

    87   };

    88 }

    90 var tests = {

    91   testAddonEnableToggle: function(next) {

    92     let expectEvent;

    93     let prefname = getManifestPrefname(manifest);

    94     let listener = {

    95       onEnabled: function(addon) {

    96         is(expectEvent, "onEnabled", "provider onEnabled");

    97         ok(!addon.userDisabled, "provider enabled");

    98         executeSoon(function() {

    99           expectEvent = "onDisabling";

   100           addon.userDisabled = true;

   101         });

   102       },

   103       onEnabling: function(addon) {

   104         is(expectEvent, "onEnabling", "provider onEnabling");

   105         expectEvent = "onEnabled";

   106       },

   107       onDisabled: function(addon) {

   108         is(expectEvent, "onDisabled", "provider onDisabled");

   109         ok(addon.userDisabled, "provider disabled");

   110         AddonManager.removeAddonListener(listener);

   111         // clear the provider user-level pref

   112         Services.prefs.clearUserPref(prefname);

   113         executeSoon(next);

   114       },

   115       onDisabling: function(addon) {

   116         is(expectEvent, "onDisabling", "provider onDisabling");

   117         expectEvent = "onDisabled";

   118       }

   119     };

   120     AddonManager.addAddonListener(listener);

   122     // we're only testing enable disable, so we quickly set the user-level pref

   123     // for this provider and test enable/disable toggling

   124     setManifestPref(prefname, manifest);

   125     ok(Services.prefs.prefHasUserValue(prefname), "manifest is in user-prefs");

   126     AddonManager.getAddonsByTypes([ADDON_TYPE_SERVICE], function(addons) {

   127       for (let addon of addons) {

   128         if (addon.userDisabled) {

   129           expectEvent = "onEnabling";

   130           addon.userDisabled = false;

   131           // only test with one addon

   132           return;

   133         }

   134       }

   135       ok(false, "no addons toggled");

   136       next();

   137     });

   138   },

   139   testProviderEnableToggle: function(next) {

   140     // enable and disabel a provider from the SocialService interface, check

   141     // that the addon manager is updated

   143     let expectEvent;

   144     let prefname = getManifestPrefname(manifest);

   146     let listener = {

   147       onEnabled: function(addon) {

   148         is(expectEvent, "onEnabled", "provider onEnabled");

   149         is(addon.manifest.origin, manifest.origin, "provider enabled");

   150         ok(!addon.userDisabled, "provider !userDisabled");

   151       },

   152       onEnabling: function(addon) {

   153         is(expectEvent, "onEnabling", "provider onEnabling");

   154         is(addon.manifest.origin, manifest.origin, "provider about to be enabled");

   155         expectEvent = "onEnabled";

   156       },

   157       onDisabled: function(addon) {

   158         is(expectEvent, "onDisabled", "provider onDisabled");

   159         is(addon.manifest.origin, manifest.origin, "provider disabled");

   160         ok(addon.userDisabled, "provider userDisabled");

   161       },

   162       onDisabling: function(addon) {

   163         is(expectEvent, "onDisabling", "provider onDisabling");

   164         is(addon.manifest.origin, manifest.origin, "provider about to be disabled");

   165         expectEvent = "onDisabled";

   166       }

   167     };

   168     AddonManager.addAddonListener(listener);

   170     expectEvent = "onEnabling";

   171     setManifestPref(prefname, manifest);

   172     SocialService.addBuiltinProvider(manifest.origin, function(provider) {

   173       expectEvent = "onDisabling";

   174       SocialService.removeProvider(provider.origin, function() {

   175         AddonManager.removeAddonListener(listener);

   176         Services.prefs.clearUserPref(prefname);

   177         next();

   178       });

   179     });

   180   },

   181   testForeignInstall: function(next) {

   182     AddonManager.addAddonListener(installListener(next, manifest2));

   184     // we expect the addon install dialog to appear, we need to accept the

   185     // install from the dialog.

   186     info("Waiting for install dialog");

   187     let panel = document.getElementById("servicesInstall-notification");

   188     PopupNotifications.panel.addEventListener("popupshown", function onpopupshown() {

   189       PopupNotifications.panel.removeEventListener("popupshown", onpopupshown);

   190       info("servicesInstall-notification panel opened");

   191       panel.button.click();

   192     })

   194     let activationURL = manifest2.origin + "/browser/browser/base/content/test/social/social_activate.html"

   195     addTab(activationURL, function(tab) {

   196       let doc = tab.linkedBrowser.contentDocument;

   197       let installFrom = doc.nodePrincipal.origin;

   198       Services.prefs.setCharPref("social.whitelist", "");

   199       is(SocialService.getOriginActivationType(installFrom), "foreign", "testing foriegn install");

   200       Social.installProvider(doc, manifest2, function(addonManifest) {

   201         Services.prefs.clearUserPref("social.whitelist");

   202         SocialService.addBuiltinProvider(addonManifest.origin, function(provider) {

   203           Social.uninstallProvider(addonManifest.origin);

   204           gBrowser.removeTab(tab);

   205         });

   206       });

   207     });

   208   },

   209   testBuiltinInstallWithoutManifest: function(next) {

   210     // send installProvider null for the manifest

   211     AddonManager.addAddonListener(installListener(next, manifest));

   212     let panel = document.getElementById("servicesInstall-notification");

   213     PopupNotifications.panel.addEventListener("popupshown", function onpopupshown() {

   214       PopupNotifications.panel.removeEventListener("popupshown", onpopupshown);

   215       info("servicesInstall-notification panel opened");

   216       panel.button.click();

   217     });

   219     let prefname = getManifestPrefname(manifest);

   220     let activationURL = manifest.origin + "/browser/browser/base/content/test/social/social_activate.html"

   221     addTab(activationURL, function(tab) {

   222       let doc = tab.linkedBrowser.contentDocument;

   223       let installFrom = doc.nodePrincipal.origin;

   224       is(SocialService.getOriginActivationType(installFrom), "builtin", "testing builtin install");

   225       ok(!Services.prefs.prefHasUserValue(prefname), "manifest is not in user-prefs");

   226       Social.installProvider(doc, null, function(addonManifest) {

   227         ok(Services.prefs.prefHasUserValue(prefname), "manifest is in user-prefs");

   228         SocialService.addBuiltinProvider(addonManifest.origin, function(provider) {

   229           Social.uninstallProvider(addonManifest.origin);

   230           gBrowser.removeTab(tab);

   231         });

   232       });

   233     });

   234   },

   235   testBuiltinInstall: function(next) {

   236     // send installProvider a json object for the manifest

   237     AddonManager.addAddonListener(installListener(next, manifest));

   238     let panel = document.getElementById("servicesInstall-notification");

   239     PopupNotifications.panel.addEventListener("popupshown", function onpopupshown() {

   240       PopupNotifications.panel.removeEventListener("popupshown", onpopupshown);

   241       info("servicesInstall-notification panel opened");

   242       panel.button.click();

   243     });

   245     let prefname = getManifestPrefname(manifest);

   246     let activationURL = manifest.origin + "/browser/browser/base/content/test/social/social_activate.html"

   247     addTab(activationURL, function(tab) {

   248       let doc = tab.linkedBrowser.contentDocument;

   249       let installFrom = doc.nodePrincipal.origin;

   250       is(SocialService.getOriginActivationType(installFrom), "builtin", "testing builtin install");

   251       ok(!Services.prefs.prefHasUserValue(prefname), "manifest is not in user-prefs");

   252       Social.installProvider(doc, manifest, function(addonManifest) {

   253         ok(Services.prefs.prefHasUserValue(prefname), "manifest is in user-prefs");

   254         SocialService.addBuiltinProvider(addonManifest.origin, function(provider) {

   255           Social.uninstallProvider(addonManifest.origin);

   256           gBrowser.removeTab(tab);

   257         });

   258       });

   259     });

   260   },

   261   testWhitelistInstall: function(next) {

   262     AddonManager.addAddonListener(installListener(next, manifest2));

   263     let panel = document.getElementById("servicesInstall-notification");

   264     PopupNotifications.panel.addEventListener("popupshown", function onpopupshown() {

   265       PopupNotifications.panel.removeEventListener("popupshown", onpopupshown);

   266       info("servicesInstall-notification panel opened");

   267       panel.button.click();

   268     });

   270     let activationURL = manifest2.origin + "/browser/browser/base/content/test/social/social_activate.html"

   271     addTab(activationURL, function(tab) {

   272       let doc = tab.linkedBrowser.contentDocument;

   273       let installFrom = doc.nodePrincipal.origin;

   274       Services.prefs.setCharPref("social.whitelist", installFrom);

   275       is(SocialService.getOriginActivationType(installFrom), "whitelist", "testing whitelist install");

   276       Social.installProvider(doc, manifest2, function(addonManifest) {

   277         Services.prefs.clearUserPref("social.whitelist");

   278         SocialService.addBuiltinProvider(addonManifest.origin, function(provider) {

   279           Social.uninstallProvider(addonManifest.origin);

   280           gBrowser.removeTab(tab);

   281         });

   282       });

   283     });

   284   },

   285   testDirectoryInstall: function(next) {

   286     AddonManager.addAddonListener(installListener(next, manifest2));

   287     let panel = document.getElementById("servicesInstall-notification");

   288     PopupNotifications.panel.addEventListener("popupshown", function onpopupshown() {

   289       PopupNotifications.panel.removeEventListener("popupshown", onpopupshown);

   290       info("servicesInstall-notification panel opened");

   291       panel.button.click();

   292     });

   294     let activationURL = manifest2.origin + "/browser/browser/base/content/test/social/social_activate.html"

   295     addTab(activationURL, function(tab) {

   296       let doc = tab.linkedBrowser.contentDocument;

   297       let installFrom = doc.nodePrincipal.origin;

   298       Services.prefs.setCharPref("social.directories", installFrom);

   299       is(SocialService.getOriginActivationType(installFrom), "directory", "testing directory install");

   300       Social.installProvider(doc, manifest2, function(addonManifest) {

   301         Services.prefs.clearUserPref("social.directories");

   302         SocialService.addBuiltinProvider(addonManifest.origin, function(provider) {

   303           Social.uninstallProvider(addonManifest.origin);

   304           gBrowser.removeTab(tab);

   305         });

   306       });

   307     });

   308   },

   309   testUpgradeProviderFromWorker: function(next) {

   310     // add the provider, change the pref, add it again. The provider at that

   311     // point should be upgraded

   312     let activationURL = manifest2.origin + "/browser/browser/base/content/test/social/social_activate.html"

   313     let panel = document.getElementById("servicesInstall-notification");

   314     PopupNotifications.panel.addEventListener("popupshown", function onpopupshown() {

   315       PopupNotifications.panel.removeEventListener("popupshown", onpopupshown);

   316       info("servicesInstall-notification panel opened");

   317       panel.button.click();

   318     });

   320     addTab(activationURL, function(tab) {

   321       let doc = tab.linkedBrowser.contentDocument;

   322       let installFrom = doc.nodePrincipal.origin;

   323       Services.prefs.setCharPref("social.whitelist", installFrom);

   324       Social.installProvider(doc, manifest2, function(addonManifest) {

   325         SocialService.addBuiltinProvider(addonManifest.origin, function(provider) {

   326           is(provider.manifest.version, 1, "manifest version is 1");

   328           // watch for the provider-update and test the new version

   329           SocialService.registerProviderListener(function providerListener(topic, origin, providers) {

   330             if (topic != "provider-update")

   331               return;

   332             is(origin, addonManifest.origin, "provider updated")

   333             SocialService.unregisterProviderListener(providerListener);

   334             Services.prefs.clearUserPref("social.whitelist");

   335             let provider = Social._getProviderFromOrigin(origin);

   336             is(provider.manifest.version, 2, "manifest version is 2");

   337             Social.uninstallProvider(origin, function() {

   338               gBrowser.removeTab(tab);

   339               next();

   340             });

   341           });

   343           let port = provider.getWorkerPort();

   344           port.postMessage({topic: "worker.update", data: true});

   346         });

   347       });

   348     });

   349   }

   350 }

The Tor Browser / file revision

browser/base/content/test/social/browser_addons.js@6474c204b198

browser/base/content/test/social/browser_addons.js