The Tor Browser / file comparison

comparison: services/metrics/tests/xpcshell/test_metrics_provider_manager.js

services/metrics/tests/xpcshell/test_metrics_provider_manager.js

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:51ac18c3ef17
1 /* Any copyright is dedicated to the Public Domain.
2 * http://creativecommons.org/publicdomain/zero/1.0/ */
3
4 "use strict";
5
6 const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
7
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");
11
12 const PULL_ONLY_TESTING_CATEGORY = "testing-only-pull-only-providers";
13
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);
23
24 run_next_test();
25 };
26
27 add_task(function test_constructor() {
28 let storage = yield Metrics.Storage("constructor");
29 let manager = new Metrics.ProviderManager(storage);
30
31 yield storage.close();
32 });
33
34 add_task(function test_register_provider() {
35 let storage = yield Metrics.Storage("register_provider");
36
37 let manager = new Metrics.ProviderManager(storage);
38 let dummy = new DummyProvider();
39
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);
45
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 }
56
57 manager.unregisterProvider(dummy.name);
58 do_check_eq(manager._providers.size, 0);
59 do_check_null(manager.getProvider(dummy.name));
60
61 yield storage.close();
62 });
63
64 add_task(function test_register_providers_from_category_manager() {
65 const category = "metrics-providers-js-modules";
66
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);
72
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 });
83
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);
91
92 do_check_eq(provider.collectConstantCount, 0);
93
94 yield manager.collectConstantData();
95 do_check_eq(provider.collectConstantCount, 1);
96
97 do_check_true(manager._providers.get("DummyProvider").constantsCollected);
98
99 yield storage.close();
100 do_check_eq(errorCount, 0);
101 });
102
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); };
108
109 let provider = new DummyProvider();
110 provider.throwDuringCollectConstantData = "Fake error during collect";
111 yield manager.registerProvider(provider);
112
113 yield manager.collectConstantData();
114 do_check_eq(errors.length, 1);
115 do_check_true(errors[0].contains(provider.throwDuringCollectConstantData));
116
117 yield storage.close();
118 });
119
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); };
125
126 let provider = new DummyProvider();
127 provider.throwDuringConstantPopulate = "Fake error during constant populate";
128 yield manager.registerProvider(provider);
129
130 yield manager.collectConstantData();
131
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);
135
136 yield storage.close();
137 });
138
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);
144
145 yield manager.collectConstantData();
146 do_check_eq(provider.collectConstantCount, 1);
147
148 yield manager.collectConstantData();
149 do_check_eq(provider.collectConstantCount, 1);
150
151 yield storage.close();
152 });
153
154 add_task(function test_collect_multiple() {
155 let storage = yield Metrics.Storage("collect_multiple");
156 let manager = new Metrics.ProviderManager(storage);
157
158 for (let i = 0; i < 10; i++) {
159 yield manager.registerProvider(new DummyProvider("provider" + i));
160 }
161
162 do_check_eq(manager._providers.size, 10);
163
164 yield manager.collectConstantData();
165
166 yield storage.close();
167 });
168
169 add_task(function test_collect_daily() {
170 let storage = yield Metrics.Storage("collect_daily");
171 let manager = new Metrics.ProviderManager(storage);
172
173 let provider1 = new DummyProvider("DP1");
174 let provider2 = new DummyProvider("DP2");
175
176 yield manager.registerProvider(provider1);
177 yield manager.registerProvider(provider2);
178
179 yield manager.collectDailyData();
180 do_check_eq(provider1.collectDailyCount, 1);
181 do_check_eq(provider2.collectDailyCount, 1);
182
183 yield manager.collectDailyData();
184 do_check_eq(provider1.collectDailyCount, 2);
185 do_check_eq(provider2.collectDailyCount, 2);
186
187 yield storage.close();
188 });
189
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 });
198
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);
204
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"));
212
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);
218
219 // Unregister with 2 requests for registration should not unregister.
220 yield manager.ensurePullOnlyProvidersUnregistered();
221 do_check_eq(manager.providers.length, 2);
222
223 // But the 2nd one will.
224 yield manager.ensurePullOnlyProvidersUnregistered();
225 do_check_eq(manager.providers.length, 1);
226
227 yield storage.close();
228 });
229
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);
234
235 manager.ensurePullOnlyProvidersRegistered();
236 manager.ensurePullOnlyProvidersRegistered();
237 yield manager.ensurePullOnlyProvidersRegistered();
238 do_check_eq(manager.providers.length, 2);
239
240 manager.ensurePullOnlyProvidersUnregistered();
241 manager.ensurePullOnlyProvidersUnregistered();
242 yield manager.ensurePullOnlyProvidersUnregistered();
243 do_check_eq(manager.providers.length, 1);
244
245 yield storage.close();
246 });
247
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);
252
253 manager.ensurePullOnlyProvidersRegistered();
254 yield manager.ensurePullOnlyProvidersUnregistered();
255 do_check_eq(manager.providers.length, 1);
256
257 yield storage.close();
258 });
259
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);
264
265 yield manager.ensurePullOnlyProvidersRegistered();
266 manager.ensurePullOnlyProvidersUnregistered();
267 yield manager.ensurePullOnlyProvidersRegistered();
268 do_check_eq(manager.providers.length, 2);
269
270 yield storage.close();
271 });
272
273 // Re-use database for perf reasons.
274 const REGISTRATION_ERRORS_DB = "registration_errors";
275
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);
279
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);
285
286 let deferred = Promise.defer();
287 let errorCount = 0;
288
289 manager.onProviderError = function (msg) {
290 errorCount++;
291 deferred.resolve(msg);
292 };
293
294 yield manager.registerProvidersFromCategoryManager("registration-errors");
295 do_check_eq(manager.providers.length, 0);
296 do_check_eq(errorCount, 1);
297
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"));
302
303 yield storage.close();
304 });
305
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);
309
310 let deferred = Promise.defer();
311 let errorCount = 0;
312
313 manager.onProviderError = function (msg) {
314 errorCount++;
315 deferred.resolve(msg);
316 };
317
318 yield manager.registerProviderFromType(DummyPullOnlyThrowsOnInitProvider);
319 do_check_eq(errorCount, 0);
320
321 yield manager.ensurePullOnlyProvidersRegistered();
322 do_check_eq(errorCount, 1);
323
324 let msg = yield deferred.promise;
325 do_check_true(msg.contains("Provider error: DummyPullOnlyThrowsOnInitProvider: " +
326 "Error registering pull-only provider: Error: Dummy Error"));
327
328 yield storage.close();
329 });
330
331 add_task(function test_error_during_shutdown() {
332 let storage = yield Metrics.Storage(REGISTRATION_ERRORS_DB);
333 let manager = new Metrics.ProviderManager(storage);
334
335 let deferred = Promise.defer();
336 let errorCount = 0;
337
338 manager.onProviderError = function (msg) {
339 errorCount++;
340 deferred.resolve(msg);
341 };
342
343 yield manager.registerProviderFromType(DummyThrowOnShutdownProvider);
344 yield manager.registerProviderFromType(DummyProvider);
345 do_check_eq(errorCount, 0);
346 do_check_eq(manager.providers.length, 1);
347
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"));
355
356 yield storage.close();
357 });

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial