The Tor Browser / file comparison

comparison: toolkit/mozapps/extensions/test/xpcshell/test_update_strictcompat.js

toolkit/mozapps/extensions/test/xpcshell/test_update_strictcompat.js

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:3112f7d66bcc
1 /* Any copyright is dedicated to the Public Domain.
2 * http://creativecommons.org/publicdomain/zero/1.0/
3 */
4
5 // This verifies that add-on update checks work
6
7 const PREF_MATCH_OS_LOCALE = "intl.locale.matchOS";
8 const PREF_SELECTED_LOCALE = "general.useragent.locale";
9 const PREF_GETADDONS_CACHE_ENABLED = "extensions.getAddons.cache.enabled";
10
11 // The test extension uses an insecure update url.
12 Services.prefs.setBoolPref("extensions.checkUpdateSecurity", false);
13 // This test requires lightweight themes update to be enabled even if the app
14 // doesn't support lightweight themes.
15 Services.prefs.setBoolPref("lightweightThemes.update.enabled", true);
16
17 Components.utils.import("resource://gre/modules/LightweightThemeManager.jsm");
18
19 const PARAMS = "?%REQ_VERSION%/%ITEM_ID%/%ITEM_VERSION%/%ITEM_MAXAPPVERSION%/" +
20 "%ITEM_STATUS%/%APP_ID%/%APP_VERSION%/%CURRENT_APP_VERSION%/" +
21 "%APP_OS%/%APP_ABI%/%APP_LOCALE%/%UPDATE_TYPE%";
22
23 var gInstallDate;
24
25 Components.utils.import("resource://testing-common/httpd.js");
26 var testserver = new HttpServer();
27 testserver.start(-1);
28 gPort = testserver.identity.primaryPort;
29 mapFile("/data/test_update.rdf", testserver);
30 mapFile("/data/test_update.xml", testserver);
31 testserver.registerDirectory("/addons/", do_get_file("addons"));
32
33 const profileDir = gProfD.clone();
34 profileDir.append("extensions");
35
36 function run_test() {
37 createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
38 Services.prefs.setBoolPref(PREF_MATCH_OS_LOCALE, false);
39 Services.prefs.setCharPref(PREF_SELECTED_LOCALE, "fr-FR");
40 Services.prefs.setBoolPref(PREF_EM_STRICT_COMPATIBILITY, true);
41
42 writeInstallRDFForExtension({
43 id: "addon1@tests.mozilla.org",
44 version: "1.0",
45 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
46 targetApplications: [{
47 id: "xpcshell@tests.mozilla.org",
48 minVersion: "1",
49 maxVersion: "1"
50 }],
51 name: "Test Addon 1",
52 }, profileDir);
53
54 writeInstallRDFForExtension({
55 id: "addon2@tests.mozilla.org",
56 version: "1.0",
57 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
58 targetApplications: [{
59 id: "xpcshell@tests.mozilla.org",
60 minVersion: "0",
61 maxVersion: "0"
62 }],
63 name: "Test Addon 2",
64 }, profileDir);
65
66 writeInstallRDFForExtension({
67 id: "addon3@tests.mozilla.org",
68 version: "1.0",
69 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
70 targetApplications: [{
71 id: "xpcshell@tests.mozilla.org",
72 minVersion: "5",
73 maxVersion: "5"
74 }],
75 name: "Test Addon 3",
76 }, profileDir);
77
78 startupManager();
79
80 do_test_pending();
81 run_test_1();
82 }
83
84 function end_test() {
85 Services.prefs.clearUserPref(PREF_EM_STRICT_COMPATIBILITY);
86
87 testserver.stop(do_test_finished);
88 }
89
90 // Verify that an update is available and can be installed.
91 function run_test_1() {
92 AddonManager.getAddonByID("addon1@tests.mozilla.org", function(a1) {
93 do_check_neq(a1, null);
94 do_check_eq(a1.version, "1.0");
95 do_check_eq(a1.applyBackgroundUpdates, AddonManager.AUTOUPDATE_DEFAULT);
96 do_check_eq(a1.releaseNotesURI, null);
97
98 a1.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DEFAULT;
99
100 prepare_test({
101 "addon1@tests.mozilla.org": [
102 ["onPropertyChanged", ["applyBackgroundUpdates"]]
103 ]
104 });
105 a1.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DISABLE;
106 check_test_completed();
107
108 a1.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DISABLE;
109
110 prepare_test({}, [
111 "onNewInstall",
112 ]);
113
114 a1.findUpdates({
115 onNoCompatibilityUpdateAvailable: function(addon) {
116 do_throw("Should not have seen onNoCompatibilityUpdateAvailable notification");
117 },
118
119 onUpdateAvailable: function(addon, install) {
120 ensure_test_completed();
121
122 AddonManager.getAllInstalls(function(aInstalls) {
123 do_check_eq(aInstalls.length, 1);
124 do_check_eq(aInstalls[0], install);
125
126 do_check_eq(addon, a1);
127 do_check_eq(install.name, addon.name);
128 do_check_eq(install.version, "2.0");
129 do_check_eq(install.state, AddonManager.STATE_AVAILABLE);
130 do_check_eq(install.existingAddon, addon);
131 do_check_eq(install.releaseNotesURI.spec, "http://example.com/updateInfo.xhtml");
132
133 // Verify that another update check returns the same AddonInstall
134 a1.findUpdates({
135 onNoCompatibilityUpdateAvailable: function(addon) {
136 do_throw("Should not have seen onNoCompatibilityUpdateAvailable notification");
137 },
138
139 onUpdateAvailable: function(newAddon, newInstall) {
140 AddonManager.getAllInstalls(function(aInstalls) {
141 do_check_eq(aInstalls.length, 1);
142 do_check_eq(aInstalls[0], install);
143 do_check_eq(newAddon, addon);
144 do_check_eq(newInstall, install);
145
146 prepare_test({}, [
147 "onDownloadStarted",
148 "onDownloadEnded",
149 ], check_test_1);
150 install.install();
151 });
152 },
153
154 onNoUpdateAvailable: function(addon) {
155 do_throw("Should not have seen onNoUpdateAvailable notification");
156 }
157 }, AddonManager.UPDATE_WHEN_USER_REQUESTED);
158 });
159 },
160
161 onNoUpdateAvailable: function(addon) {
162 do_throw("Should not have seen onNoUpdateAvailable notification");
163 }
164 }, AddonManager.UPDATE_WHEN_USER_REQUESTED);
165 });
166 }
167
168 function check_test_1(install) {
169 ensure_test_completed();
170 do_check_eq(install.state, AddonManager.STATE_DOWNLOADED);
171 run_test_2(install);
172 return false;
173 }
174
175 // Continue installing the update.
176 function run_test_2(install) {
177 // Verify that another update check returns no new update
178 install.existingAddon.findUpdates({
179 onNoCompatibilityUpdateAvailable: function(addon) {
180 do_throw("Should not have seen onNoCompatibilityUpdateAvailable notification");
181 },
182
183 onUpdateAvailable: function(addon, install) {
184 do_throw("Should find no available update when one is already downloading");
185 },
186
187 onNoUpdateAvailable: function(addon) {
188 AddonManager.getAllInstalls(function(aInstalls) {
189 do_check_eq(aInstalls.length, 1);
190 do_check_eq(aInstalls[0], install);
191
192 prepare_test({
193 "addon1@tests.mozilla.org": [
194 "onInstalling"
195 ]
196 }, [
197 "onInstallStarted",
198 "onInstallEnded",
199 ], check_test_2);
200 install.install();
201 });
202 }
203 }, AddonManager.UPDATE_WHEN_USER_REQUESTED);
204 }
205
206 function check_test_2() {
207 ensure_test_completed();
208
209 AddonManager.getAddonByID("addon1@tests.mozilla.org", callback_soon(function(olda1) {
210 do_check_neq(olda1, null);
211 do_check_eq(olda1.version, "1.0");
212 do_check_true(isExtensionInAddonsList(profileDir, olda1.id));
213
214 shutdownManager();
215
216 startupManager();
217
218 do_check_true(isExtensionInAddonsList(profileDir, olda1.id));
219
220 AddonManager.getAddonByID("addon1@tests.mozilla.org", function(a1) {
221 do_check_neq(a1, null);
222 do_check_eq(a1.version, "2.0");
223 do_check_true(isExtensionInAddonsList(profileDir, a1.id));
224 do_check_eq(a1.applyBackgroundUpdates, AddonManager.AUTOUPDATE_DISABLE);
225 do_check_eq(a1.releaseNotesURI.spec, "http://example.com/updateInfo.xhtml");
226
227 a1.uninstall();
228 do_execute_soon(run_test_3);
229 });
230 }));
231 }
232
233
234 // Check that an update check finds compatibility updates and applies them
235 function run_test_3() {
236 restartManager();
237
238 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
239 do_check_neq(a2, null);
240 do_check_false(a2.isActive);
241 do_check_false(a2.isCompatible);
242 do_check_true(a2.appDisabled);
243 do_check_true(a2.isCompatibleWith("0"));
244
245 a2.findUpdates({
246 onCompatibilityUpdateAvailable: function(addon) {
247 do_check_true(a2.isCompatible);
248 do_check_false(a2.appDisabled);
249 do_check_false(a2.isActive);
250 },
251
252 onUpdateAvailable: function(addon, install) {
253 do_throw("Should not have seen an available update");
254 },
255
256 onNoUpdateAvailable: function(addon) {
257 do_check_eq(addon, a2);
258 do_execute_soon(check_test_3);
259 }
260 }, AddonManager.UPDATE_WHEN_USER_REQUESTED);
261 });
262 }
263
264 function check_test_3() {
265 restartManager();
266 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
267 do_check_neq(a2, null);
268 do_check_true(a2.isActive);
269 do_check_true(a2.isCompatible);
270 do_check_false(a2.appDisabled);
271 a2.uninstall();
272
273 run_test_4();
274 });
275 }
276
277 // Checks that we see no compatibility information when there is none.
278 function run_test_4() {
279 AddonManager.getAddonByID("addon3@tests.mozilla.org", function(a3) {
280 do_check_neq(a3, null);
281 do_check_false(a3.isActive);
282 do_check_false(a3.isCompatible);
283 do_check_true(a3.appDisabled);
284 do_check_true(a3.isCompatibleWith("5"));
285 do_check_false(a3.isCompatibleWith("2"));
286
287 a3.findUpdates({
288 sawUpdate: false,
289 onCompatibilityUpdateAvailable: function(addon) {
290 do_throw("Should not have seen compatibility information");
291 },
292
293 onNoCompatibilityUpdateAvailable: function(addon) {
294 this.sawUpdate = true;
295 },
296
297 onUpdateAvailable: function(addon, install) {
298 do_throw("Should not have seen an available update");
299 },
300
301 onNoUpdateAvailable: function(addon) {
302 do_check_true(this.sawUpdate);
303 run_test_5();
304 }
305 }, AddonManager.UPDATE_WHEN_USER_REQUESTED);
306 });
307 }
308
309 // Checks that compatibility info for future apps are detected but don't make
310 // the item compatibile.
311 function run_test_5() {
312 AddonManager.getAddonByID("addon3@tests.mozilla.org", function(a3) {
313 do_check_neq(a3, null);
314 do_check_false(a3.isActive);
315 do_check_false(a3.isCompatible);
316 do_check_true(a3.appDisabled);
317 do_check_true(a3.isCompatibleWith("5"));
318 do_check_false(a3.isCompatibleWith("2"));
319
320 a3.findUpdates({
321 sawUpdate: false,
322 onCompatibilityUpdateAvailable: function(addon) {
323 do_check_false(a3.isCompatible);
324 do_check_true(a3.appDisabled);
325 do_check_false(a3.isActive);
326 this.sawUpdate = true;
327 },
328
329 onNoCompatibilityUpdateAvailable: function(addon) {
330 do_throw("Should have seen some compatibility information");
331 },
332
333 onUpdateAvailable: function(addon, install) {
334 do_throw("Should not have seen an available update");
335 },
336
337 onNoUpdateAvailable: function(addon) {
338 do_check_true(this.sawUpdate);
339 do_execute_soon(check_test_5);
340 }
341 }, AddonManager.UPDATE_WHEN_USER_REQUESTED, "3.0");
342 });
343 }
344
345 function check_test_5() {
346 restartManager();
347 AddonManager.getAddonByID("addon3@tests.mozilla.org", function(a3) {
348 do_check_neq(a3, null);
349 do_check_false(a3.isActive);
350 do_check_false(a3.isCompatible);
351 do_check_true(a3.appDisabled);
352
353 a3.uninstall();
354 do_execute_soon(run_test_6);
355 });
356 }
357
358 // Test that background update checks work
359 function run_test_6() {
360 restartManager();
361
362 writeInstallRDFForExtension({
363 id: "addon1@tests.mozilla.org",
364 version: "1.0",
365 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
366 targetApplications: [{
367 id: "xpcshell@tests.mozilla.org",
368 minVersion: "1",
369 maxVersion: "1"
370 }],
371 name: "Test Addon 1",
372 }, profileDir);
373 restartManager();
374
375 prepare_test({}, [
376 "onNewInstall",
377 "onDownloadStarted",
378 "onDownloadEnded"
379 ], continue_test_6);
380
381 // Fake a timer event to cause a background update and wait for the magic to
382 // happen
383 gInternalManager.notify(null);
384 }
385
386 function continue_test_6(install) {
387 do_check_neq(install.existingAddon, null);
388 do_check_eq(install.existingAddon.id, "addon1@tests.mozilla.org");
389
390 prepare_test({
391 "addon1@tests.mozilla.org": [
392 "onInstalling"
393 ]
394 }, [
395 "onInstallStarted",
396 "onInstallEnded",
397 ], callback_soon(check_test_6));
398 }
399
400 function check_test_6(install) {
401 do_check_eq(install.existingAddon.pendingUpgrade.install, install);
402
403 restartManager();
404 AddonManager.getAddonByID("addon1@tests.mozilla.org", function(a1) {
405 do_check_neq(a1, null);
406 do_check_eq(a1.version, "2.0");
407 do_check_eq(a1.releaseNotesURI.spec, "http://example.com/updateInfo.xhtml");
408 a1.uninstall();
409 do_execute_soon(run_test_7);
410 });
411 }
412
413 // Test that background update checks work for lightweight themes
414 function run_test_7() {
415 restartManager();
416
417 LightweightThemeManager.currentTheme = {
418 id: "1",
419 version: "1",
420 name: "Test LW Theme",
421 description: "A test theme",
422 author: "Mozilla",
423 homepageURL: "http://localhost:" + gPort + "/data/index.html",
424 headerURL: "http://localhost:" + gPort + "/data/header.png",
425 footerURL: "http://localhost:" + gPort + "/data/footer.png",
426 previewURL: "http://localhost:" + gPort + "/data/preview.png",
427 iconURL: "http://localhost:" + gPort + "/data/icon.png",
428 updateURL: "http://localhost:" + gPort + "/data/lwtheme.js"
429 };
430
431 // XXX The lightweight theme manager strips non-https updateURLs so hack it
432 // back in.
433 let themes = JSON.parse(Services.prefs.getCharPref("lightweightThemes.usedThemes"));
434 do_check_eq(themes.length, 1);
435 themes[0].updateURL = "http://localhost:" + gPort + "/data/lwtheme.js";
436 Services.prefs.setCharPref("lightweightThemes.usedThemes", JSON.stringify(themes));
437
438 testserver.registerPathHandler("/data/lwtheme.js", function(request, response) {
439 response.write(JSON.stringify({
440 id: "1",
441 version: "2",
442 name: "Updated Theme",
443 description: "A test theme",
444 author: "Mozilla",
445 homepageURL: "http://localhost:" + gPort + "/data/index2.html",
446 headerURL: "http://localhost:" + gPort + "/data/header.png",
447 footerURL: "http://localhost:" + gPort + "/data/footer.png",
448 previewURL: "http://localhost:" + gPort + "/data/preview.png",
449 iconURL: "http://localhost:" + gPort + "/data/icon2.png",
450 updateURL: "http://localhost:" + gPort + "/data/lwtheme.js"
451 }));
452 });
453
454 AddonManager.getAddonByID("1@personas.mozilla.org", function(p1) {
455 do_check_neq(p1, null);
456 do_check_eq(p1.version, "1");
457 do_check_eq(p1.name, "Test LW Theme");
458 do_check_true(p1.isActive);
459 do_check_eq(p1.installDate.getTime(), p1.updateDate.getTime());
460
461 // 5 seconds leeway seems like a lot, but tests can run slow and really if
462 // this is within 5 seconds it is fine. If it is going to be wrong then it
463 // is likely to be hours out at least
464 do_check_true((Date.now() - p1.installDate.getTime()) < 5000);
465
466 gInstallDate = p1.installDate.getTime();
467
468 prepare_test({
469 "1@personas.mozilla.org": [
470 ["onInstalling", false],
471 "onInstalled"
472 ]
473 }, [
474 "onExternalInstall"
475 ], check_test_7);
476
477 // Fake a timer event to cause a background update and wait for the magic to
478 // happen
479 gInternalManager.notify(null);
480 });
481 }
482
483 function check_test_7() {
484 AddonManager.getAddonByID("1@personas.mozilla.org", function(p1) {
485 do_check_neq(p1, null);
486 do_check_eq(p1.version, "2");
487 do_check_eq(p1.name, "Updated Theme");
488 do_check_eq(p1.installDate.getTime(), gInstallDate);
489 do_check_true(p1.installDate.getTime() < p1.updateDate.getTime());
490
491 // 5 seconds leeway seems like a lot, but tests can run slow and really if
492 // this is within 5 seconds it is fine. If it is going to be wrong then it
493 // is likely to be hours out at least
494 do_check_true((Date.now() - p1.updateDate.getTime()) < 5000);
495
496 gInstallDate = p1.installDate.getTime();
497
498 do_execute_soon(run_test_8);
499 });
500 }
501
502 // Verify the parameter escaping in update urls.
503 function run_test_8() {
504 writeInstallRDFForExtension({
505 id: "addon1@tests.mozilla.org",
506 version: "5.0",
507 updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,
508 targetApplications: [{
509 id: "xpcshell@tests.mozilla.org",
510 minVersion: "1",
511 maxVersion: "2"
512 }],
513 name: "Test Addon 1",
514 }, profileDir);
515
516 writeInstallRDFForExtension({
517 id: "addon2@tests.mozilla.org",
518 version: "67.0.5b1",
519 updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,
520 targetApplications: [{
521 id: "toolkit@mozilla.org",
522 minVersion: "0",
523 maxVersion: "3"
524 }],
525 name: "Test Addon 2",
526 }, profileDir);
527
528 writeInstallRDFForExtension({
529 id: "addon3@tests.mozilla.org",
530 version: "1.3+",
531 updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,
532 targetApplications: [{
533 id: "xpcshell@tests.mozilla.org",
534 minVersion: "0",
535 maxVersion: "0"
536 }, {
537 id: "toolkit@mozilla.org",
538 minVersion: "0",
539 maxVersion: "3"
540 }],
541 name: "Test Addon 3",
542 }, profileDir);
543
544 writeInstallRDFForExtension({
545 id: "addon4@tests.mozilla.org",
546 version: "0.5ab6",
547 updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,
548 targetApplications: [{
549 id: "xpcshell@tests.mozilla.org",
550 minVersion: "1",
551 maxVersion: "5"
552 }],
553 name: "Test Addon 4",
554 }, profileDir);
555
556 writeInstallRDFForExtension({
557 id: "addon5@tests.mozilla.org",
558 version: "1.0",
559 updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,
560 targetApplications: [{
561 id: "xpcshell@tests.mozilla.org",
562 minVersion: "1",
563 maxVersion: "1"
564 }],
565 name: "Test Addon 5",
566 }, profileDir);
567
568 writeInstallRDFForExtension({
569 id: "addon6@tests.mozilla.org",
570 version: "1.0",
571 updateURL: "http://localhost:" + gPort + "/data/param_test.rdf" + PARAMS,
572 targetApplications: [{
573 id: "xpcshell@tests.mozilla.org",
574 minVersion: "1",
575 maxVersion: "1"
576 }],
577 name: "Test Addon 6",
578 }, profileDir);
579
580 restartManager();
581
582 AddonManager.getAddonByID("addon2@tests.mozilla.org", callback_soon(function(a2) {
583 a2.userDisabled = true;
584 restartManager();
585
586 testserver.registerPathHandler("/data/param_test.rdf", function(request, response) {
587 do_check_neq(request.queryString, "");
588 let [req_version, item_id, item_version,
589 item_maxappversion, item_status,
590 app_id, app_version, current_app_version,
591 app_os, app_abi, app_locale, update_type] =
592 [decodeURIComponent(a) for each (a in request.queryString.split("/"))];
593
594 do_check_eq(req_version, "2");
595
596 switch(item_id) {
597 case "addon1@tests.mozilla.org":
598 do_check_eq(item_version, "5.0");
599 do_check_eq(item_maxappversion, "2");
600 do_check_eq(item_status, "userEnabled");
601 do_check_eq(app_version, "1");
602 do_check_eq(update_type, "97");
603 break;
604 case "addon2@tests.mozilla.org":
605 do_check_eq(item_version, "67.0.5b1");
606 do_check_eq(item_maxappversion, "3");
607 do_check_eq(item_status, "userDisabled");
608 do_check_eq(app_version, "1");
609 do_check_eq(update_type, "49");
610 break;
611 case "addon3@tests.mozilla.org":
612 do_check_eq(item_version, "1.3+");
613 do_check_eq(item_maxappversion, "0");
614 do_check_eq(item_status, "userEnabled,incompatible");
615 do_check_eq(app_version, "1");
616 do_check_eq(update_type, "112");
617 break;
618 case "addon4@tests.mozilla.org":
619 do_check_eq(item_version, "0.5ab6");
620 do_check_eq(item_maxappversion, "5");
621 do_check_eq(item_status, "userEnabled");
622 do_check_eq(app_version, "2");
623 do_check_eq(update_type, "98");
624 break;
625 case "addon5@tests.mozilla.org":
626 do_check_eq(item_version, "1.0");
627 do_check_eq(item_maxappversion, "1");
628 do_check_eq(item_status, "userEnabled");
629 do_check_eq(app_version, "1");
630 do_check_eq(update_type, "35");
631 break;
632 case "addon6@tests.mozilla.org":
633 do_check_eq(item_version, "1.0");
634 do_check_eq(item_maxappversion, "1");
635 do_check_eq(item_status, "userEnabled");
636 do_check_eq(app_version, "1");
637 do_check_eq(update_type, "99");
638 break;
639 default:
640 do_throw("Update request for unexpected add-on " + item_id);
641 }
642
643 do_check_eq(app_id, "xpcshell@tests.mozilla.org");
644 do_check_eq(current_app_version, "1");
645 do_check_eq(app_os, "XPCShell");
646 do_check_eq(app_abi, "noarch-spidermonkey");
647 do_check_eq(app_locale, "fr-FR");
648
649 request.setStatusLine(null, 500, "Server Error");
650 });
651
652 AddonManager.getAddonsByIDs(["addon1@tests.mozilla.org",
653 "addon2@tests.mozilla.org",
654 "addon3@tests.mozilla.org",
655 "addon4@tests.mozilla.org",
656 "addon5@tests.mozilla.org",
657 "addon6@tests.mozilla.org"],
658 function([a1, a2, a3, a4, a5, a6]) {
659 let count = 6;
660
661 function run_next_test() {
662 a1.uninstall();
663 a2.uninstall();
664 a3.uninstall();
665 a4.uninstall();
666 a5.uninstall();
667 a6.uninstall();
668
669 restartManager();
670 run_test_9();
671 }
672
673 let compatListener = {
674 onUpdateFinished: function(addon, error) {
675 if (--count == 0)
676 do_execute_soon(run_next_test);
677 }
678 };
679
680 let updateListener = {
681 onUpdateAvailable: function(addon, update) {
682 // Dummy so the update checker knows we care about new versions
683 },
684
685 onUpdateFinished: function(addon, error) {
686 if (--count == 0)
687 do_execute_soon(run_next_test);
688 }
689 };
690
691 a1.findUpdates(updateListener, AddonManager.UPDATE_WHEN_USER_REQUESTED);
692 a2.findUpdates(compatListener, AddonManager.UPDATE_WHEN_ADDON_INSTALLED);
693 a3.findUpdates(updateListener, AddonManager.UPDATE_WHEN_PERIODIC_UPDATE);
694 a4.findUpdates(updateListener, AddonManager.UPDATE_WHEN_NEW_APP_DETECTED, "2");
695 a5.findUpdates(compatListener, AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED);
696 a6.findUpdates(updateListener, AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED);
697 });
698 }));
699 }
700
701 // Tests that if an install.rdf claims compatibility then the add-on will be
702 // seen as compatible regardless of what the update.rdf says.
703 function run_test_9() {
704 writeInstallRDFForExtension({
705 id: "addon4@tests.mozilla.org",
706 version: "5.0",
707 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
708 targetApplications: [{
709 id: "xpcshell@tests.mozilla.org",
710 minVersion: "0",
711 maxVersion: "1"
712 }],
713 name: "Test Addon 1",
714 }, profileDir);
715
716 restartManager();
717
718 AddonManager.getAddonByID("addon4@tests.mozilla.org", function(a4) {
719 do_check_true(a4.isActive);
720 do_check_true(a4.isCompatible);
721
722 run_test_10();
723 });
724 }
725
726 // Tests that a normal update check won't decrease a targetApplication's
727 // maxVersion.
728 function run_test_10() {
729 AddonManager.getAddonByID("addon4@tests.mozilla.org", function(a4) {
730 a4.findUpdates({
731 onUpdateFinished: function(addon) {
732 do_check_true(addon.isCompatible);
733
734 run_test_11();
735 }
736 }, AddonManager.UPDATE_WHEN_PERIODIC_UPDATE);
737 });
738 }
739
740 // Tests that an update check for a new application will decrease a
741 // targetApplication's maxVersion.
742 function run_test_11() {
743 AddonManager.getAddonByID("addon4@tests.mozilla.org", function(a4) {
744 a4.findUpdates({
745 onUpdateFinished: function(addon) {
746 do_check_false(addon.isCompatible);
747
748 do_execute_soon(run_test_12);
749 }
750 }, AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED);
751 });
752 }
753
754 // Check that the decreased maxVersion applied and disables the add-on
755 function run_test_12() {
756 restartManager();
757
758 AddonManager.getAddonByID("addon4@tests.mozilla.org", function(a4) {
759 do_check_false(a4.isActive);
760 do_check_false(a4.isCompatible);
761
762 a4.uninstall();
763 do_execute_soon(run_test_13);
764 });
765 }
766
767 // Tests that no compatibility update is passed to the listener when there is
768 // compatibility info for the current version of the app but not for the
769 // version of the app that the caller requested an update check for.
770 function run_test_13() {
771 restartManager();
772
773 // Not initially compatible but the update check will make it compatible
774 writeInstallRDFForExtension({
775 id: "addon7@tests.mozilla.org",
776 version: "1.0",
777 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
778 targetApplications: [{
779 id: "xpcshell@tests.mozilla.org",
780 minVersion: "0",
781 maxVersion: "0"
782 }],
783 name: "Test Addon 7",
784 }, profileDir);
785 restartManager();
786
787 AddonManager.getAddonByID("addon7@tests.mozilla.org", function(a7) {
788 do_check_neq(a7, null);
789 do_check_false(a7.isActive);
790 do_check_false(a7.isCompatible);
791 do_check_true(a7.appDisabled);
792 do_check_true(a7.isCompatibleWith("0"));
793
794 a7.findUpdates({
795 sawUpdate: false,
796 onCompatibilityUpdateAvailable: function(addon) {
797 do_throw("Should have not have seen compatibility information");
798 },
799
800 onUpdateAvailable: function(addon, install) {
801 do_throw("Should not have seen an available update");
802 },
803
804 onUpdateFinished: function(addon) {
805 do_check_true(addon.isCompatible);
806 do_execute_soon(check_test_13);
807 }
808 }, AddonManager.UPDATE_WHEN_NEW_APP_DETECTED, "3.0");
809 });
810 }
811
812 function check_test_13() {
813 restartManager();
814 AddonManager.getAddonByID("addon7@tests.mozilla.org", function(a7) {
815 do_check_neq(a7, null);
816 do_check_true(a7.isActive);
817 do_check_true(a7.isCompatible);
818 do_check_false(a7.appDisabled);
819
820 a7.uninstall();
821 do_execute_soon(run_test_14);
822 });
823 }
824
825 // Test that background update checks doesn't update an add-on that isn't
826 // allowed to update automatically.
827 function run_test_14() {
828 restartManager();
829
830 // Have an add-on there that will be updated so we see some events from it
831 writeInstallRDFForExtension({
832 id: "addon1@tests.mozilla.org",
833 version: "1.0",
834 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
835 targetApplications: [{
836 id: "xpcshell@tests.mozilla.org",
837 minVersion: "1",
838 maxVersion: "1"
839 }],
840 name: "Test Addon 1",
841 }, profileDir);
842
843 writeInstallRDFForExtension({
844 id: "addon8@tests.mozilla.org",
845 version: "1.0",
846 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
847 targetApplications: [{
848 id: "xpcshell@tests.mozilla.org",
849 minVersion: "1",
850 maxVersion: "1"
851 }],
852 name: "Test Addon 8",
853 }, profileDir);
854 restartManager();
855
856 AddonManager.getAddonByID("addon8@tests.mozilla.org", function(a8) {
857 a8.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DISABLE;
858
859 // The background update check will find updates for both add-ons but only
860 // proceed to install one of them.
861 AddonManager.addInstallListener({
862 onNewInstall: function(aInstall) {
863 if (aInstall.existingAddon.id != "addon1@tests.mozilla.org" &&
864 aInstall.existingAddon.id != "addon8@tests.mozilla.org")
865 do_throw("Saw unexpected onNewInstall for " + aInstall.existingAddon.id);
866 },
867
868 onDownloadStarted: function(aInstall) {
869 do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");
870 },
871
872 onDownloadEnded: function(aInstall) {
873 do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");
874 },
875
876 onDownloadFailed: function(aInstall) {
877 do_throw("Should not have seen onDownloadFailed event");
878 },
879
880 onDownloadCancelled: function(aInstall) {
881 do_throw("Should not have seen onDownloadCancelled event");
882 },
883
884 onInstallStarted: function(aInstall) {
885 do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");
886 },
887
888 onInstallEnded: function(aInstall) {
889 do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");
890 do_check_eq(aInstall.existingAddon.pendingUpgrade.install, aInstall);
891 do_execute_soon(check_test_14);
892 },
893
894 onInstallFailed: function(aInstall) {
895 do_throw("Should not have seen onInstallFailed event");
896 },
897
898 onInstallCancelled: function(aInstall) {
899 do_throw("Should not have seen onInstallCancelled event");
900 },
901 });
902
903 // Fake a timer event
904 gInternalManager.notify(null);
905 });
906 }
907
908 function check_test_14() {
909 restartManager();
910 AddonManager.getAddonsByIDs(["addon1@tests.mozilla.org",
911 "addon8@tests.mozilla.org"], function([a1, a8]) {
912 do_check_neq(a1, null);
913 do_check_eq(a1.version, "2.0");
914 a1.uninstall();
915
916 do_check_neq(a8, null);
917 do_check_eq(a8.version, "1.0");
918 a8.uninstall();
919
920 do_execute_soon(run_test_15);
921 });
922 }
923
924 // Test that background update checks doesn't update an add-on that is
925 // pending uninstall
926 function run_test_15() {
927 restartManager();
928
929 // Have an add-on there that will be updated so we see some events from it
930 writeInstallRDFForExtension({
931 id: "addon1@tests.mozilla.org",
932 version: "1.0",
933 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
934 targetApplications: [{
935 id: "xpcshell@tests.mozilla.org",
936 minVersion: "1",
937 maxVersion: "1"
938 }],
939 name: "Test Addon 1",
940 }, profileDir);
941
942 writeInstallRDFForExtension({
943 id: "addon8@tests.mozilla.org",
944 version: "1.0",
945 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
946 targetApplications: [{
947 id: "xpcshell@tests.mozilla.org",
948 minVersion: "1",
949 maxVersion: "1"
950 }],
951 name: "Test Addon 8",
952 }, profileDir);
953 restartManager();
954
955 AddonManager.getAddonByID("addon8@tests.mozilla.org", function(a8) {
956 a8.uninstall();
957 do_check_false(hasFlag(a8.permissions, AddonManager.PERM_CAN_UPGRADE));
958
959 // The background update check will find updates for both add-ons but only
960 // proceed to install one of them.
961 AddonManager.addInstallListener({
962 onNewInstall: function(aInstall) {
963 if (aInstall.existingAddon.id != "addon1@tests.mozilla.org" &&
964 aInstall.existingAddon.id != "addon8@tests.mozilla.org")
965 do_throw("Saw unexpected onNewInstall for " + aInstall.existingAddon.id);
966 },
967
968 onDownloadStarted: function(aInstall) {
969 do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");
970 },
971
972 onDownloadEnded: function(aInstall) {
973 do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");
974 },
975
976 onDownloadFailed: function(aInstall) {
977 do_throw("Should not have seen onDownloadFailed event");
978 },
979
980 onDownloadCancelled: function(aInstall) {
981 do_throw("Should not have seen onDownloadCancelled event");
982 },
983
984 onInstallStarted: function(aInstall) {
985 do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");
986 },
987
988 onInstallEnded: function(aInstall) {
989 do_check_eq(aInstall.existingAddon.id, "addon1@tests.mozilla.org");
990 do_execute_soon(check_test_15);
991 },
992
993 onInstallFailed: function(aInstall) {
994 do_throw("Should not have seen onInstallFailed event");
995 },
996
997 onInstallCancelled: function(aInstall) {
998 do_throw("Should not have seen onInstallCancelled event");
999 },
1000 });
1001
1002 // Fake a timer event
1003 gInternalManager.notify(null);
1004 });
1005 }
1006
1007 function check_test_15() {
1008 restartManager();
1009 AddonManager.getAddonsByIDs(["addon1@tests.mozilla.org",
1010 "addon8@tests.mozilla.org"], function([a1, a8]) {
1011 do_check_neq(a1, null);
1012 do_check_eq(a1.version, "2.0");
1013 a1.uninstall();
1014
1015 do_check_eq(a8, null);
1016
1017 do_execute_soon(run_test_16);
1018 });
1019 }
1020
1021 // Test that the update check correctly observes the
1022 // extensions.strictCompatibility pref and compatibility overrides.
1023 function run_test_16() {
1024 restartManager();
1025
1026 writeInstallRDFForExtension({
1027 id: "addon9@tests.mozilla.org",
1028 version: "1.0",
1029 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
1030 targetApplications: [{
1031 id: "xpcshell@tests.mozilla.org",
1032 minVersion: "0.1",
1033 maxVersion: "0.2"
1034 }],
1035 name: "Test Addon 9",
1036 }, profileDir);
1037 restartManager();
1038
1039 AddonManager.addInstallListener({
1040 onNewInstall: function(aInstall) {
1041 if (aInstall.existingAddon.id != "addon9@tests.mozilla.org")
1042 do_throw("Saw unexpected onNewInstall for " + aInstall.existingAddon.id);
1043 do_check_eq(aInstall.version, "2.0");
1044 },
1045 onDownloadFailed: function(aInstall) {
1046 do_execute_soon(run_test_17);
1047 }
1048 });
1049
1050 Services.prefs.setCharPref(PREF_GETADDONS_BYIDS_PERFORMANCE,
1051 "http://localhost:" + gPort + "/data/test_update.xml");
1052 Services.prefs.setBoolPref(PREF_GETADDONS_CACHE_ENABLED, true);
1053 // Fake a timer event
1054 gInternalManager.notify(null);
1055 }
1056
1057 // Test that the update check correctly observes when an addon opts-in to
1058 // strict compatibility checking.
1059 function run_test_17() {
1060
1061 writeInstallRDFForExtension({
1062 id: "addon11@tests.mozilla.org",
1063 version: "1.0",
1064 updateURL: "http://localhost:" + gPort + "/data/test_update.rdf",
1065 targetApplications: [{
1066 id: "xpcshell@tests.mozilla.org",
1067 minVersion: "0.1",
1068 maxVersion: "0.2"
1069 }],
1070 name: "Test Addon 11",
1071 }, profileDir);
1072 restartManager();
1073
1074 AddonManager.getAddonByID("addon11@tests.mozilla.org", function(a11) {
1075 do_check_neq(a11, null);
1076
1077 a11.findUpdates({
1078 onCompatibilityUpdateAvailable: function() {
1079 do_throw("Should have not have seen compatibility information");
1080 },
1081
1082 onUpdateAvailable: function() {
1083 do_throw("Should not have seen an available update");
1084 },
1085
1086 onUpdateFinished: function() {
1087 do_execute_soon(end_test);
1088 }
1089 }, AddonManager.UPDATE_WHEN_USER_REQUESTED);
1090 });
1091 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial