The Tor Browser / file comparison

comparison: services/sync/tests/unit/test_errorhandler.js

services/sync/tests/unit/test_errorhandler.js

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:15a564b525bf
1 /* Any copyright is dedicated to the Public Domain.
2 http://creativecommons.org/publicdomain/zero/1.0/ */
3
4 Cu.import("resource://services-sync/engines/clients.js");
5 Cu.import("resource://services-sync/constants.js");
6 Cu.import("resource://services-sync/engines.js");
7 Cu.import("resource://services-sync/keys.js");
8 Cu.import("resource://services-sync/policies.js");
9 Cu.import("resource://services-sync/service.js");
10 Cu.import("resource://services-sync/status.js");
11 Cu.import("resource://services-sync/util.js");
12 Cu.import("resource://testing-common/services/sync/utils.js");
13 Cu.import("resource://gre/modules/FileUtils.jsm");
14
15 const FAKE_SERVER_URL = "http://dummy:9000/";
16 const logsdir = FileUtils.getDir("ProfD", ["weave", "logs"], true);
17 const LOG_PREFIX_SUCCESS = "success-";
18 const LOG_PREFIX_ERROR = "error-";
19
20 const PROLONGED_ERROR_DURATION =
21 (Svc.Prefs.get('errorhandler.networkFailureReportTimeout') * 2) * 1000;
22
23 const NON_PROLONGED_ERROR_DURATION =
24 (Svc.Prefs.get('errorhandler.networkFailureReportTimeout') / 2) * 1000;
25
26 Service.engineManager.clear();
27
28 function setLastSync(lastSyncValue) {
29 Svc.Prefs.set("lastSync", (new Date(Date.now() - lastSyncValue)).toString());
30 }
31
32 function CatapultEngine() {
33 SyncEngine.call(this, "Catapult", Service);
34 }
35 CatapultEngine.prototype = {
36 __proto__: SyncEngine.prototype,
37 exception: null, // tests fill this in
38 _sync: function _sync() {
39 if (this.exception) {
40 throw this.exception;
41 }
42 }
43 };
44
45 let engineManager = Service.engineManager;
46 engineManager.register(CatapultEngine);
47
48 // This relies on Service/ErrorHandler being a singleton. Fixing this will take
49 // a lot of work.
50 let errorHandler = Service.errorHandler;
51
52 function run_test() {
53 initTestLogging("Trace");
54
55 Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
56 Log.repository.getLogger("Sync.SyncScheduler").level = Log.Level.Trace;
57 Log.repository.getLogger("Sync.ErrorHandler").level = Log.Level.Trace;
58
59 ensureLegacyIdentityManager();
60
61 run_next_test();
62 }
63
64 function generateCredentialsChangedFailure() {
65 // Make sync fail due to changed credentials. We simply re-encrypt
66 // the keys with a different Sync Key, without changing the local one.
67 let newSyncKeyBundle = new SyncKeyBundle("johndoe", "23456234562345623456234562");
68 let keys = Service.collectionKeys.asWBO();
69 keys.encrypt(newSyncKeyBundle);
70 keys.upload(Service.resource(Service.cryptoKeysURL));
71 }
72
73 function service_unavailable(request, response) {
74 let body = "Service Unavailable";
75 response.setStatusLine(request.httpVersion, 503, "Service Unavailable");
76 response.setHeader("Retry-After", "42");
77 response.bodyOutputStream.write(body, body.length);
78 }
79
80 function sync_httpd_setup() {
81 let global = new ServerWBO("global", {
82 syncID: Service.syncID,
83 storageVersion: STORAGE_VERSION,
84 engines: {clients: {version: Service.clientsEngine.version,
85 syncID: Service.clientsEngine.syncID},
86 catapult: {version: engineManager.get("catapult").version,
87 syncID: engineManager.get("catapult").syncID}}
88 });
89 let clientsColl = new ServerCollection({}, true);
90
91 // Tracking info/collections.
92 let collectionsHelper = track_collections_helper();
93 let upd = collectionsHelper.with_updated_collection;
94
95 let handler_401 = httpd_handler(401, "Unauthorized");
96 return httpd_setup({
97 // Normal server behaviour.
98 "/1.1/johndoe/storage/meta/global": upd("meta", global.handler()),
99 "/1.1/johndoe/info/collections": collectionsHelper.handler,
100 "/1.1/johndoe/storage/crypto/keys":
101 upd("crypto", (new ServerWBO("keys")).handler()),
102 "/1.1/johndoe/storage/clients": upd("clients", clientsColl.handler()),
103
104 // Credentials are wrong or node reallocated.
105 "/1.1/janedoe/storage/meta/global": handler_401,
106 "/1.1/janedoe/info/collections": handler_401,
107
108 // Maintenance or overloaded (503 + Retry-After) at info/collections.
109 "/maintenance/1.1/broken.info/info/collections": service_unavailable,
110
111 // Maintenance or overloaded (503 + Retry-After) at meta/global.
112 "/maintenance/1.1/broken.meta/storage/meta/global": service_unavailable,
113 "/maintenance/1.1/broken.meta/info/collections": collectionsHelper.handler,
114
115 // Maintenance or overloaded (503 + Retry-After) at crypto/keys.
116 "/maintenance/1.1/broken.keys/storage/meta/global": upd("meta", global.handler()),
117 "/maintenance/1.1/broken.keys/info/collections": collectionsHelper.handler,
118 "/maintenance/1.1/broken.keys/storage/crypto/keys": service_unavailable,
119
120 // Maintenance or overloaded (503 + Retry-After) at wiping collection.
121 "/maintenance/1.1/broken.wipe/info/collections": collectionsHelper.handler,
122 "/maintenance/1.1/broken.wipe/storage/meta/global": upd("meta", global.handler()),
123 "/maintenance/1.1/broken.wipe/storage/crypto/keys":
124 upd("crypto", (new ServerWBO("keys")).handler()),
125 "/maintenance/1.1/broken.wipe/storage": service_unavailable,
126 "/maintenance/1.1/broken.wipe/storage/clients": upd("clients", clientsColl.handler()),
127 "/maintenance/1.1/broken.wipe/storage/catapult": service_unavailable
128 });
129 }
130
131 function setUp(server) {
132 return configureIdentity({username: "johndoe"}).then(
133 () => {
134 Service.serverURL = server.baseURI + "/";
135 Service.clusterURL = server.baseURI + "/";
136 }
137 ).then(
138 () => generateAndUploadKeys()
139 );
140 }
141
142 function generateAndUploadKeys() {
143 generateNewKeys(Service.collectionKeys);
144 let serverKeys = Service.collectionKeys.asWBO("crypto", "keys");
145 serverKeys.encrypt(Service.identity.syncKeyBundle);
146 return serverKeys.upload(Service.resource(Service.cryptoKeysURL)).success;
147 }
148
149 function clean() {
150 Service.startOver();
151 Status.resetSync();
152 Status.resetBackoff();
153 errorHandler.didReportProlongedError = false;
154 }
155
156 add_identity_test(this, function test_401_logout() {
157 let server = sync_httpd_setup();
158 yield setUp(server);
159
160 // By calling sync, we ensure we're logged in.
161 Service.sync();
162 do_check_eq(Status.sync, SYNC_SUCCEEDED);
163 do_check_true(Service.isLoggedIn);
164
165 let deferred = Promise.defer();
166 Svc.Obs.add("weave:service:sync:error", onSyncError);
167 function onSyncError() {
168 _("Got weave:service:sync:error in first sync.");
169 Svc.Obs.remove("weave:service:sync:error", onSyncError);
170
171 // Wait for the automatic next sync.
172 function onLoginError() {
173 _("Got weave:service:login:error in second sync.");
174 Svc.Obs.remove("weave:service:login:error", onLoginError);
175
176 do_check_eq(Status.login, LOGIN_FAILED_LOGIN_REJECTED);
177 do_check_false(Service.isLoggedIn);
178
179 // Clean up.
180 Utils.nextTick(function () {
181 Service.startOver();
182 server.stop(deferred.resolve);
183 });
184 }
185 Svc.Obs.add("weave:service:login:error", onLoginError);
186 }
187
188 // Make sync fail due to login rejected.
189 yield configureIdentity({username: "janedoe"});
190 Service._updateCachedURLs();
191
192 _("Starting first sync.");
193 Service.sync();
194 _("First sync done.");
195 yield deferred.promise;
196 });
197
198 add_identity_test(this, function test_credentials_changed_logout() {
199 let server = sync_httpd_setup();
200 yield setUp(server);
201
202 // By calling sync, we ensure we're logged in.
203 Service.sync();
204 do_check_eq(Status.sync, SYNC_SUCCEEDED);
205 do_check_true(Service.isLoggedIn);
206
207 generateCredentialsChangedFailure();
208 Service.sync();
209
210 do_check_eq(Status.sync, CREDENTIALS_CHANGED);
211 do_check_false(Service.isLoggedIn);
212
213 // Clean up.
214 Service.startOver();
215 let deferred = Promise.defer();
216 server.stop(deferred.resolve);
217 yield deferred.promise;
218 });
219
220 add_identity_test(this, function test_no_lastSync_pref() {
221 // Test reported error.
222 Status.resetSync();
223 errorHandler.dontIgnoreErrors = true;
224 Status.sync = CREDENTIALS_CHANGED;
225 do_check_true(errorHandler.shouldReportError());
226
227 // Test unreported error.
228 Status.resetSync();
229 errorHandler.dontIgnoreErrors = true;
230 Status.login = LOGIN_FAILED_NETWORK_ERROR;
231 do_check_true(errorHandler.shouldReportError());
232
233 });
234
235 add_identity_test(this, function test_shouldReportError() {
236 Status.login = MASTER_PASSWORD_LOCKED;
237 do_check_false(errorHandler.shouldReportError());
238
239 // Give ourselves a clusterURL so that the temporary 401 no-error situation
240 // doesn't come into play.
241 Service.serverURL = FAKE_SERVER_URL;
242 Service.clusterURL = FAKE_SERVER_URL;
243
244 // Test dontIgnoreErrors, non-network, non-prolonged, login error reported
245 Status.resetSync();
246 setLastSync(NON_PROLONGED_ERROR_DURATION);
247 errorHandler.dontIgnoreErrors = true;
248 Status.login = LOGIN_FAILED_NO_PASSWORD;
249 do_check_true(errorHandler.shouldReportError());
250
251 // Test dontIgnoreErrors, non-network, non-prolonged, sync error reported
252 Status.resetSync();
253 setLastSync(NON_PROLONGED_ERROR_DURATION);
254 errorHandler.dontIgnoreErrors = true;
255 Status.sync = CREDENTIALS_CHANGED;
256 do_check_true(errorHandler.shouldReportError());
257
258 // Test dontIgnoreErrors, non-network, prolonged, login error reported
259 Status.resetSync();
260 setLastSync(PROLONGED_ERROR_DURATION);
261 errorHandler.dontIgnoreErrors = true;
262 Status.login = LOGIN_FAILED_NO_PASSWORD;
263 do_check_true(errorHandler.shouldReportError());
264
265 // Test dontIgnoreErrors, non-network, prolonged, sync error reported
266 Status.resetSync();
267 setLastSync(PROLONGED_ERROR_DURATION);
268 errorHandler.dontIgnoreErrors = true;
269 Status.sync = CREDENTIALS_CHANGED;
270 do_check_true(errorHandler.shouldReportError());
271
272 // Test dontIgnoreErrors, network, non-prolonged, login error reported
273 Status.resetSync();
274 setLastSync(NON_PROLONGED_ERROR_DURATION);
275 errorHandler.dontIgnoreErrors = true;
276 Status.login = LOGIN_FAILED_NETWORK_ERROR;
277 do_check_true(errorHandler.shouldReportError());
278
279 // Test dontIgnoreErrors, network, non-prolonged, sync error reported
280 Status.resetSync();
281 setLastSync(NON_PROLONGED_ERROR_DURATION);
282 errorHandler.dontIgnoreErrors = true;
283 Status.sync = LOGIN_FAILED_NETWORK_ERROR;
284 do_check_true(errorHandler.shouldReportError());
285
286 // Test dontIgnoreErrors, network, prolonged, login error reported
287 Status.resetSync();
288 setLastSync(PROLONGED_ERROR_DURATION);
289 errorHandler.dontIgnoreErrors = true;
290 Status.login = LOGIN_FAILED_NETWORK_ERROR;
291 do_check_true(errorHandler.shouldReportError());
292
293 // Test dontIgnoreErrors, network, prolonged, sync error reported
294 Status.resetSync();
295 setLastSync(PROLONGED_ERROR_DURATION);
296 errorHandler.dontIgnoreErrors = true;
297 Status.sync = LOGIN_FAILED_NETWORK_ERROR;
298 do_check_true(errorHandler.shouldReportError());
299
300 // Test non-network, prolonged, login error reported
301 do_check_false(errorHandler.didReportProlongedError);
302 Status.resetSync();
303 setLastSync(PROLONGED_ERROR_DURATION);
304 errorHandler.dontIgnoreErrors = false;
305 Status.login = LOGIN_FAILED_NO_PASSWORD;
306 do_check_true(errorHandler.shouldReportError());
307 do_check_true(errorHandler.didReportProlongedError);
308
309 // Second time with prolonged error and without resetting
310 // didReportProlongedError, sync error should not be reported.
311 Status.resetSync();
312 setLastSync(PROLONGED_ERROR_DURATION);
313 errorHandler.dontIgnoreErrors = false;
314 Status.login = LOGIN_FAILED_NO_PASSWORD;
315 do_check_false(errorHandler.shouldReportError());
316 do_check_true(errorHandler.didReportProlongedError);
317
318 // Test non-network, prolonged, sync error reported
319 Status.resetSync();
320 setLastSync(PROLONGED_ERROR_DURATION);
321 errorHandler.dontIgnoreErrors = false;
322 errorHandler.didReportProlongedError = false;
323 Status.sync = CREDENTIALS_CHANGED;
324 do_check_true(errorHandler.shouldReportError());
325 do_check_true(errorHandler.didReportProlongedError);
326 errorHandler.didReportProlongedError = false;
327
328 // Test network, prolonged, login error reported
329 Status.resetSync();
330 setLastSync(PROLONGED_ERROR_DURATION);
331 errorHandler.dontIgnoreErrors = false;
332 Status.login = LOGIN_FAILED_NETWORK_ERROR;
333 do_check_true(errorHandler.shouldReportError());
334 do_check_true(errorHandler.didReportProlongedError);
335 errorHandler.didReportProlongedError = false;
336
337 // Test network, prolonged, sync error reported
338 Status.resetSync();
339 setLastSync(PROLONGED_ERROR_DURATION);
340 errorHandler.dontIgnoreErrors = false;
341 Status.sync = LOGIN_FAILED_NETWORK_ERROR;
342 do_check_true(errorHandler.shouldReportError());
343 do_check_true(errorHandler.didReportProlongedError);
344 errorHandler.didReportProlongedError = false;
345
346 // Test non-network, non-prolonged, login error reported
347 Status.resetSync();
348 setLastSync(NON_PROLONGED_ERROR_DURATION);
349 errorHandler.dontIgnoreErrors = false;
350 Status.login = LOGIN_FAILED_NO_PASSWORD;
351 do_check_true(errorHandler.shouldReportError());
352 do_check_false(errorHandler.didReportProlongedError);
353
354 // Test non-network, non-prolonged, sync error reported
355 Status.resetSync();
356 setLastSync(NON_PROLONGED_ERROR_DURATION);
357 errorHandler.dontIgnoreErrors = false;
358 Status.sync = CREDENTIALS_CHANGED;
359 do_check_true(errorHandler.shouldReportError());
360 do_check_false(errorHandler.didReportProlongedError);
361
362 // Test network, non-prolonged, login error reported
363 Status.resetSync();
364 setLastSync(NON_PROLONGED_ERROR_DURATION);
365 errorHandler.dontIgnoreErrors = false;
366 Status.login = LOGIN_FAILED_NETWORK_ERROR;
367 do_check_false(errorHandler.shouldReportError());
368 do_check_false(errorHandler.didReportProlongedError);
369
370 // Test network, non-prolonged, sync error reported
371 Status.resetSync();
372 setLastSync(NON_PROLONGED_ERROR_DURATION);
373 errorHandler.dontIgnoreErrors = false;
374 Status.sync = LOGIN_FAILED_NETWORK_ERROR;
375 do_check_false(errorHandler.shouldReportError());
376 do_check_false(errorHandler.didReportProlongedError);
377
378 // Test server maintenance, sync errors are not reported
379 Status.resetSync();
380 setLastSync(NON_PROLONGED_ERROR_DURATION);
381 errorHandler.dontIgnoreErrors = false;
382 Status.sync = SERVER_MAINTENANCE;
383 do_check_false(errorHandler.shouldReportError());
384 do_check_false(errorHandler.didReportProlongedError);
385
386 // Test server maintenance, login errors are not reported
387 Status.resetSync();
388 setLastSync(NON_PROLONGED_ERROR_DURATION);
389 errorHandler.dontIgnoreErrors = false;
390 Status.login = SERVER_MAINTENANCE;
391 do_check_false(errorHandler.shouldReportError());
392 do_check_false(errorHandler.didReportProlongedError);
393
394 // Test prolonged, server maintenance, sync errors are reported
395 Status.resetSync();
396 setLastSync(PROLONGED_ERROR_DURATION);
397 errorHandler.dontIgnoreErrors = false;
398 Status.sync = SERVER_MAINTENANCE;
399 do_check_true(errorHandler.shouldReportError());
400 do_check_true(errorHandler.didReportProlongedError);
401 errorHandler.didReportProlongedError = false;
402
403 // Test prolonged, server maintenance, login errors are reported
404 Status.resetSync();
405 setLastSync(PROLONGED_ERROR_DURATION);
406 errorHandler.dontIgnoreErrors = false;
407 Status.login = SERVER_MAINTENANCE;
408 do_check_true(errorHandler.shouldReportError());
409 do_check_true(errorHandler.didReportProlongedError);
410 errorHandler.didReportProlongedError = false;
411
412 // Test dontIgnoreErrors, server maintenance, sync errors are reported
413 Status.resetSync();
414 setLastSync(NON_PROLONGED_ERROR_DURATION);
415 errorHandler.dontIgnoreErrors = true;
416 Status.sync = SERVER_MAINTENANCE;
417 do_check_true(errorHandler.shouldReportError());
418 // dontIgnoreErrors means we don't set didReportProlongedError
419 do_check_false(errorHandler.didReportProlongedError);
420
421 // Test dontIgnoreErrors, server maintenance, login errors are reported
422 Status.resetSync();
423 setLastSync(NON_PROLONGED_ERROR_DURATION);
424 errorHandler.dontIgnoreErrors = true;
425 Status.login = SERVER_MAINTENANCE;
426 do_check_true(errorHandler.shouldReportError());
427 do_check_false(errorHandler.didReportProlongedError);
428
429 // Test dontIgnoreErrors, prolonged, server maintenance,
430 // sync errors are reported
431 Status.resetSync();
432 setLastSync(PROLONGED_ERROR_DURATION);
433 errorHandler.dontIgnoreErrors = true;
434 Status.sync = SERVER_MAINTENANCE;
435 do_check_true(errorHandler.shouldReportError());
436 do_check_false(errorHandler.didReportProlongedError);
437
438 // Test dontIgnoreErrors, prolonged, server maintenance,
439 // login errors are reported
440 Status.resetSync();
441 setLastSync(PROLONGED_ERROR_DURATION);
442 errorHandler.dontIgnoreErrors = true;
443 Status.login = SERVER_MAINTENANCE;
444 do_check_true(errorHandler.shouldReportError());
445 do_check_false(errorHandler.didReportProlongedError);
446 });
447
448 add_identity_test(this, function test_shouldReportError_master_password() {
449 _("Test error ignored due to locked master password");
450 let server = sync_httpd_setup();
451 yield setUp(server);
452
453 // Monkey patch Service.verifyLogin to imitate
454 // master password being locked.
455 Service._verifyLogin = Service.verifyLogin;
456 Service.verifyLogin = function () {
457 Status.login = MASTER_PASSWORD_LOCKED;
458 return false;
459 };
460
461 setLastSync(NON_PROLONGED_ERROR_DURATION);
462 Service.sync();
463 do_check_false(errorHandler.shouldReportError());
464
465 // Clean up.
466 Service.verifyLogin = Service._verifyLogin;
467 clean();
468 let deferred = Promise.defer();
469 server.stop(deferred.resolve);
470 yield deferred.promise;
471 });
472
473 // XXX - how to arrange for 'Service.identity.basicPassword = null;' in
474 // an fxaccounts environment?
475 add_task(function test_login_syncAndReportErrors_non_network_error() {
476 // Test non-network errors are reported
477 // when calling syncAndReportErrors
478 let server = sync_httpd_setup();
479 yield setUp(server);
480 Service.identity.basicPassword = null;
481
482 let deferred = Promise.defer();
483 Svc.Obs.add("weave:ui:login:error", function onSyncError() {
484 Svc.Obs.remove("weave:ui:login:error", onSyncError);
485 do_check_eq(Status.login, LOGIN_FAILED_NO_PASSWORD);
486
487 clean();
488 server.stop(deferred.resolve);
489 });
490
491 setLastSync(NON_PROLONGED_ERROR_DURATION);
492 errorHandler.syncAndReportErrors();
493 yield deferred.promise;
494 });
495
496 add_identity_test(this, function test_sync_syncAndReportErrors_non_network_error() {
497 // Test non-network errors are reported
498 // when calling syncAndReportErrors
499 let server = sync_httpd_setup();
500 yield setUp(server);
501
502 // By calling sync, we ensure we're logged in.
503 Service.sync();
504 do_check_eq(Status.sync, SYNC_SUCCEEDED);
505 do_check_true(Service.isLoggedIn);
506
507 generateCredentialsChangedFailure();
508
509 let deferred = Promise.defer();
510 Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
511 Svc.Obs.remove("weave:ui:sync:error", onSyncError);
512 do_check_eq(Status.sync, CREDENTIALS_CHANGED);
513
514 clean();
515 server.stop(deferred.resolve);
516 });
517
518 setLastSync(NON_PROLONGED_ERROR_DURATION);
519 errorHandler.syncAndReportErrors();
520 yield deferred.promise;
521 });
522
523 // XXX - how to arrange for 'Service.identity.basicPassword = null;' in
524 // an fxaccounts environment?
525 add_task(function test_login_syncAndReportErrors_prolonged_non_network_error() {
526 // Test prolonged, non-network errors are
527 // reported when calling syncAndReportErrors.
528 let server = sync_httpd_setup();
529 yield setUp(server);
530 Service.identity.basicPassword = null;
531
532 let deferred = Promise.defer();
533 Svc.Obs.add("weave:ui:login:error", function onSyncError() {
534 Svc.Obs.remove("weave:ui:login:error", onSyncError);
535 do_check_eq(Status.login, LOGIN_FAILED_NO_PASSWORD);
536
537 clean();
538 server.stop(deferred.resolve);
539 });
540
541 setLastSync(PROLONGED_ERROR_DURATION);
542 errorHandler.syncAndReportErrors();
543 yield deferred.promise;
544 });
545
546 add_identity_test(this, function test_sync_syncAndReportErrors_prolonged_non_network_error() {
547 // Test prolonged, non-network errors are
548 // reported when calling syncAndReportErrors.
549 let server = sync_httpd_setup();
550 yield setUp(server);
551
552 // By calling sync, we ensure we're logged in.
553 Service.sync();
554 do_check_eq(Status.sync, SYNC_SUCCEEDED);
555 do_check_true(Service.isLoggedIn);
556
557 generateCredentialsChangedFailure();
558
559 let deferred = Promise.defer();
560 Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
561 Svc.Obs.remove("weave:ui:sync:error", onSyncError);
562 do_check_eq(Status.sync, CREDENTIALS_CHANGED);
563
564 clean();
565 server.stop(deferred.resolve);
566 });
567
568 setLastSync(PROLONGED_ERROR_DURATION);
569 errorHandler.syncAndReportErrors();
570 yield deferred.promise;
571 });
572
573 add_identity_test(this, function test_login_syncAndReportErrors_network_error() {
574 // Test network errors are reported when calling syncAndReportErrors.
575 yield configureIdentity({username: "broken.wipe"});
576 Service.serverURL = FAKE_SERVER_URL;
577 Service.clusterURL = FAKE_SERVER_URL;
578
579 let deferred = Promise.defer();
580 Svc.Obs.add("weave:ui:login:error", function onSyncError() {
581 Svc.Obs.remove("weave:ui:login:error", onSyncError);
582 do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
583
584 clean();
585 deferred.resolve();
586 });
587
588 setLastSync(NON_PROLONGED_ERROR_DURATION);
589 errorHandler.syncAndReportErrors();
590 yield deferred.promise;
591 });
592
593
594 add_test(function test_sync_syncAndReportErrors_network_error() {
595 // Test network errors are reported when calling syncAndReportErrors.
596 Services.io.offline = true;
597
598 Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
599 Svc.Obs.remove("weave:ui:sync:error", onSyncError);
600 do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
601
602 Services.io.offline = false;
603 clean();
604 run_next_test();
605 });
606
607 setLastSync(NON_PROLONGED_ERROR_DURATION);
608 errorHandler.syncAndReportErrors();
609 });
610
611 add_identity_test(this, function test_login_syncAndReportErrors_prolonged_network_error() {
612 // Test prolonged, network errors are reported
613 // when calling syncAndReportErrors.
614 yield configureIdentity({username: "johndoe"});
615
616 Service.serverURL = FAKE_SERVER_URL;
617 Service.clusterURL = FAKE_SERVER_URL;
618
619 let deferred = Promise.defer();
620 Svc.Obs.add("weave:ui:login:error", function onSyncError() {
621 Svc.Obs.remove("weave:ui:login:error", onSyncError);
622 do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
623
624 clean();
625 deferred.resolve();
626 });
627
628 setLastSync(PROLONGED_ERROR_DURATION);
629 errorHandler.syncAndReportErrors();
630 yield deferred.promise;
631 });
632
633 add_test(function test_sync_syncAndReportErrors_prolonged_network_error() {
634 // Test prolonged, network errors are reported
635 // when calling syncAndReportErrors.
636 Services.io.offline = true;
637
638 Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
639 Svc.Obs.remove("weave:ui:sync:error", onSyncError);
640 do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
641
642 Services.io.offline = false;
643 clean();
644 run_next_test();
645 });
646
647 setLastSync(PROLONGED_ERROR_DURATION);
648 errorHandler.syncAndReportErrors();
649 });
650
651 add_task(function test_login_prolonged_non_network_error() {
652 // Test prolonged, non-network errors are reported
653 let server = sync_httpd_setup();
654 yield setUp(server);
655 Service.identity.basicPassword = null;
656
657 let deferred = Promise.defer();
658 Svc.Obs.add("weave:ui:login:error", function onSyncError() {
659 Svc.Obs.remove("weave:ui:login:error", onSyncError);
660 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
661 do_check_true(errorHandler.didReportProlongedError);
662
663 clean();
664 server.stop(deferred.resolve);
665 });
666
667 setLastSync(PROLONGED_ERROR_DURATION);
668 Service.sync();
669 yield deferred.promise;
670 });
671
672 add_task(function test_sync_prolonged_non_network_error() {
673 // Test prolonged, non-network errors are reported
674 let server = sync_httpd_setup();
675 yield setUp(server);
676
677 // By calling sync, we ensure we're logged in.
678 Service.sync();
679 do_check_eq(Status.sync, SYNC_SUCCEEDED);
680 do_check_true(Service.isLoggedIn);
681
682 generateCredentialsChangedFailure();
683
684 let deferred = Promise.defer();
685 Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
686 Svc.Obs.remove("weave:ui:sync:error", onSyncError);
687 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
688 do_check_true(errorHandler.didReportProlongedError);
689
690 clean();
691 server.stop(deferred.resolve);
692 });
693
694 setLastSync(PROLONGED_ERROR_DURATION);
695 Service.sync();
696 yield deferred.promise;
697 });
698
699 add_identity_test(this, function test_login_prolonged_network_error() {
700 // Test prolonged, network errors are reported
701 yield configureIdentity({username: "johndoe"});
702 Service.serverURL = FAKE_SERVER_URL;
703 Service.clusterURL = FAKE_SERVER_URL;
704
705 let deferred = Promise.defer();
706 Svc.Obs.add("weave:ui:login:error", function onSyncError() {
707 Svc.Obs.remove("weave:ui:login:error", onSyncError);
708 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
709 do_check_true(errorHandler.didReportProlongedError);
710
711 clean();
712 deferred.resolve();
713 });
714
715 setLastSync(PROLONGED_ERROR_DURATION);
716 Service.sync();
717 yield deferred.promise;
718 });
719
720 add_test(function test_sync_prolonged_network_error() {
721 // Test prolonged, network errors are reported
722 Services.io.offline = true;
723
724 Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
725 Svc.Obs.remove("weave:ui:sync:error", onSyncError);
726 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
727 do_check_true(errorHandler.didReportProlongedError);
728
729 Services.io.offline = false;
730 clean();
731 run_next_test();
732 });
733
734 setLastSync(PROLONGED_ERROR_DURATION);
735 Service.sync();
736 });
737
738 add_task(function test_login_non_network_error() {
739 // Test non-network errors are reported
740 let server = sync_httpd_setup();
741 yield setUp(server);
742 Service.identity.basicPassword = null;
743
744 let deferred = Promise.defer();
745 Svc.Obs.add("weave:ui:login:error", function onSyncError() {
746 Svc.Obs.remove("weave:ui:login:error", onSyncError);
747 do_check_eq(Status.login, LOGIN_FAILED_NO_PASSWORD);
748 do_check_false(errorHandler.didReportProlongedError);
749
750 clean();
751 server.stop(deferred.resolve);
752 });
753
754 setLastSync(NON_PROLONGED_ERROR_DURATION);
755 Service.sync();
756 yield deferred.promise;
757 });
758
759 add_task(function test_sync_non_network_error() {
760 // Test non-network errors are reported
761 let server = sync_httpd_setup();
762 yield setUp(server);
763
764 // By calling sync, we ensure we're logged in.
765 Service.sync();
766 do_check_eq(Status.sync, SYNC_SUCCEEDED);
767 do_check_true(Service.isLoggedIn);
768
769 generateCredentialsChangedFailure();
770
771 let deferred = Promise.defer();
772 Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
773 Svc.Obs.remove("weave:ui:sync:error", onSyncError);
774 do_check_eq(Status.sync, CREDENTIALS_CHANGED);
775 do_check_false(errorHandler.didReportProlongedError);
776
777 clean();
778 server.stop(deferred.resolve);
779 });
780
781 setLastSync(NON_PROLONGED_ERROR_DURATION);
782 Service.sync();
783 yield deferred.promise;
784 });
785
786 add_identity_test(this, function test_login_network_error() {
787 yield configureIdentity({username: "johndoe"});
788 Service.serverURL = FAKE_SERVER_URL;
789 Service.clusterURL = FAKE_SERVER_URL;
790
791 let deferred = Promise.defer();
792 // Test network errors are not reported.
793 Svc.Obs.add("weave:ui:clear-error", function onClearError() {
794 Svc.Obs.remove("weave:ui:clear-error", onClearError);
795
796 do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
797 do_check_false(errorHandler.didReportProlongedError);
798
799 Services.io.offline = false;
800 clean();
801 deferred.resolve()
802 });
803
804 setLastSync(NON_PROLONGED_ERROR_DURATION);
805 Service.sync();
806 yield deferred.promise;
807 });
808
809 add_test(function test_sync_network_error() {
810 // Test network errors are not reported.
811 Services.io.offline = true;
812
813 Svc.Obs.add("weave:ui:sync:finish", function onUIUpdate() {
814 Svc.Obs.remove("weave:ui:sync:finish", onUIUpdate);
815 do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
816 do_check_false(errorHandler.didReportProlongedError);
817
818 Services.io.offline = false;
819 clean();
820 run_next_test();
821 });
822
823 setLastSync(NON_PROLONGED_ERROR_DURATION);
824 Service.sync();
825 });
826
827 add_identity_test(this, function test_sync_server_maintenance_error() {
828 // Test server maintenance errors are not reported.
829 let server = sync_httpd_setup();
830 yield setUp(server);
831
832 const BACKOFF = 42;
833 let engine = engineManager.get("catapult");
834 engine.enabled = true;
835 engine.exception = {status: 503,
836 headers: {"retry-after": BACKOFF}};
837
838 function onSyncError() {
839 do_throw("Shouldn't get here!");
840 }
841 Svc.Obs.add("weave:ui:sync:error", onSyncError);
842
843 do_check_eq(Status.service, STATUS_OK);
844
845 let deferred = Promise.defer();
846 Svc.Obs.add("weave:ui:sync:finish", function onSyncFinish() {
847 Svc.Obs.remove("weave:ui:sync:finish", onSyncFinish);
848
849 do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
850 do_check_eq(Status.sync, SERVER_MAINTENANCE);
851 do_check_false(errorHandler.didReportProlongedError);
852
853 Svc.Obs.remove("weave:ui:sync:error", onSyncError);
854 clean();
855 server.stop(deferred.resolve);
856 });
857
858 setLastSync(NON_PROLONGED_ERROR_DURATION);
859 Service.sync();
860 yield deferred.promise;
861 });
862
863 add_identity_test(this, function test_info_collections_login_server_maintenance_error() {
864 // Test info/collections server maintenance errors are not reported.
865 let server = sync_httpd_setup();
866 yield setUp(server);
867
868 Service.username = "broken.info";
869 yield configureIdentity({username: "broken.info"});
870 Service.serverURL = server.baseURI + "/maintenance/";
871 Service.clusterURL = server.baseURI + "/maintenance/";
872
873 let backoffInterval;
874 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
875 Svc.Obs.remove("weave:service:backoff:interval", observe);
876 backoffInterval = subject;
877 });
878
879 function onUIUpdate() {
880 do_throw("Shouldn't experience UI update!");
881 }
882 Svc.Obs.add("weave:ui:login:error", onUIUpdate);
883
884 do_check_false(Status.enforceBackoff);
885 do_check_eq(Status.service, STATUS_OK);
886
887 let deferred = Promise.defer();
888 Svc.Obs.add("weave:ui:clear-error", function onLoginFinish() {
889 Svc.Obs.remove("weave:ui:clear-error", onLoginFinish);
890
891 do_check_true(Status.enforceBackoff);
892 do_check_eq(backoffInterval, 42);
893 do_check_eq(Status.service, LOGIN_FAILED);
894 do_check_eq(Status.login, SERVER_MAINTENANCE);
895 do_check_false(errorHandler.didReportProlongedError);
896
897 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
898 clean();
899 server.stop(deferred.resolve);
900 });
901
902 setLastSync(NON_PROLONGED_ERROR_DURATION);
903 Service.sync();
904 yield deferred.promise;
905 });
906
907 add_identity_test(this, function test_meta_global_login_server_maintenance_error() {
908 // Test meta/global server maintenance errors are not reported.
909 let server = sync_httpd_setup();
910 yield setUp(server);
911
912 yield configureIdentity({username: "broken.meta"});
913 Service.serverURL = server.baseURI + "/maintenance/";
914 Service.clusterURL = server.baseURI + "/maintenance/";
915
916 let backoffInterval;
917 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
918 Svc.Obs.remove("weave:service:backoff:interval", observe);
919 backoffInterval = subject;
920 });
921
922 function onUIUpdate() {
923 do_throw("Shouldn't get here!");
924 }
925 Svc.Obs.add("weave:ui:login:error", onUIUpdate);
926
927 do_check_false(Status.enforceBackoff);
928 do_check_eq(Status.service, STATUS_OK);
929
930 let deferred = Promise.defer();
931 Svc.Obs.add("weave:ui:clear-error", function onLoginFinish() {
932 Svc.Obs.remove("weave:ui:clear-error", onLoginFinish);
933
934 do_check_true(Status.enforceBackoff);
935 do_check_eq(backoffInterval, 42);
936 do_check_eq(Status.service, LOGIN_FAILED);
937 do_check_eq(Status.login, SERVER_MAINTENANCE);
938 do_check_false(errorHandler.didReportProlongedError);
939
940 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
941 clean();
942 server.stop(deferred.resolve);
943 });
944
945 setLastSync(NON_PROLONGED_ERROR_DURATION);
946 Service.sync();
947 yield deferred.promise;
948 });
949
950 add_identity_test(this, function test_crypto_keys_login_server_maintenance_error() {
951 // Test crypto/keys server maintenance errors are not reported.
952 let server = sync_httpd_setup();
953 yield setUp(server);
954
955 yield configureIdentity({username: "broken.keys"});
956 Service.serverURL = server.baseURI + "/maintenance/";
957 Service.clusterURL = server.baseURI + "/maintenance/";
958
959 // Force re-download of keys
960 Service.collectionKeys.clear();
961
962 let backoffInterval;
963 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
964 Svc.Obs.remove("weave:service:backoff:interval", observe);
965 backoffInterval = subject;
966 });
967
968 function onUIUpdate() {
969 do_throw("Shouldn't get here!");
970 }
971 Svc.Obs.add("weave:ui:login:error", onUIUpdate);
972
973 do_check_false(Status.enforceBackoff);
974 do_check_eq(Status.service, STATUS_OK);
975
976 let deferred = Promise.defer();
977 Svc.Obs.add("weave:ui:clear-error", function onLoginFinish() {
978 Svc.Obs.remove("weave:ui:clear-error", onLoginFinish);
979
980 do_check_true(Status.enforceBackoff);
981 do_check_eq(backoffInterval, 42);
982 do_check_eq(Status.service, LOGIN_FAILED);
983 do_check_eq(Status.login, SERVER_MAINTENANCE);
984 do_check_false(errorHandler.didReportProlongedError);
985
986 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
987 clean();
988 server.stop(deferred.resolve);
989 });
990
991 setLastSync(NON_PROLONGED_ERROR_DURATION);
992 Service.sync();
993 yield deferred.promise;
994 });
995
996 add_task(function test_sync_prolonged_server_maintenance_error() {
997 // Test prolonged server maintenance errors are reported.
998 let server = sync_httpd_setup();
999 yield setUp(server);
1000
1001 const BACKOFF = 42;
1002 let engine = engineManager.get("catapult");
1003 engine.enabled = true;
1004 engine.exception = {status: 503,
1005 headers: {"retry-after": BACKOFF}};
1006
1007 let deferred = Promise.defer();
1008 Svc.Obs.add("weave:ui:sync:error", function onUIUpdate() {
1009 Svc.Obs.remove("weave:ui:sync:error", onUIUpdate);
1010 do_check_eq(Status.service, SYNC_FAILED);
1011 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
1012 do_check_true(errorHandler.didReportProlongedError);
1013
1014 clean();
1015 server.stop(deferred.resolve);
1016 });
1017
1018 do_check_eq(Status.service, STATUS_OK);
1019
1020 setLastSync(PROLONGED_ERROR_DURATION);
1021 Service.sync();
1022 yield deferred.promise;
1023 });
1024
1025 add_identity_test(this, function test_info_collections_login_prolonged_server_maintenance_error(){
1026 // Test info/collections prolonged server maintenance errors are reported.
1027 let server = sync_httpd_setup();
1028 yield setUp(server);
1029
1030 yield configureIdentity({username: "broken.info"});
1031 Service.serverURL = server.baseURI + "/maintenance/";
1032 Service.clusterURL = server.baseURI + "/maintenance/";
1033
1034 let backoffInterval;
1035 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1036 Svc.Obs.remove("weave:service:backoff:interval", observe);
1037 backoffInterval = subject;
1038 });
1039
1040 let deferred = Promise.defer();
1041 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1042 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1043 do_check_true(Status.enforceBackoff);
1044 do_check_eq(backoffInterval, 42);
1045 do_check_eq(Status.service, SYNC_FAILED);
1046 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
1047 do_check_true(errorHandler.didReportProlongedError);
1048
1049 clean();
1050 server.stop(deferred.resolve);
1051 });
1052
1053 do_check_false(Status.enforceBackoff);
1054 do_check_eq(Status.service, STATUS_OK);
1055
1056 setLastSync(PROLONGED_ERROR_DURATION);
1057 Service.sync();
1058 yield deferred.promise;
1059 });
1060
1061 add_identity_test(this, function test_meta_global_login_prolonged_server_maintenance_error(){
1062 // Test meta/global prolonged server maintenance errors are reported.
1063 let server = sync_httpd_setup();
1064 yield setUp(server);
1065
1066 yield configureIdentity({username: "broken.meta"});
1067 Service.serverURL = server.baseURI + "/maintenance/";
1068 Service.clusterURL = server.baseURI + "/maintenance/";
1069
1070 let backoffInterval;
1071 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1072 Svc.Obs.remove("weave:service:backoff:interval", observe);
1073 backoffInterval = subject;
1074 });
1075
1076 let deferred = Promise.defer();
1077 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1078 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1079 do_check_true(Status.enforceBackoff);
1080 do_check_eq(backoffInterval, 42);
1081 do_check_eq(Status.service, SYNC_FAILED);
1082 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
1083 do_check_true(errorHandler.didReportProlongedError);
1084
1085 clean();
1086 server.stop(deferred.resolve);
1087 });
1088
1089 do_check_false(Status.enforceBackoff);
1090 do_check_eq(Status.service, STATUS_OK);
1091
1092 setLastSync(PROLONGED_ERROR_DURATION);
1093 Service.sync();
1094 yield deferred.promise;
1095 });
1096
1097 add_identity_test(this, function test_download_crypto_keys_login_prolonged_server_maintenance_error(){
1098 // Test crypto/keys prolonged server maintenance errors are reported.
1099 let server = sync_httpd_setup();
1100 yield setUp(server);
1101
1102 yield configureIdentity({username: "broken.keys"});
1103 Service.serverURL = server.baseURI + "/maintenance/";
1104 Service.clusterURL = server.baseURI + "/maintenance/";
1105 // Force re-download of keys
1106 Service.collectionKeys.clear();
1107
1108 let backoffInterval;
1109 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1110 Svc.Obs.remove("weave:service:backoff:interval", observe);
1111 backoffInterval = subject;
1112 });
1113
1114 let deferred = Promise.defer();
1115 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1116 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1117 do_check_true(Status.enforceBackoff);
1118 do_check_eq(backoffInterval, 42);
1119 do_check_eq(Status.service, SYNC_FAILED);
1120 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
1121 do_check_true(errorHandler.didReportProlongedError);
1122
1123 clean();
1124 server.stop(deferred.resolve);
1125 });
1126
1127 do_check_false(Status.enforceBackoff);
1128 do_check_eq(Status.service, STATUS_OK);
1129
1130 setLastSync(PROLONGED_ERROR_DURATION);
1131 Service.sync();
1132 yield deferred.promise;
1133 });
1134
1135 add_identity_test(this, function test_upload_crypto_keys_login_prolonged_server_maintenance_error(){
1136 // Test crypto/keys prolonged server maintenance errors are reported.
1137 let server = sync_httpd_setup();
1138
1139 // Start off with an empty account, do not upload a key.
1140 yield configureIdentity({username: "broken.keys"});
1141 Service.serverURL = server.baseURI + "/maintenance/";
1142 Service.clusterURL = server.baseURI + "/maintenance/";
1143
1144 let backoffInterval;
1145 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1146 Svc.Obs.remove("weave:service:backoff:interval", observe);
1147 backoffInterval = subject;
1148 });
1149
1150 let deferred = Promise.defer();
1151 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1152 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1153 do_check_true(Status.enforceBackoff);
1154 do_check_eq(backoffInterval, 42);
1155 do_check_eq(Status.service, SYNC_FAILED);
1156 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
1157 do_check_true(errorHandler.didReportProlongedError);
1158
1159 clean();
1160 server.stop(deferred.resolve);
1161 });
1162
1163 do_check_false(Status.enforceBackoff);
1164 do_check_eq(Status.service, STATUS_OK);
1165
1166 setLastSync(PROLONGED_ERROR_DURATION);
1167 Service.sync();
1168 yield deferred.promise;
1169 });
1170
1171 add_identity_test(this, function test_wipeServer_login_prolonged_server_maintenance_error(){
1172 // Test that we report prolonged server maintenance errors that occur whilst
1173 // wiping the server.
1174 let server = sync_httpd_setup();
1175
1176 // Start off with an empty account, do not upload a key.
1177 yield configureIdentity({username: "broken.wipe"});
1178 Service.serverURL = server.baseURI + "/maintenance/";
1179 Service.clusterURL = server.baseURI + "/maintenance/";
1180
1181 let backoffInterval;
1182 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1183 Svc.Obs.remove("weave:service:backoff:interval", observe);
1184 backoffInterval = subject;
1185 });
1186
1187 let deferred = Promise.defer();
1188 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1189 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1190 do_check_true(Status.enforceBackoff);
1191 do_check_eq(backoffInterval, 42);
1192 do_check_eq(Status.service, SYNC_FAILED);
1193 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
1194 do_check_true(errorHandler.didReportProlongedError);
1195
1196 clean();
1197 server.stop(deferred.resolve);
1198 });
1199
1200 do_check_false(Status.enforceBackoff);
1201 do_check_eq(Status.service, STATUS_OK);
1202
1203 setLastSync(PROLONGED_ERROR_DURATION);
1204 Service.sync();
1205 yield deferred.promise;
1206 });
1207
1208 add_identity_test(this, function test_wipeRemote_prolonged_server_maintenance_error(){
1209 // Test that we report prolonged server maintenance errors that occur whilst
1210 // wiping all remote devices.
1211 let server = sync_httpd_setup();
1212
1213 server.registerPathHandler("/1.1/broken.wipe/storage/catapult", service_unavailable);
1214 yield configureIdentity({username: "broken.wipe"});
1215 Service.serverURL = server.baseURI + "/maintenance/";
1216 Service.clusterURL = server.baseURI + "/maintenance/";
1217 generateAndUploadKeys();
1218
1219 let engine = engineManager.get("catapult");
1220 engine.exception = null;
1221 engine.enabled = true;
1222
1223 let backoffInterval;
1224 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1225 Svc.Obs.remove("weave:service:backoff:interval", observe);
1226 backoffInterval = subject;
1227 });
1228
1229 let deferred = Promise.defer();
1230 Svc.Obs.add("weave:ui:sync:error", function onUIUpdate() {
1231 Svc.Obs.remove("weave:ui:sync:error", onUIUpdate);
1232 do_check_true(Status.enforceBackoff);
1233 do_check_eq(backoffInterval, 42);
1234 do_check_eq(Status.service, SYNC_FAILED);
1235 do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
1236 do_check_eq(Svc.Prefs.get("firstSync"), "wipeRemote");
1237 do_check_true(errorHandler.didReportProlongedError);
1238
1239 clean();
1240 server.stop(deferred.resolve);
1241 });
1242
1243 do_check_false(Status.enforceBackoff);
1244 do_check_eq(Status.service, STATUS_OK);
1245
1246 Svc.Prefs.set("firstSync", "wipeRemote");
1247 setLastSync(PROLONGED_ERROR_DURATION);
1248 Service.sync();
1249 yield deferred.promise;
1250 });
1251
1252 add_task(function test_sync_syncAndReportErrors_server_maintenance_error() {
1253 // Test server maintenance errors are reported
1254 // when calling syncAndReportErrors.
1255 let server = sync_httpd_setup();
1256 yield setUp(server);
1257
1258 const BACKOFF = 42;
1259 let engine = engineManager.get("catapult");
1260 engine.enabled = true;
1261 engine.exception = {status: 503,
1262 headers: {"retry-after": BACKOFF}};
1263
1264 let deferred = Promise.defer();
1265 Svc.Obs.add("weave:ui:sync:error", function onUIUpdate() {
1266 Svc.Obs.remove("weave:ui:sync:error", onUIUpdate);
1267 do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
1268 do_check_eq(Status.sync, SERVER_MAINTENANCE);
1269 do_check_false(errorHandler.didReportProlongedError);
1270
1271 clean();
1272 server.stop(deferred.resolve);
1273 });
1274
1275 do_check_eq(Status.service, STATUS_OK);
1276
1277 setLastSync(NON_PROLONGED_ERROR_DURATION);
1278 errorHandler.syncAndReportErrors();
1279 yield deferred.promise;
1280 });
1281
1282 add_identity_test(this, function test_info_collections_login_syncAndReportErrors_server_maintenance_error() {
1283 // Test info/collections server maintenance errors are reported
1284 // when calling syncAndReportErrors.
1285 let server = sync_httpd_setup();
1286 yield setUp(server);
1287
1288 yield configureIdentity({username: "broken.info"});
1289 Service.serverURL = server.baseURI + "/maintenance/";
1290 Service.clusterURL = server.baseURI + "/maintenance/";
1291
1292 let backoffInterval;
1293 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1294 Svc.Obs.remove("weave:service:backoff:interval", observe);
1295 backoffInterval = subject;
1296 });
1297
1298 let deferred = Promise.defer();
1299 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1300 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1301 do_check_true(Status.enforceBackoff);
1302 do_check_eq(backoffInterval, 42);
1303 do_check_eq(Status.service, LOGIN_FAILED);
1304 do_check_eq(Status.login, SERVER_MAINTENANCE);
1305 do_check_false(errorHandler.didReportProlongedError);
1306
1307 clean();
1308 server.stop(deferred.resolve);
1309 });
1310
1311 do_check_false(Status.enforceBackoff);
1312 do_check_eq(Status.service, STATUS_OK);
1313
1314 setLastSync(NON_PROLONGED_ERROR_DURATION);
1315 errorHandler.syncAndReportErrors();
1316 yield deferred.promise;
1317 });
1318
1319 add_identity_test(this, function test_meta_global_login_syncAndReportErrors_server_maintenance_error() {
1320 // Test meta/global server maintenance errors are reported
1321 // when calling syncAndReportErrors.
1322 let server = sync_httpd_setup();
1323 yield setUp(server);
1324
1325 yield configureIdentity({username: "broken.meta"});
1326 Service.serverURL = server.baseURI + "/maintenance/";
1327 Service.clusterURL = server.baseURI + "/maintenance/";
1328
1329 let backoffInterval;
1330 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1331 Svc.Obs.remove("weave:service:backoff:interval", observe);
1332 backoffInterval = subject;
1333 });
1334
1335 let deferred = Promise.defer();
1336 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1337 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1338 do_check_true(Status.enforceBackoff);
1339 do_check_eq(backoffInterval, 42);
1340 do_check_eq(Status.service, LOGIN_FAILED);
1341 do_check_eq(Status.login, SERVER_MAINTENANCE);
1342 do_check_false(errorHandler.didReportProlongedError);
1343
1344 clean();
1345 server.stop(deferred.resolve);
1346 });
1347
1348 do_check_false(Status.enforceBackoff);
1349 do_check_eq(Status.service, STATUS_OK);
1350
1351 setLastSync(NON_PROLONGED_ERROR_DURATION);
1352 errorHandler.syncAndReportErrors();
1353 yield deferred.promise;
1354 });
1355
1356 add_identity_test(this, function test_download_crypto_keys_login_syncAndReportErrors_server_maintenance_error() {
1357 // Test crypto/keys server maintenance errors are reported
1358 // when calling syncAndReportErrors.
1359 let server = sync_httpd_setup();
1360 yield setUp(server);
1361
1362 yield configureIdentity({username: "broken.keys"});
1363 Service.serverURL = server.baseURI + "/maintenance/";
1364 Service.clusterURL = server.baseURI + "/maintenance/";
1365 // Force re-download of keys
1366 Service.collectionKeys.clear();
1367
1368 let backoffInterval;
1369 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1370 Svc.Obs.remove("weave:service:backoff:interval", observe);
1371 backoffInterval = subject;
1372 });
1373
1374 let deferred = Promise.defer();
1375 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1376 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1377 do_check_true(Status.enforceBackoff);
1378 do_check_eq(backoffInterval, 42);
1379 do_check_eq(Status.service, LOGIN_FAILED);
1380 do_check_eq(Status.login, SERVER_MAINTENANCE);
1381 do_check_false(errorHandler.didReportProlongedError);
1382
1383 clean();
1384 server.stop(deferred.resolve);
1385 });
1386
1387 do_check_false(Status.enforceBackoff);
1388 do_check_eq(Status.service, STATUS_OK);
1389
1390 setLastSync(NON_PROLONGED_ERROR_DURATION);
1391 errorHandler.syncAndReportErrors();
1392 yield deferred.promise;
1393 });
1394
1395 add_identity_test(this, function test_upload_crypto_keys_login_syncAndReportErrors_server_maintenance_error() {
1396 // Test crypto/keys server maintenance errors are reported
1397 // when calling syncAndReportErrors.
1398 let server = sync_httpd_setup();
1399
1400 // Start off with an empty account, do not upload a key.
1401 yield configureIdentity({username: "broken.keys"});
1402 Service.serverURL = server.baseURI + "/maintenance/";
1403 Service.clusterURL = server.baseURI + "/maintenance/";
1404
1405 let backoffInterval;
1406 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1407 Svc.Obs.remove("weave:service:backoff:interval", observe);
1408 backoffInterval = subject;
1409 });
1410
1411 let deferred = Promise.defer();
1412 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1413 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1414 do_check_true(Status.enforceBackoff);
1415 do_check_eq(backoffInterval, 42);
1416 do_check_eq(Status.service, LOGIN_FAILED);
1417 do_check_eq(Status.login, SERVER_MAINTENANCE);
1418 do_check_false(errorHandler.didReportProlongedError);
1419
1420 clean();
1421 server.stop(deferred.resolve);
1422 });
1423
1424 do_check_false(Status.enforceBackoff);
1425 do_check_eq(Status.service, STATUS_OK);
1426
1427 setLastSync(NON_PROLONGED_ERROR_DURATION);
1428 errorHandler.syncAndReportErrors();
1429 yield deferred.promise;
1430 });
1431
1432 add_identity_test(this, function test_wipeServer_login_syncAndReportErrors_server_maintenance_error() {
1433 // Test crypto/keys server maintenance errors are reported
1434 // when calling syncAndReportErrors.
1435 let server = sync_httpd_setup();
1436
1437 // Start off with an empty account, do not upload a key.
1438 yield configureIdentity({username: "broken.wipe"});
1439 Service.serverURL = server.baseURI + "/maintenance/";
1440 Service.clusterURL = server.baseURI + "/maintenance/";
1441
1442 let backoffInterval;
1443 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1444 Svc.Obs.remove("weave:service:backoff:interval", observe);
1445 backoffInterval = subject;
1446 });
1447
1448 let deferred = Promise.defer();
1449 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1450 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1451 do_check_true(Status.enforceBackoff);
1452 do_check_eq(backoffInterval, 42);
1453 do_check_eq(Status.service, LOGIN_FAILED);
1454 do_check_eq(Status.login, SERVER_MAINTENANCE);
1455 do_check_false(errorHandler.didReportProlongedError);
1456
1457 clean();
1458 server.stop(deferred.resolve);
1459 });
1460
1461 do_check_false(Status.enforceBackoff);
1462 do_check_eq(Status.service, STATUS_OK);
1463
1464 setLastSync(NON_PROLONGED_ERROR_DURATION);
1465 errorHandler.syncAndReportErrors();
1466 yield deferred.promise;
1467 });
1468
1469 add_identity_test(this, function test_wipeRemote_syncAndReportErrors_server_maintenance_error(){
1470 // Test that we report prolonged server maintenance errors that occur whilst
1471 // wiping all remote devices.
1472 let server = sync_httpd_setup();
1473
1474 yield configureIdentity({username: "broken.wipe"});
1475 Service.serverURL = server.baseURI + "/maintenance/";
1476 Service.clusterURL = server.baseURI + "/maintenance/";
1477 generateAndUploadKeys();
1478
1479 let engine = engineManager.get("catapult");
1480 engine.exception = null;
1481 engine.enabled = true;
1482
1483 let backoffInterval;
1484 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1485 Svc.Obs.remove("weave:service:backoff:interval", observe);
1486 backoffInterval = subject;
1487 });
1488
1489 let deferred = Promise.defer();
1490 Svc.Obs.add("weave:ui:sync:error", function onUIUpdate() {
1491 Svc.Obs.remove("weave:ui:sync:error", onUIUpdate);
1492 do_check_true(Status.enforceBackoff);
1493 do_check_eq(backoffInterval, 42);
1494 do_check_eq(Status.service, SYNC_FAILED);
1495 do_check_eq(Status.sync, SERVER_MAINTENANCE);
1496 do_check_eq(Svc.Prefs.get("firstSync"), "wipeRemote");
1497 do_check_false(errorHandler.didReportProlongedError);
1498
1499 clean();
1500 server.stop(deferred.resolve);
1501 });
1502
1503 do_check_false(Status.enforceBackoff);
1504 do_check_eq(Status.service, STATUS_OK);
1505
1506 Svc.Prefs.set("firstSync", "wipeRemote");
1507 setLastSync(NON_PROLONGED_ERROR_DURATION);
1508 errorHandler.syncAndReportErrors();
1509 yield deferred.promise;
1510 });
1511
1512 add_task(function test_sync_syncAndReportErrors_prolonged_server_maintenance_error() {
1513 // Test prolonged server maintenance errors are
1514 // reported when calling syncAndReportErrors.
1515 let server = sync_httpd_setup();
1516 yield setUp(server);
1517
1518 const BACKOFF = 42;
1519 let engine = engineManager.get("catapult");
1520 engine.enabled = true;
1521 engine.exception = {status: 503,
1522 headers: {"retry-after": BACKOFF}};
1523
1524 let deferred = Promise.defer();
1525 Svc.Obs.add("weave:ui:sync:error", function onUIUpdate() {
1526 Svc.Obs.remove("weave:ui:sync:error", onUIUpdate);
1527 do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
1528 do_check_eq(Status.sync, SERVER_MAINTENANCE);
1529 // syncAndReportErrors means dontIgnoreErrors, which means
1530 // didReportProlongedError not touched.
1531 do_check_false(errorHandler.didReportProlongedError);
1532
1533 clean();
1534 server.stop(deferred.resolve);
1535 });
1536
1537 do_check_eq(Status.service, STATUS_OK);
1538
1539 setLastSync(PROLONGED_ERROR_DURATION);
1540 errorHandler.syncAndReportErrors();
1541 yield deferred.promise;
1542 });
1543
1544 add_identity_test(this, function test_info_collections_login_syncAndReportErrors_prolonged_server_maintenance_error() {
1545 // Test info/collections server maintenance errors are reported
1546 // when calling syncAndReportErrors.
1547 let server = sync_httpd_setup();
1548 yield setUp(server);
1549
1550 yield configureIdentity({username: "broken.info"});
1551 Service.serverURL = server.baseURI + "/maintenance/";
1552 Service.clusterURL = server.baseURI + "/maintenance/";
1553
1554 let backoffInterval;
1555 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1556 Svc.Obs.remove("weave:service:backoff:interval", observe);
1557 backoffInterval = subject;
1558 });
1559
1560 let deferred = Promise.defer();
1561 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1562 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1563 do_check_true(Status.enforceBackoff);
1564 do_check_eq(backoffInterval, 42);
1565 do_check_eq(Status.service, LOGIN_FAILED);
1566 do_check_eq(Status.login, SERVER_MAINTENANCE);
1567 // syncAndReportErrors means dontIgnoreErrors, which means
1568 // didReportProlongedError not touched.
1569 do_check_false(errorHandler.didReportProlongedError);
1570
1571 clean();
1572 server.stop(deferred.resolve);
1573 });
1574
1575 do_check_false(Status.enforceBackoff);
1576 do_check_eq(Status.service, STATUS_OK);
1577
1578 setLastSync(PROLONGED_ERROR_DURATION);
1579 errorHandler.syncAndReportErrors();
1580 yield deferred.promise;
1581 });
1582
1583 add_identity_test(this, function test_meta_global_login_syncAndReportErrors_prolonged_server_maintenance_error() {
1584 // Test meta/global server maintenance errors are reported
1585 // when calling syncAndReportErrors.
1586 let server = sync_httpd_setup();
1587 yield setUp(server);
1588
1589 yield configureIdentity({username: "broken.meta"});
1590 Service.serverURL = server.baseURI + "/maintenance/";
1591 Service.clusterURL = server.baseURI + "/maintenance/";
1592
1593 let backoffInterval;
1594 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1595 Svc.Obs.remove("weave:service:backoff:interval", observe);
1596 backoffInterval = subject;
1597 });
1598
1599 let deferred = Promise.defer();
1600 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1601 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1602 do_check_true(Status.enforceBackoff);
1603 do_check_eq(backoffInterval, 42);
1604 do_check_eq(Status.service, LOGIN_FAILED);
1605 do_check_eq(Status.login, SERVER_MAINTENANCE);
1606 // syncAndReportErrors means dontIgnoreErrors, which means
1607 // didReportProlongedError not touched.
1608 do_check_false(errorHandler.didReportProlongedError);
1609
1610 clean();
1611 server.stop(deferred.resolve);
1612 });
1613
1614 do_check_false(Status.enforceBackoff);
1615 do_check_eq(Status.service, STATUS_OK);
1616
1617 setLastSync(PROLONGED_ERROR_DURATION);
1618 errorHandler.syncAndReportErrors();
1619 yield deferred.promise;
1620 });
1621
1622 add_identity_test(this, function test_download_crypto_keys_login_syncAndReportErrors_prolonged_server_maintenance_error() {
1623 // Test crypto/keys server maintenance errors are reported
1624 // when calling syncAndReportErrors.
1625 let server = sync_httpd_setup();
1626 yield setUp(server);
1627
1628 yield configureIdentity({username: "broken.keys"});
1629 Service.serverURL = server.baseURI + "/maintenance/";
1630 Service.clusterURL = server.baseURI + "/maintenance/";
1631 // Force re-download of keys
1632 Service.collectionKeys.clear();
1633
1634 let backoffInterval;
1635 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1636 Svc.Obs.remove("weave:service:backoff:interval", observe);
1637 backoffInterval = subject;
1638 });
1639
1640 let deferred = Promise.defer();
1641 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1642 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1643 do_check_true(Status.enforceBackoff);
1644 do_check_eq(backoffInterval, 42);
1645 do_check_eq(Status.service, LOGIN_FAILED);
1646 do_check_eq(Status.login, SERVER_MAINTENANCE);
1647 // syncAndReportErrors means dontIgnoreErrors, which means
1648 // didReportProlongedError not touched.
1649 do_check_false(errorHandler.didReportProlongedError);
1650
1651 clean();
1652 server.stop(deferred.resolve);
1653 });
1654
1655 do_check_false(Status.enforceBackoff);
1656 do_check_eq(Status.service, STATUS_OK);
1657
1658 setLastSync(PROLONGED_ERROR_DURATION);
1659 errorHandler.syncAndReportErrors();
1660 yield deferred.promise;
1661 });
1662
1663 add_identity_test(this, function test_upload_crypto_keys_login_syncAndReportErrors_prolonged_server_maintenance_error() {
1664 // Test crypto/keys server maintenance errors are reported
1665 // when calling syncAndReportErrors.
1666 let server = sync_httpd_setup();
1667
1668 // Start off with an empty account, do not upload a key.
1669 yield configureIdentity({username: "broken.keys"});
1670 Service.serverURL = server.baseURI + "/maintenance/";
1671 Service.clusterURL = server.baseURI + "/maintenance/";
1672
1673 let backoffInterval;
1674 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1675 Svc.Obs.remove("weave:service:backoff:interval", observe);
1676 backoffInterval = subject;
1677 });
1678
1679 let deferred = Promise.defer();
1680 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1681 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1682 do_check_true(Status.enforceBackoff);
1683 do_check_eq(backoffInterval, 42);
1684 do_check_eq(Status.service, LOGIN_FAILED);
1685 do_check_eq(Status.login, SERVER_MAINTENANCE);
1686 // syncAndReportErrors means dontIgnoreErrors, which means
1687 // didReportProlongedError not touched.
1688 do_check_false(errorHandler.didReportProlongedError);
1689
1690 clean();
1691 server.stop(deferred.resolve);
1692 });
1693
1694 do_check_false(Status.enforceBackoff);
1695 do_check_eq(Status.service, STATUS_OK);
1696
1697 setLastSync(PROLONGED_ERROR_DURATION);
1698 errorHandler.syncAndReportErrors();
1699 yield deferred.promise;
1700 });
1701
1702 add_identity_test(this, function test_wipeServer_login_syncAndReportErrors_prolonged_server_maintenance_error() {
1703 // Test crypto/keys server maintenance errors are reported
1704 // when calling syncAndReportErrors.
1705 let server = sync_httpd_setup();
1706
1707 // Start off with an empty account, do not upload a key.
1708 yield configureIdentity({username: "broken.wipe"});
1709 Service.serverURL = server.baseURI + "/maintenance/";
1710 Service.clusterURL = server.baseURI + "/maintenance/";
1711
1712 let backoffInterval;
1713 Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
1714 Svc.Obs.remove("weave:service:backoff:interval", observe);
1715 backoffInterval = subject;
1716 });
1717
1718 let deferred = Promise.defer();
1719 Svc.Obs.add("weave:ui:login:error", function onUIUpdate() {
1720 Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
1721 do_check_true(Status.enforceBackoff);
1722 do_check_eq(backoffInterval, 42);
1723 do_check_eq(Status.service, LOGIN_FAILED);
1724 do_check_eq(Status.login, SERVER_MAINTENANCE);
1725 // syncAndReportErrors means dontIgnoreErrors, which means
1726 // didReportProlongedError not touched.
1727 do_check_false(errorHandler.didReportProlongedError);
1728
1729 clean();
1730 server.stop(deferred.resolve);
1731 });
1732
1733 do_check_false(Status.enforceBackoff);
1734 do_check_eq(Status.service, STATUS_OK);
1735
1736 setLastSync(PROLONGED_ERROR_DURATION);
1737 errorHandler.syncAndReportErrors();
1738 yield deferred.promise;
1739 });
1740
1741 add_task(function test_sync_engine_generic_fail() {
1742 let server = sync_httpd_setup();
1743
1744 let engine = engineManager.get("catapult");
1745 engine.enabled = true;
1746 engine.sync = function sync() {
1747 Svc.Obs.notify("weave:engine:sync:error", "", "catapult");
1748 };
1749
1750 let log = Log.repository.getLogger("Sync.ErrorHandler");
1751 Svc.Prefs.set("log.appender.file.logOnError", true);
1752
1753 do_check_eq(Status.engines["catapult"], undefined);
1754
1755 let deferred = Promise.defer();
1756 // Don't wait for reset-file-log until the sync is underway.
1757 // This avoids us catching a delayed notification from an earlier test.
1758 Svc.Obs.add("weave:engine:sync:finish", function onEngineFinish() {
1759 Svc.Obs.remove("weave:engine:sync:finish", onEngineFinish);
1760
1761 log.info("Adding reset-file-log observer.");
1762 Svc.Obs.add("weave:service:reset-file-log", function onResetFileLog() {
1763 Svc.Obs.remove("weave:service:reset-file-log", onResetFileLog);
1764
1765 // Put these checks here, not after sync(), so that we aren't racing the
1766 // log handler... which resets everything just a few lines below!
1767 _("Status.engines: " + JSON.stringify(Status.engines));
1768 do_check_eq(Status.engines["catapult"], ENGINE_UNKNOWN_FAIL);
1769 do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
1770
1771 // Test Error log was written on SYNC_FAILED_PARTIAL.
1772 let entries = logsdir.directoryEntries;
1773 do_check_true(entries.hasMoreElements());
1774 let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
1775 do_check_eq(logfile.leafName.slice(0, LOG_PREFIX_ERROR.length),
1776 LOG_PREFIX_ERROR);
1777
1778 clean();
1779 server.stop(deferred.resolve);
1780 });
1781 });
1782
1783 do_check_true(yield setUp(server));
1784 Service.sync();
1785 yield deferred.promise;
1786 });
1787
1788 add_test(function test_logs_on_sync_error_despite_shouldReportError() {
1789 _("Ensure that an error is still logged when weave:service:sync:error " +
1790 "is notified, despite shouldReportError returning false.");
1791
1792 let log = Log.repository.getLogger("Sync.ErrorHandler");
1793 Svc.Prefs.set("log.appender.file.logOnError", true);
1794 log.info("TESTING");
1795
1796 // Ensure that we report no error.
1797 Status.login = MASTER_PASSWORD_LOCKED;
1798 do_check_false(errorHandler.shouldReportError());
1799
1800 Svc.Obs.add("weave:service:reset-file-log", function onResetFileLog() {
1801 Svc.Obs.remove("weave:service:reset-file-log", onResetFileLog);
1802
1803 // Test that error log was written.
1804 let entries = logsdir.directoryEntries;
1805 do_check_true(entries.hasMoreElements());
1806 let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
1807 do_check_eq(logfile.leafName.slice(0, LOG_PREFIX_ERROR.length),
1808 LOG_PREFIX_ERROR);
1809
1810 clean();
1811 run_next_test();
1812 });
1813 Svc.Obs.notify("weave:service:sync:error", {});
1814 });
1815
1816 add_test(function test_logs_on_login_error_despite_shouldReportError() {
1817 _("Ensure that an error is still logged when weave:service:login:error " +
1818 "is notified, despite shouldReportError returning false.");
1819
1820 let log = Log.repository.getLogger("Sync.ErrorHandler");
1821 Svc.Prefs.set("log.appender.file.logOnError", true);
1822 log.info("TESTING");
1823
1824 // Ensure that we report no error.
1825 Status.login = MASTER_PASSWORD_LOCKED;
1826 do_check_false(errorHandler.shouldReportError());
1827
1828 Svc.Obs.add("weave:service:reset-file-log", function onResetFileLog() {
1829 Svc.Obs.remove("weave:service:reset-file-log", onResetFileLog);
1830
1831 // Test that error log was written.
1832 let entries = logsdir.directoryEntries;
1833 do_check_true(entries.hasMoreElements());
1834 let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
1835 do_check_eq(logfile.leafName.slice(0, LOG_PREFIX_ERROR.length),
1836 LOG_PREFIX_ERROR);
1837
1838 clean();
1839 run_next_test();
1840 });
1841 Svc.Obs.notify("weave:service:login:error", {});
1842 });
1843
1844 // This test should be the last one since it monkeypatches the engine object
1845 // and we should only have one engine object throughout the file (bug 629664).
1846 add_task(function test_engine_applyFailed() {
1847 let server = sync_httpd_setup();
1848
1849 let engine = engineManager.get("catapult");
1850 engine.enabled = true;
1851 delete engine.exception;
1852 engine.sync = function sync() {
1853 Svc.Obs.notify("weave:engine:sync:applied", {newFailed:1}, "catapult");
1854 };
1855
1856 let log = Log.repository.getLogger("Sync.ErrorHandler");
1857 Svc.Prefs.set("log.appender.file.logOnError", true);
1858
1859 let deferred = Promise.defer();
1860 Svc.Obs.add("weave:service:reset-file-log", function onResetFileLog() {
1861 Svc.Obs.remove("weave:service:reset-file-log", onResetFileLog);
1862
1863 do_check_eq(Status.engines["catapult"], ENGINE_APPLY_FAIL);
1864 do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
1865
1866 // Test Error log was written on SYNC_FAILED_PARTIAL.
1867 let entries = logsdir.directoryEntries;
1868 do_check_true(entries.hasMoreElements());
1869 let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
1870 do_check_eq(logfile.leafName.slice(0, LOG_PREFIX_ERROR.length),
1871 LOG_PREFIX_ERROR);
1872
1873 clean();
1874 server.stop(deferred.resolve);
1875 });
1876
1877 do_check_eq(Status.engines["catapult"], undefined);
1878 do_check_true(yield setUp(server));
1879 Service.sync();
1880 yield deferred.promise;
1881 });

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial