The Tor Browser: services/metrics/tests/xpcshell/test_metrics_provider

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 /* Any copyright is dedicated to the Public Domain.

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

     4 "use strict";

     6 const {classes: Cc, interfaces: Ci, utils: Cu} = Components;

     8 Cu.import("resource://gre/modules/Promise.jsm");

     9 Cu.import("resource://gre/modules/Metrics.jsm");

    10 Cu.import("resource://testing-common/services/metrics/mocks.jsm");

    12 const PULL_ONLY_TESTING_CATEGORY = "testing-only-pull-only-providers";

    14 function run_test() {

    15   let cm = Cc["@mozilla.org/categorymanager;1"]

    16              .getService(Ci.nsICategoryManager);

    17   cm.addCategoryEntry(PULL_ONLY_TESTING_CATEGORY, "DummyProvider",

    18                       "resource://testing-common/services/metrics/mocks.jsm",

    19                       false, true);

    20   cm.addCategoryEntry(PULL_ONLY_TESTING_CATEGORY, "DummyConstantProvider",

    21                       "resource://testing-common/services/metrics/mocks.jsm",

    22                       false, true);

    24   run_next_test();

    25 };

    27 add_task(function test_constructor() {

    28   let storage = yield Metrics.Storage("constructor");

    29   let manager = new Metrics.ProviderManager(storage);

    31   yield storage.close();

    32 });

    34 add_task(function test_register_provider() {

    35   let storage = yield Metrics.Storage("register_provider");

    37   let manager = new Metrics.ProviderManager(storage);

    38   let dummy = new DummyProvider();

    40   yield manager.registerProvider(dummy);

    41   do_check_eq(manager._providers.size, 1);

    42   yield manager.registerProvider(dummy);

    43   do_check_eq(manager._providers.size, 1);

    44   do_check_eq(manager.getProvider(dummy.name), dummy);

    46   let failed = false;

    47   try {

    48     manager.registerProvider({});

    49   } catch (ex) {

    50     do_check_true(ex.message.startsWith("Provider is not valid"));

    51     failed = true;

    52   } finally {

    53     do_check_true(failed);

    54     failed = false;

    55   }

    57   manager.unregisterProvider(dummy.name);

    58   do_check_eq(manager._providers.size, 0);

    59   do_check_null(manager.getProvider(dummy.name));

    61   yield storage.close();

    62 });

    64 add_task(function test_register_providers_from_category_manager() {

    65   const category = "metrics-providers-js-modules";

    67   let cm = Cc["@mozilla.org/categorymanager;1"]

    68              .getService(Ci.nsICategoryManager);

    69   cm.addCategoryEntry(category, "DummyProvider",

    70                       "resource://testing-common/services/metrics/mocks.jsm",

    71                       false, true);

    73   let storage = yield Metrics.Storage("register_providers_from_category_manager");

    74   let manager = new Metrics.ProviderManager(storage);

    75   try {

    76     do_check_eq(manager._providers.size, 0);

    77     yield manager.registerProvidersFromCategoryManager(category);

    78     do_check_eq(manager._providers.size, 1);

    79   } finally {

    80     yield storage.close();

    81   }

    82 });

    84 add_task(function test_collect_constant_data() {

    85   let storage = yield Metrics.Storage("collect_constant_data");

    86   let errorCount = 0;

    87   let manager= new Metrics.ProviderManager(storage);

    88   manager.onProviderError = function () { errorCount++; }

    89   let provider = new DummyProvider();

    90   yield manager.registerProvider(provider);

    92   do_check_eq(provider.collectConstantCount, 0);

    94   yield manager.collectConstantData();

    95   do_check_eq(provider.collectConstantCount, 1);

    97   do_check_true(manager._providers.get("DummyProvider").constantsCollected);

    99   yield storage.close();

   100   do_check_eq(errorCount, 0);

   101 });

   103 add_task(function test_collect_constant_throws() {

   104   let storage = yield Metrics.Storage("collect_constant_throws");

   105   let manager = new Metrics.ProviderManager(storage);

   106   let errors = [];

   107   manager.onProviderError = function (error) { errors.push(error); };

   109   let provider = new DummyProvider();

   110   provider.throwDuringCollectConstantData = "Fake error during collect";

   111   yield manager.registerProvider(provider);

   113   yield manager.collectConstantData();

   114   do_check_eq(errors.length, 1);

   115   do_check_true(errors[0].contains(provider.throwDuringCollectConstantData));

   117   yield storage.close();

   118 });

   120 add_task(function test_collect_constant_populate_throws() {

   121   let storage = yield Metrics.Storage("collect_constant_populate_throws");

   122   let manager = new Metrics.ProviderManager(storage);

   123   let errors = [];

   124   manager.onProviderError = function (error) { errors.push(error); };

   126   let provider = new DummyProvider();

   127   provider.throwDuringConstantPopulate = "Fake error during constant populate";

   128   yield manager.registerProvider(provider);

   130   yield manager.collectConstantData();

   132   do_check_eq(errors.length, 1);

   133   do_check_true(errors[0].contains(provider.throwDuringConstantPopulate));

   134   do_check_false(manager._providers.get(provider.name).constantsCollected);

   136   yield storage.close();

   137 });

   139 add_task(function test_collect_constant_onetime() {

   140   let storage = yield Metrics.Storage("collect_constant_onetime");

   141   let manager = new Metrics.ProviderManager(storage);

   142   let provider = new DummyProvider();

   143   yield manager.registerProvider(provider);

   145   yield manager.collectConstantData();

   146   do_check_eq(provider.collectConstantCount, 1);

   148   yield manager.collectConstantData();

   149   do_check_eq(provider.collectConstantCount, 1);

   151   yield storage.close();

   152 });

   154 add_task(function test_collect_multiple() {

   155   let storage = yield Metrics.Storage("collect_multiple");

   156   let manager = new Metrics.ProviderManager(storage);

   158   for (let i = 0; i < 10; i++) {

   159     yield manager.registerProvider(new DummyProvider("provider" + i));

   160   }

   162   do_check_eq(manager._providers.size, 10);

   164   yield manager.collectConstantData();

   166   yield storage.close();

   167 });

   169 add_task(function test_collect_daily() {

   170   let storage = yield Metrics.Storage("collect_daily");

   171   let manager = new Metrics.ProviderManager(storage);

   173   let provider1 = new DummyProvider("DP1");

   174   let provider2 = new DummyProvider("DP2");

   176   yield manager.registerProvider(provider1);

   177   yield manager.registerProvider(provider2);

   179   yield manager.collectDailyData();

   180   do_check_eq(provider1.collectDailyCount, 1);

   181   do_check_eq(provider2.collectDailyCount, 1);

   183   yield manager.collectDailyData();

   184   do_check_eq(provider1.collectDailyCount, 2);

   185   do_check_eq(provider2.collectDailyCount, 2);

   187   yield storage.close();

   188 });

   190 add_task(function test_pull_only_not_initialized() {

   191   let storage = yield Metrics.Storage("pull_only_not_initialized");

   192   let manager = new Metrics.ProviderManager(storage);

   193   yield manager.registerProvidersFromCategoryManager(PULL_ONLY_TESTING_CATEGORY);

   194   do_check_eq(manager.providers.length, 1);

   195   do_check_eq(manager.providers[0].name, "DummyProvider");

   196   yield storage.close();

   197 });

   199 add_task(function test_pull_only_registration() {

   200   let storage = yield Metrics.Storage("pull_only_registration");

   201   let manager = new Metrics.ProviderManager(storage);

   202   yield manager.registerProvidersFromCategoryManager(PULL_ONLY_TESTING_CATEGORY);

   203   do_check_eq(manager.providers.length, 1);

   205   // Simple registration and unregistration.

   206   yield manager.ensurePullOnlyProvidersRegistered();

   207   do_check_eq(manager.providers.length, 2);

   208   do_check_neq(manager.getProvider("DummyConstantProvider"), null);

   209   yield manager.ensurePullOnlyProvidersUnregistered();

   210   do_check_eq(manager.providers.length, 1);

   211   do_check_null(manager.getProvider("DummyConstantProvider"));

   213   // Multiple calls to register work.

   214   yield manager.ensurePullOnlyProvidersRegistered();

   215   do_check_eq(manager.providers.length, 2);

   216   yield manager.ensurePullOnlyProvidersRegistered();

   217   do_check_eq(manager.providers.length, 2);

   219   // Unregister with 2 requests for registration should not unregister.

   220   yield manager.ensurePullOnlyProvidersUnregistered();

   221   do_check_eq(manager.providers.length, 2);

   223   // But the 2nd one will.

   224   yield manager.ensurePullOnlyProvidersUnregistered();

   225   do_check_eq(manager.providers.length, 1);

   227   yield storage.close();

   228 });

   230 add_task(function test_pull_only_register_while_registering() {

   231   let storage = yield Metrics.Storage("pull_only_register_will_registering");

   232   let manager = new Metrics.ProviderManager(storage);

   233   yield manager.registerProvidersFromCategoryManager(PULL_ONLY_TESTING_CATEGORY);

   235   manager.ensurePullOnlyProvidersRegistered();

   236   manager.ensurePullOnlyProvidersRegistered();

   237   yield manager.ensurePullOnlyProvidersRegistered();

   238   do_check_eq(manager.providers.length, 2);

   240   manager.ensurePullOnlyProvidersUnregistered();

   241   manager.ensurePullOnlyProvidersUnregistered();

   242   yield manager.ensurePullOnlyProvidersUnregistered();

   243   do_check_eq(manager.providers.length, 1);

   245   yield storage.close();

   246 });

   248 add_task(function test_pull_only_unregister_while_registering() {

   249   let storage = yield Metrics.Storage("pull_only_unregister_while_registering");

   250   let manager = new Metrics.ProviderManager(storage);

   251   yield manager.registerProvidersFromCategoryManager(PULL_ONLY_TESTING_CATEGORY);

   253   manager.ensurePullOnlyProvidersRegistered();

   254   yield manager.ensurePullOnlyProvidersUnregistered();

   255   do_check_eq(manager.providers.length, 1);

   257   yield storage.close();

   258 });

   260 add_task(function test_pull_only_register_while_unregistering() {

   261   let storage = yield Metrics.Storage("pull_only_register_while_unregistering");

   262   let manager = new Metrics.ProviderManager(storage);

   263   yield manager.registerProvidersFromCategoryManager(PULL_ONLY_TESTING_CATEGORY);

   265   yield manager.ensurePullOnlyProvidersRegistered();

   266   manager.ensurePullOnlyProvidersUnregistered();

   267   yield manager.ensurePullOnlyProvidersRegistered();

   268   do_check_eq(manager.providers.length, 2);

   270   yield storage.close();

   271 });

   273 // Re-use database for perf reasons.

   274 const REGISTRATION_ERRORS_DB = "registration_errors";

   276 add_task(function test_category_manager_registration_error() {

   277   let storage = yield Metrics.Storage(REGISTRATION_ERRORS_DB);

   278   let manager = new Metrics.ProviderManager(storage);

   280   let cm = Cc["@mozilla.org/categorymanager;1"]

   281              .getService(Ci.nsICategoryManager);

   282   cm.addCategoryEntry("registration-errors", "DummyThrowOnInitProvider",

   283                       "resource://testing-common/services/metrics/mocks.jsm",

   284                       false, true);

   286   let deferred = Promise.defer();

   287   let errorCount = 0;

   289   manager.onProviderError = function (msg) {

   290     errorCount++;

   291     deferred.resolve(msg);

   292   };

   294   yield manager.registerProvidersFromCategoryManager("registration-errors");

   295   do_check_eq(manager.providers.length, 0);

   296   do_check_eq(errorCount, 1);

   298   let msg = yield deferred.promise;

   299   do_check_true(msg.contains("Provider error: DummyThrowOnInitProvider: "

   300                              + "Error registering provider from category manager: "

   301                              + "Error: Dummy Error"));

   303   yield storage.close();

   304 });

   306 add_task(function test_pull_only_registration_error() {

   307   let storage = yield Metrics.Storage(REGISTRATION_ERRORS_DB);

   308   let manager = new Metrics.ProviderManager(storage);

   310   let deferred = Promise.defer();

   311   let errorCount = 0;

   313   manager.onProviderError = function (msg) {

   314     errorCount++;

   315     deferred.resolve(msg);

   316   };

   318   yield manager.registerProviderFromType(DummyPullOnlyThrowsOnInitProvider);

   319   do_check_eq(errorCount, 0);

   321   yield manager.ensurePullOnlyProvidersRegistered();

   322   do_check_eq(errorCount, 1);

   324   let msg = yield deferred.promise;

   325   do_check_true(msg.contains("Provider error: DummyPullOnlyThrowsOnInitProvider: " +

   326                              "Error registering pull-only provider: Error: Dummy Error"));

   328   yield storage.close();

   329 });

   331 add_task(function test_error_during_shutdown() {

   332   let storage = yield Metrics.Storage(REGISTRATION_ERRORS_DB);

   333   let manager = new Metrics.ProviderManager(storage);

   335   let deferred = Promise.defer();

   336   let errorCount = 0;

   338   manager.onProviderError = function (msg) {

   339     errorCount++;

   340     deferred.resolve(msg);

   341   };

   343   yield manager.registerProviderFromType(DummyThrowOnShutdownProvider);

   344   yield manager.registerProviderFromType(DummyProvider);

   345   do_check_eq(errorCount, 0);

   346   do_check_eq(manager.providers.length, 1);

   348   yield manager.ensurePullOnlyProvidersRegistered();

   349   do_check_eq(errorCount, 0);

   350   yield manager.ensurePullOnlyProvidersUnregistered();

   351   do_check_eq(errorCount, 1);

   352   let msg = yield deferred.promise;

   353   do_check_true(msg.contains("Provider error: DummyThrowOnShutdownProvider: " +

   354                              "Error when shutting down provider: Error: Dummy shutdown error"));

   356   yield storage.close();

   357 });

The Tor Browser / file revision

services/metrics/tests/xpcshell/test_metrics_provider_manager.js@b8a032363ba2

services/metrics/tests/xpcshell/test_metrics_provider_manager.js