The Tor Browser / file comparison

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

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

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:24f0b4a538b3
1 /* Any copyright is dedicated to the Public Domain.
2 * http://creativecommons.org/publicdomain/zero/1.0/
3 */
4
5 // This verifies that add-ons can be installed from XPI files
6 const Cc = Components.classes;
7 const Ci = Components.interfaces;
8 const Cu = Components.utils;
9
10 // Maximum error in file modification times. Some file systems don't store
11 // modification times exactly. As long as we are closer than this then it
12 // still passes.
13 const MAX_TIME_DIFFERENCE = 3000;
14
15 // install.rdf size, icon.png, icon64.png size
16 const ADDON1_SIZE = 705 + 16 + 16;
17
18 Cu.import("resource://gre/modules/Services.jsm");
19 Cu.import("resource://gre/modules/NetUtil.jsm");
20 Cu.import("resource://testing-common/httpd.js");
21
22 var testserver;
23 var gInstallDate;
24 var gInstall = null;
25
26 // The test extension uses an insecure update url.
27 Services.prefs.setBoolPref(PREF_EM_CHECK_UPDATE_SECURITY, false);
28 Services.prefs.setBoolPref(PREF_EM_STRICT_COMPATIBILITY, true);
29
30
31 const profileDir = gProfD.clone();
32 profileDir.append("extensions");
33
34 function run_test() {
35 createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
36
37 startupManager();
38 // Make sure we only register once despite multiple calls
39 AddonManager.addInstallListener(InstallListener);
40 AddonManager.addAddonListener(AddonListener);
41 AddonManager.addInstallListener(InstallListener);
42 AddonManager.addAddonListener(AddonListener);
43
44 // Create and configure the HTTP server.
45 testserver = new HttpServer();
46 testserver.registerDirectory("/addons/", do_get_file("addons"));
47 testserver.registerDirectory("/data/", do_get_file("data"));
48 testserver.registerPathHandler("/redirect", function(aRequest, aResponse) {
49 aResponse.setStatusLine(null, 301, "Moved Permanently");
50 let url = aRequest.host + ":" + aRequest.port + aRequest.queryString;
51 aResponse.setHeader("Location", "http://" + url);
52 });
53 testserver.start(4444);
54
55 do_test_pending();
56 run_test_1();
57 }
58
59 function end_test() {
60 testserver.stop(do_test_finished);
61 }
62
63 // Checks that an install from a local file proceeds as expected
64 function run_test_1() {
65 prepare_test({ }, [
66 "onNewInstall"
67 ]);
68
69 AddonManager.getInstallForFile(do_get_addon("test_install1"), function(install) {
70 ensure_test_completed();
71
72 do_check_neq(install, null);
73 do_check_eq(install.linkedInstalls, null);
74 do_check_eq(install.type, "extension");
75 do_check_eq(install.version, "1.0");
76 do_check_eq(install.name, "Test 1");
77 do_check_eq(install.state, AddonManager.STATE_DOWNLOADED);
78 do_check_true(install.addon.hasResource("install.rdf"));
79 do_check_eq(install.addon.install, install);
80 do_check_eq(install.addon.size, ADDON1_SIZE);
81 do_check_true(hasFlag(install.addon.operationsRequiringRestart,
82 AddonManager.OP_NEEDS_RESTART_INSTALL));
83 let file = do_get_addon("test_install1");
84 let uri = Services.io.newFileURI(file).spec;
85 do_check_eq(install.addon.getResourceURI("install.rdf").spec, "jar:" + uri + "!/install.rdf");
86 do_check_eq(install.addon.iconURL, "jar:" + uri + "!/icon.png");
87 do_check_eq(install.addon.icon64URL, "jar:" + uri + "!/icon64.png");
88 do_check_eq(install.iconURL, null);
89
90 do_check_eq(install.sourceURI.spec, uri);
91 do_check_eq(install.addon.sourceURI.spec, uri);
92
93 AddonManager.getAllInstalls(function(activeInstalls) {
94 do_check_eq(activeInstalls.length, 1);
95 do_check_eq(activeInstalls[0], install);
96
97 AddonManager.getInstallsByTypes(["foo"], function(fooInstalls) {
98 do_check_eq(fooInstalls.length, 0);
99
100 AddonManager.getInstallsByTypes(["extension"], function(extensionInstalls) {
101 do_check_eq(extensionInstalls.length, 1);
102 do_check_eq(extensionInstalls[0], install);
103
104 prepare_test({
105 "addon1@tests.mozilla.org": [
106 "onInstalling"
107 ]
108 }, [
109 "onInstallStarted",
110 "onInstallEnded",
111 ], check_test_1);
112 install.install();
113 });
114 });
115 });
116 });
117 }
118
119 function check_test_1() {
120 ensure_test_completed();
121 AddonManager.getAddonByID("addon1@tests.mozilla.org", function(olda1) {
122 do_check_eq(olda1, null);
123
124 AddonManager.getAddonsWithOperationsByTypes(null, callback_soon(function(pendingAddons) {
125 do_check_eq(pendingAddons.length, 1);
126 do_check_eq(pendingAddons[0].id, "addon1@tests.mozilla.org");
127 let uri = NetUtil.newURI(pendingAddons[0].iconURL);
128 if (uri instanceof AM_Ci.nsIJARURI) {
129 let jarURI = uri.QueryInterface(AM_Ci.nsIJARURI);
130 let archiveURI = jarURI.JARFile;
131 let archiveFile = archiveURI.QueryInterface(AM_Ci.nsIFileURL).file;
132 let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
133 createInstance(Ci.nsIZipReader);
134 try {
135 zipReader.open(archiveFile);
136 do_check_true(zipReader.hasEntry(jarURI.JAREntry));
137 }
138 finally {
139 zipReader.close();
140 }
141 }
142 else {
143 let iconFile = uri.QueryInterface(AM_Ci.nsIFileURL).file;
144 do_check_true(iconFile.exists());
145 }
146
147 // Make the pending install have a sensible date
148 let updateDate = Date.now();
149 let extURI = pendingAddons[0].getResourceURI("");
150 let ext = extURI.QueryInterface(AM_Ci.nsIFileURL).file;
151 setExtensionModifiedTime(ext, updateDate);
152
153 // The pending add-on cannot be disabled or enabled.
154 do_check_false(hasFlag(pendingAddons[0].permissions, AddonManager.PERM_CAN_ENABLE));
155 do_check_false(hasFlag(pendingAddons[0].permissions, AddonManager.PERM_CAN_DISABLE));
156
157 restartManager();
158
159 AddonManager.getAllInstalls(function(activeInstalls) {
160 do_check_eq(activeInstalls, 0);
161
162 AddonManager.getAddonByID("addon1@tests.mozilla.org", function(a1) {
163 do_check_neq(a1, null);
164 do_check_eq(a1.type, "extension");
165 do_check_eq(a1.version, "1.0");
166 do_check_eq(a1.name, "Test 1");
167 do_check_true(isExtensionInAddonsList(profileDir, a1.id));
168 do_check_true(do_get_addon("test_install1").exists());
169 do_check_in_crash_annotation(a1.id, a1.version);
170 do_check_eq(a1.size, ADDON1_SIZE);
171
172 do_check_eq(a1.sourceURI.spec,
173 Services.io.newFileURI(do_get_addon("test_install1")).spec);
174 let difference = a1.installDate.getTime() - updateDate;
175 if (Math.abs(difference) > MAX_TIME_DIFFERENCE)
176 do_throw("Add-on install time was out by " + difference + "ms");
177
178 difference = a1.updateDate.getTime() - updateDate;
179 if (Math.abs(difference) > MAX_TIME_DIFFERENCE)
180 do_throw("Add-on update time was out by " + difference + "ms");
181
182 do_check_true(a1.hasResource("install.rdf"));
183 do_check_false(a1.hasResource("foo.bar"));
184
185 let uri = do_get_addon_root_uri(profileDir, "addon1@tests.mozilla.org");
186 do_check_eq(a1.getResourceURI("install.rdf").spec, uri + "install.rdf");
187 do_check_eq(a1.iconURL, uri + "icon.png");
188 do_check_eq(a1.icon64URL, uri + "icon64.png");
189
190 a1.uninstall();
191 do_execute_soon(function(){run_test_2(a1)});
192 });
193 });
194 }));
195 });
196 }
197
198 // Tests that an install from a url downloads.
199 function run_test_2(aAddon) {
200 restartManager();
201 do_check_not_in_crash_annotation(aAddon.id, aAddon.version);
202
203 let url = "http://localhost:4444/addons/test_install2_1.xpi";
204 AddonManager.getInstallForURL(url, function(install) {
205 do_check_neq(install, null);
206 do_check_eq(install.linkedInstalls, null);
207 do_check_eq(install.version, "1.0");
208 do_check_eq(install.name, "Test 2");
209 do_check_eq(install.state, AddonManager.STATE_AVAILABLE);
210 do_check_eq(install.iconURL, null);
211 do_check_eq(install.sourceURI.spec, url);
212
213 AddonManager.getAllInstalls(function(activeInstalls) {
214 do_check_eq(activeInstalls.length, 1);
215 do_check_eq(activeInstalls[0], install);
216
217 prepare_test({}, [
218 "onDownloadStarted",
219 "onDownloadEnded",
220 ], check_test_2);
221
222 install.addListener({
223 onDownloadProgress: function(install) {
224 do_execute_soon(function() {
225 Components.utils.forceGC();
226 });
227 }
228 });
229
230 install.install();
231 });
232 }, "application/x-xpinstall", null, "Test 2", null, "1.0");
233 }
234
235 function check_test_2(install) {
236 ensure_test_completed();
237 do_check_eq(install.version, "2.0");
238 do_check_eq(install.name, "Real Test 2");
239 do_check_eq(install.state, AddonManager.STATE_DOWNLOADED);
240 do_check_eq(install.addon.install, install);
241 do_check_true(hasFlag(install.addon.operationsRequiringRestart,
242 AddonManager.OP_NEEDS_RESTART_INSTALL));
243 do_check_eq(install.iconURL, null);
244
245 // Pause the install here and start it again in run_test_3
246 do_execute_soon(function() { run_test_3(install); });
247 return false;
248 }
249
250 // Tests that the downloaded XPI installs ok
251 function run_test_3(install) {
252 prepare_test({
253 "addon2@tests.mozilla.org": [
254 "onInstalling"
255 ]
256 }, [
257 "onInstallStarted",
258 "onInstallEnded",
259 ], check_test_3);
260 install.install();
261 }
262
263 function check_test_3(aInstall) {
264 // Make the pending install have a sensible date
265 let updateDate = Date.now();
266 let extURI = aInstall.addon.getResourceURI("");
267 let ext = extURI.QueryInterface(AM_Ci.nsIFileURL).file;
268 setExtensionModifiedTime(ext, updateDate);
269
270 ensure_test_completed();
271 AddonManager.getAddonByID("addon2@tests.mozilla.org", callback_soon(function(olda2) {
272 do_check_eq(olda2, null);
273 restartManager();
274
275 AddonManager.getAllInstalls(function(installs) {
276 do_check_eq(installs, 0);
277
278 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
279 do_check_neq(a2, null);
280 do_check_eq(a2.type, "extension");
281 do_check_eq(a2.version, "2.0");
282 do_check_eq(a2.name, "Real Test 2");
283 do_check_true(isExtensionInAddonsList(profileDir, a2.id));
284 do_check_true(do_get_addon("test_install2_1").exists());
285 do_check_in_crash_annotation(a2.id, a2.version);
286 do_check_eq(a2.sourceURI.spec,
287 "http://localhost:4444/addons/test_install2_1.xpi");
288
289 let difference = a2.installDate.getTime() - updateDate;
290 if (Math.abs(difference) > MAX_TIME_DIFFERENCE)
291 do_throw("Add-on install time was out by " + difference + "ms");
292
293 difference = a2.updateDate.getTime() - updateDate;
294 if (Math.abs(difference) > MAX_TIME_DIFFERENCE)
295 do_throw("Add-on update time was out by " + difference + "ms");
296
297 gInstallDate = a2.installDate.getTime();
298
299 run_test_4();
300 });
301 });
302 }));
303 }
304
305 // Tests that installing a new version of an existing add-on works
306 function run_test_4() {
307 prepare_test({ }, [
308 "onNewInstall"
309 ]);
310
311 let url = "http://localhost:4444/addons/test_install2_2.xpi";
312 AddonManager.getInstallForURL(url, function(install) {
313 ensure_test_completed();
314
315 do_check_neq(install, null);
316 do_check_eq(install.version, "3.0");
317 do_check_eq(install.name, "Test 3");
318 do_check_eq(install.state, AddonManager.STATE_AVAILABLE);
319
320 AddonManager.getAllInstalls(function(activeInstalls) {
321 do_check_eq(activeInstalls.length, 1);
322 do_check_eq(activeInstalls[0], install);
323 do_check_eq(install.existingAddon, null);
324
325 prepare_test({}, [
326 "onDownloadStarted",
327 "onDownloadEnded",
328 ], check_test_4);
329 install.install();
330 });
331 }, "application/x-xpinstall", null, "Test 3", null, "3.0");
332 }
333
334 function check_test_4(install) {
335 ensure_test_completed();
336
337 do_check_eq(install.version, "3.0");
338 do_check_eq(install.name, "Real Test 3");
339 do_check_eq(install.state, AddonManager.STATE_DOWNLOADED);
340 do_check_neq(install.existingAddon);
341 do_check_eq(install.existingAddon.id, "addon2@tests.mozilla.org");
342 do_check_eq(install.addon.install, install);
343 do_check_true(hasFlag(install.addon.operationsRequiringRestart,
344 AddonManager.OP_NEEDS_RESTART_INSTALL));
345
346 run_test_5();
347 // Installation will continue when there is nothing returned.
348 }
349
350 // Continue installing the new version
351 function run_test_5() {
352 prepare_test({
353 "addon2@tests.mozilla.org": [
354 "onInstalling"
355 ]
356 }, [
357 "onInstallStarted",
358 "onInstallEnded",
359 ], check_test_5);
360 }
361
362 function check_test_5(install) {
363 ensure_test_completed();
364
365 do_check_eq(install.existingAddon.pendingUpgrade.install, install);
366
367 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(olda2) {
368 do_check_neq(olda2, null);
369 do_check_true(hasFlag(olda2.pendingOperations, AddonManager.PENDING_UPGRADE));
370
371 AddonManager.getInstallsByTypes(null, callback_soon(function(installs) {
372 do_check_eq(installs.length, 1);
373 do_check_eq(installs[0].addon, olda2.pendingUpgrade);
374 restartManager();
375
376 AddonManager.getInstallsByTypes(null, function(installs) {
377 do_check_eq(installs.length, 0);
378
379 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
380 do_check_neq(a2, null);
381 do_check_eq(a2.type, "extension");
382 do_check_eq(a2.version, "3.0");
383 do_check_eq(a2.name, "Real Test 3");
384 do_check_true(a2.isActive);
385 do_check_true(isExtensionInAddonsList(profileDir, a2.id));
386 do_check_true(do_get_addon("test_install2_2").exists());
387 do_check_in_crash_annotation(a2.id, a2.version);
388 do_check_eq(a2.sourceURI.spec,
389 "http://localhost:4444/addons/test_install2_2.xpi");
390
391 do_check_eq(a2.installDate.getTime(), gInstallDate);
392 // Update date should be later (or the same if this test is too fast)
393 do_check_true(a2.installDate <= a2.updateDate);
394
395 a2.uninstall();
396 do_execute_soon(run_test_6);
397 });
398 });
399 }));
400 });
401 }
402
403 // Tests that an install that requires a compatibility update works
404 function run_test_6() {
405 restartManager();
406
407 prepare_test({ }, [
408 "onNewInstall"
409 ]);
410
411 let url = "http://localhost:4444/addons/test_install3.xpi";
412 AddonManager.getInstallForURL(url, function(install) {
413 ensure_test_completed();
414
415 do_check_neq(install, null);
416 do_check_eq(install.version, "1.0");
417 do_check_eq(install.name, "Real Test 4");
418 do_check_eq(install.state, AddonManager.STATE_AVAILABLE);
419
420 AddonManager.getInstallsByTypes(null, function(activeInstalls) {
421 do_check_eq(activeInstalls.length, 1);
422 do_check_eq(activeInstalls[0], install);
423
424 prepare_test({}, [
425 "onDownloadStarted",
426 "onDownloadEnded",
427 ], check_test_6);
428 install.install();
429 });
430 }, "application/x-xpinstall", null, "Real Test 4", null, "1.0");
431 }
432
433 function check_test_6(install) {
434 ensure_test_completed();
435 do_check_eq(install.version, "1.0");
436 do_check_eq(install.name, "Real Test 4");
437 do_check_eq(install.state, AddonManager.STATE_DOWNLOADED);
438 do_check_eq(install.existingAddon, null);
439 do_check_false(install.addon.appDisabled);
440 run_test_7();
441 return true;
442 }
443
444 // Continue the install
445 function run_test_7() {
446 prepare_test({
447 "addon3@tests.mozilla.org": [
448 "onInstalling"
449 ]
450 }, [
451 "onInstallStarted",
452 "onInstallEnded",
453 ], check_test_7);
454 }
455
456 function check_test_7() {
457 ensure_test_completed();
458 AddonManager.getAddonByID("addon3@tests.mozilla.org", callback_soon(function(olda3) {
459 do_check_eq(olda3, null);
460 restartManager();
461
462 AddonManager.getAllInstalls(function(installs) {
463 do_check_eq(installs, 0);
464
465 AddonManager.getAddonByID("addon3@tests.mozilla.org", function(a3) {
466 do_check_neq(a3, null);
467 do_check_eq(a3.type, "extension");
468 do_check_eq(a3.version, "1.0");
469 do_check_eq(a3.name, "Real Test 4");
470 do_check_true(a3.isActive);
471 do_check_false(a3.appDisabled);
472 do_check_true(isExtensionInAddonsList(profileDir, a3.id));
473 do_check_true(do_get_addon("test_install3").exists());
474 a3.uninstall();
475 do_execute_soon(run_test_8);
476 });
477 });
478 }));
479 }
480
481 function run_test_8() {
482 restartManager();
483
484 AddonManager.addInstallListener(InstallListener);
485 AddonManager.addAddonListener(AddonListener);
486
487 prepare_test({ }, [
488 "onNewInstall"
489 ]);
490
491 AddonManager.getInstallForFile(do_get_addon("test_install3"), function(install) {
492 do_check_true(install.addon.isCompatible);
493
494 prepare_test({
495 "addon3@tests.mozilla.org": [
496 "onInstalling"
497 ]
498 }, [
499 "onInstallStarted",
500 "onInstallEnded",
501 ], callback_soon(check_test_8));
502 install.install();
503 });
504 }
505
506 function check_test_8() {
507 restartManager();
508
509 AddonManager.getAddonByID("addon3@tests.mozilla.org", function(a3) {
510 do_check_neq(a3, null);
511 do_check_eq(a3.type, "extension");
512 do_check_eq(a3.version, "1.0");
513 do_check_eq(a3.name, "Real Test 4");
514 do_check_true(a3.isActive);
515 do_check_false(a3.appDisabled);
516 do_check_true(isExtensionInAddonsList(profileDir, a3.id));
517 do_check_true(do_get_addon("test_install3").exists());
518 a3.uninstall();
519 do_execute_soon(run_test_9);
520 });
521 }
522
523 // Test that after cancelling a download it is removed from the active installs
524 function run_test_9() {
525 restartManager();
526
527 prepare_test({ }, [
528 "onNewInstall"
529 ]);
530
531 let url = "http://localhost:4444/addons/test_install3.xpi";
532 AddonManager.getInstallForURL(url, function(install) {
533 ensure_test_completed();
534
535 do_check_neq(install, null);
536 do_check_eq(install.version, "1.0");
537 do_check_eq(install.name, "Real Test 4");
538 do_check_eq(install.state, AddonManager.STATE_AVAILABLE);
539
540 AddonManager.getInstallsByTypes(null, function(activeInstalls) {
541 do_check_eq(activeInstalls.length, 1);
542 do_check_eq(activeInstalls[0], install);
543
544 prepare_test({}, [
545 "onDownloadStarted",
546 "onDownloadEnded",
547 ], check_test_9);
548 install.install();
549 });
550 }, "application/x-xpinstall", null, "Real Test 4", null, "1.0");
551 }
552
553 function check_test_9(install) {
554 prepare_test({}, [
555 "onDownloadCancelled"
556 ]);
557
558 install.cancel();
559
560 ensure_test_completed();
561
562 AddonManager.getAllInstalls(function(activeInstalls) {
563 do_check_eq(activeInstalls.length, 0);
564
565 run_test_10();
566 });
567 }
568
569 // Tests that after cancelling a pending install it is removed from the active
570 // installs
571 function run_test_10() {
572 prepare_test({ }, [
573 "onNewInstall"
574 ]);
575
576 let url = "http://localhost:4444/addons/test_install3.xpi";
577 AddonManager.getInstallForURL(url, function(install) {
578 ensure_test_completed();
579
580 do_check_neq(install, null);
581 do_check_eq(install.version, "1.0");
582 do_check_eq(install.name, "Real Test 4");
583 do_check_eq(install.state, AddonManager.STATE_AVAILABLE);
584
585 AddonManager.getInstallsByTypes(null, function(activeInstalls) {
586 do_check_eq(activeInstalls.length, 1);
587 do_check_eq(activeInstalls[0], install);
588
589 prepare_test({
590 "addon3@tests.mozilla.org": [
591 "onInstalling"
592 ]
593 }, [
594 "onDownloadStarted",
595 "onDownloadEnded",
596 "onInstallStarted",
597 "onInstallEnded"
598 ], check_test_10);
599 install.install();
600 });
601 }, "application/x-xpinstall", null, "Real Test 4", null, "1.0");
602 }
603
604 function check_test_10(install) {
605 prepare_test({
606 "addon3@tests.mozilla.org": [
607 "onOperationCancelled"
608 ]
609 }, [
610 "onInstallCancelled"
611 ]);
612
613 install.cancel();
614
615 ensure_test_completed();
616
617 AddonManager.getAllInstalls(callback_soon(function(activeInstalls) {
618 do_check_eq(activeInstalls.length, 0);
619
620 restartManager();
621
622 // Check that the install did not complete
623 AddonManager.getAddonByID("addon3@tests.mozilla.org", function(a3) {
624 do_check_eq(a3, null);
625
626 run_test_11();
627 });
628 }));
629 }
630
631 // Tests that a multi-package install shows up as multiple installs with the
632 // correct sourceURI.
633 function run_test_11() {
634 prepare_test({ }, [
635 "onNewInstall",
636 "onNewInstall",
637 "onNewInstall",
638 "onNewInstall"
639 ]);
640
641 AddonManager.getInstallForFile(do_get_addon("test_install4"), function(install) {
642 ensure_test_completed();
643 do_check_neq(install, null);
644 do_check_neq(install.linkedInstalls, null);
645 do_check_eq(install.linkedInstalls.length, 3);
646
647 // Might be in any order so sort them based on ID
648 let installs = [install].concat(install.linkedInstalls);
649 installs.sort(function(a, b) {
650 if (a.addon.id < b.addon.id)
651 return -1;
652 if (a.addon.id > b.addon.id)
653 return 1;
654 return 0;
655 });
656
657 // Comes from addon4.xpi and is made compatible by an update check
658 do_check_eq(installs[0].sourceURI, install.sourceURI);
659 do_check_eq(installs[0].addon.id, "addon4@tests.mozilla.org");
660 do_check_false(installs[0].addon.appDisabled);
661 do_check_eq(installs[0].version, "1.0");
662 do_check_eq(installs[0].name, "Multi Test 1");
663 do_check_eq(installs[0].state, AddonManager.STATE_DOWNLOADED);
664 do_check_true(hasFlag(installs[0].addon.operationsRequiringRestart,
665 AddonManager.OP_NEEDS_RESTART_INSTALL));
666
667 // Comes from addon5.jar and is compatible by default
668 do_check_eq(installs[1].sourceURI, install.sourceURI);
669 do_check_eq(installs[1].addon.id, "addon5@tests.mozilla.org");
670 do_check_false(installs[1].addon.appDisabled);
671 do_check_eq(installs[1].version, "3.0");
672 do_check_eq(installs[1].name, "Multi Test 2");
673 do_check_eq(installs[1].state, AddonManager.STATE_DOWNLOADED);
674 do_check_true(hasFlag(installs[1].addon.operationsRequiringRestart,
675 AddonManager.OP_NEEDS_RESTART_INSTALL));
676
677 // Comes from addon6.xpi and is incompatible
678 do_check_eq(installs[2].sourceURI, install.sourceURI);
679 do_check_eq(installs[2].addon.id, "addon6@tests.mozilla.org");
680 do_check_true(installs[2].addon.appDisabled);
681 do_check_eq(installs[2].version, "2.0");
682 do_check_eq(installs[2].name, "Multi Test 3");
683 do_check_eq(installs[2].state, AddonManager.STATE_DOWNLOADED);
684 do_check_false(hasFlag(installs[2].addon.operationsRequiringRestart,
685 AddonManager.OP_NEEDS_RESTART_INSTALL));
686
687 // Comes from addon7.jar and is made compatible by an update check
688 do_check_eq(installs[3].sourceURI, install.sourceURI);
689 do_check_eq(installs[3].addon.id, "addon7@tests.mozilla.org");
690 do_check_false(installs[3].addon.appDisabled);
691 do_check_eq(installs[3].version, "5.0");
692 do_check_eq(installs[3].name, "Multi Test 4");
693 do_check_eq(installs[3].state, AddonManager.STATE_DOWNLOADED);
694 do_check_true(hasFlag(installs[3].addon.operationsRequiringRestart,
695 AddonManager.OP_NEEDS_RESTART_INSTALL));
696
697 AddonManager.getAllInstalls(function(aInstalls) {
698 do_check_eq(aInstalls.length, 4);
699
700 prepare_test({
701 "addon4@tests.mozilla.org": [
702 "onInstalling"
703 ],
704 "addon5@tests.mozilla.org": [
705 "onInstalling"
706 ],
707 "addon6@tests.mozilla.org": [
708 ["onInstalling", false],
709 "onInstalled"
710 ],
711 "addon7@tests.mozilla.org": [
712 "onInstalling"
713 ]
714 }, {
715 "addon4@tests.mozilla.org": [
716 "onInstallStarted",
717 "onInstallEnded"
718 ],
719 "addon5@tests.mozilla.org": [
720 "onInstallStarted",
721 "onInstallEnded"
722 ],
723 "addon6@tests.mozilla.org": [
724 "onInstallStarted",
725 "onInstallEnded"
726 ],
727 "addon7@tests.mozilla.org": [
728 "onInstallStarted",
729 "onInstallEnded"
730 ]
731 }, callback_soon(check_test_11));
732
733 installs[0].install();
734 installs[1].install();
735 installs[3].install();
736
737 // Note that we install addon6 last. Since it doesn't need a restart to
738 // install it completes asynchronously which would otherwise make the
739 // onInstallStarted/onInstallEnded events go out of sequence unless this
740 // is the last install operation
741 installs[2].install();
742 });
743 });
744 }
745
746 function check_test_11() {
747 restartManager();
748
749 AddonManager.getAddonsByIDs(["addon4@tests.mozilla.org",
750 "addon5@tests.mozilla.org",
751 "addon6@tests.mozilla.org",
752 "addon7@tests.mozilla.org"],
753 function([a4, a5, a6, a7]) {
754 do_check_neq(a4, null);
755 do_check_neq(a5, null);
756 do_check_neq(a6, null);
757 do_check_neq(a7, null);
758
759 a4.uninstall();
760 a5.uninstall();
761 a6.uninstall();
762 a7.uninstall();
763
764 do_execute_soon(run_test_12);
765 });
766 }
767
768 // Same as test 11 but for a remote XPI
769 function run_test_12() {
770 restartManager();
771
772 prepare_test({ }, [
773 "onNewInstall",
774 ]);
775
776 let url = "http://localhost:4444/addons/test_install4.xpi";
777 AddonManager.getInstallForURL(url, function(install) {
778 gInstall = install;
779
780 ensure_test_completed();
781 do_check_neq(install, null);
782 do_check_eq(install.linkedInstalls, null);
783 do_check_eq(install.state, AddonManager.STATE_AVAILABLE);
784
785 prepare_test({
786 "addon4@tests.mozilla.org": [
787 "onInstalling"
788 ],
789 "addon5@tests.mozilla.org": [
790 "onInstalling"
791 ],
792 "addon6@tests.mozilla.org": [
793 ["onInstalling", false],
794 "onInstalled"
795 ],
796 "addon7@tests.mozilla.org": [
797 "onInstalling"
798 ]
799 }, {
800 "NO_ID": [
801 "onDownloadStarted",
802 "onNewInstall",
803 "onNewInstall",
804 "onNewInstall",
805 "onDownloadEnded"
806 ],
807 "addon4@tests.mozilla.org": [
808 "onInstallStarted",
809 "onInstallEnded"
810 ],
811 "addon5@tests.mozilla.org": [
812 "onInstallStarted",
813 "onInstallEnded"
814 ],
815 "addon6@tests.mozilla.org": [
816 "onInstallStarted",
817 "onInstallEnded"
818 ],
819 "addon7@tests.mozilla.org": [
820 "onInstallStarted",
821 "onInstallEnded"
822 ]
823 }, callback_soon(check_test_12));
824 install.install();
825 }, "application/x-xpinstall", null, "Multi Test 4");
826 }
827
828 function check_test_12() {
829 do_check_eq(gInstall.linkedInstalls.length, 3);
830
831 // Might be in any order so sort them based on ID
832 let installs = [gInstall].concat(gInstall.linkedInstalls);
833 installs.sort(function(a, b) {
834 if (a.addon.id < b.addon.id)
835 return -1;
836 if (a.addon.id > b.addon.id)
837 return 1;
838 return 0;
839 });
840
841 // Comes from addon4.xpi and is made compatible by an update check
842 do_check_eq(installs[0].sourceURI, gInstall.sourceURI);
843 do_check_eq(installs[0].addon.id, "addon4@tests.mozilla.org");
844 do_check_false(installs[0].addon.appDisabled);
845 do_check_eq(installs[0].version, "1.0");
846 do_check_eq(installs[0].name, "Multi Test 1");
847 do_check_eq(installs[0].state, AddonManager.STATE_INSTALLED);
848
849 // Comes from addon5.jar and is compatible by default
850 do_check_eq(installs[1].sourceURI, gInstall.sourceURI);
851 do_check_eq(installs[1].addon.id, "addon5@tests.mozilla.org");
852 do_check_false(installs[1].addon.appDisabled);
853 do_check_eq(installs[1].version, "3.0");
854 do_check_eq(installs[1].name, "Multi Test 2");
855 do_check_eq(installs[1].state, AddonManager.STATE_INSTALLED);
856
857 // Comes from addon6.xpi and is incompatible
858 do_check_eq(installs[2].sourceURI, gInstall.sourceURI);
859 do_check_eq(installs[2].addon.id, "addon6@tests.mozilla.org");
860 do_check_true(installs[2].addon.appDisabled);
861 do_check_eq(installs[2].version, "2.0");
862 do_check_eq(installs[2].name, "Multi Test 3");
863 do_check_eq(installs[2].state, AddonManager.STATE_INSTALLED);
864
865 // Comes from addon7.jar and is made compatible by an update check
866 do_check_eq(installs[3].sourceURI, gInstall.sourceURI);
867 do_check_eq(installs[3].addon.id, "addon7@tests.mozilla.org");
868 do_check_false(installs[3].addon.appDisabled);
869 do_check_eq(installs[3].version, "5.0");
870 do_check_eq(installs[3].name, "Multi Test 4");
871 do_check_eq(installs[3].state, AddonManager.STATE_INSTALLED);
872
873 restartManager();
874
875 AddonManager.getAddonsByIDs(["addon4@tests.mozilla.org",
876 "addon5@tests.mozilla.org",
877 "addon6@tests.mozilla.org",
878 "addon7@tests.mozilla.org"],
879 function([a4, a5, a6, a7]) {
880 do_check_neq(a4, null);
881 do_check_neq(a5, null);
882 do_check_neq(a6, null);
883 do_check_neq(a7, null);
884
885 a4.uninstall();
886 a5.uninstall();
887 a6.uninstall();
888 a7.uninstall();
889
890 do_execute_soon(run_test_13);
891 });
892 }
893
894
895 // Tests that cancelling an upgrade leaves the original add-on's pendingOperations
896 // correct
897 function run_test_13() {
898 restartManager();
899
900 installAllFiles([do_get_addon("test_install2_1")], function() {
901 restartManager();
902
903 prepare_test({ }, [
904 "onNewInstall"
905 ]);
906
907 let url = "http://localhost:4444/addons/test_install2_2.xpi";
908 AddonManager.getInstallForURL(url, function(install) {
909 ensure_test_completed();
910
911 do_check_neq(install, null);
912 do_check_eq(install.version, "3.0");
913 do_check_eq(install.name, "Test 3");
914 do_check_eq(install.state, AddonManager.STATE_AVAILABLE);
915
916 AddonManager.getAllInstalls(function(activeInstalls) {
917 do_check_eq(activeInstalls.length, 1);
918 do_check_eq(activeInstalls[0], install);
919 do_check_eq(install.existingAddon, null);
920
921 prepare_test({
922 "addon2@tests.mozilla.org": [
923 "onInstalling"
924 ]
925 }, [
926 "onDownloadStarted",
927 "onDownloadEnded",
928 "onInstallStarted",
929 "onInstallEnded",
930 ], check_test_13);
931 install.install();
932 });
933 }, "application/x-xpinstall", null, "Test 3", null, "3.0");
934 });
935 }
936
937 function check_test_13(install) {
938 ensure_test_completed();
939
940 do_check_eq(install.version, "3.0");
941 do_check_eq(install.name, "Real Test 3");
942 do_check_eq(install.state, AddonManager.STATE_INSTALLED);
943 do_check_neq(install.existingAddon, null);
944 do_check_eq(install.existingAddon.id, "addon2@tests.mozilla.org");
945 do_check_eq(install.addon.install, install);
946
947 AddonManager.getAddonByID("addon2@tests.mozilla.org", callback_soon(function(olda2) {
948 do_check_neq(olda2, null);
949 do_check_true(hasFlag(olda2.pendingOperations, AddonManager.PENDING_UPGRADE));
950 do_check_eq(olda2.pendingUpgrade, install.addon);
951
952 do_check_true(hasFlag(install.addon.pendingOperations,
953 AddonManager.PENDING_INSTALL));
954
955 prepare_test({
956 "addon2@tests.mozilla.org": [
957 "onOperationCancelled"
958 ]
959 }, [
960 "onInstallCancelled",
961 ]);
962
963 install.cancel();
964
965 do_check_false(hasFlag(install.addon.pendingOperations, AddonManager.PENDING_INSTALL));
966
967 do_check_false(hasFlag(olda2.pendingOperations, AddonManager.PENDING_UPGRADE));
968 do_check_eq(olda2.pendingUpgrade, null);
969
970 restartManager();
971
972 // Check that the upgrade did not complete
973 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
974 do_check_eq(a2.version, "2.0");
975
976 a2.uninstall();
977
978 do_execute_soon(run_test_14);
979 });
980 }));
981 }
982
983 // Check that cancelling the install from onDownloadStarted actually cancels it
984 function run_test_14() {
985 restartManager();
986
987 prepare_test({ }, [
988 "onNewInstall"
989 ]);
990
991 let url = "http://localhost:4444/addons/test_install2_1.xpi";
992 AddonManager.getInstallForURL(url, function(install) {
993 ensure_test_completed();
994
995 do_check_eq(install.file, null);
996
997 prepare_test({ }, [
998 "onDownloadStarted"
999 ], check_test_14);
1000 install.install();
1001 }, "application/x-xpinstall");
1002 }
1003
1004 function check_test_14(install) {
1005 prepare_test({ }, [
1006 "onDownloadCancelled"
1007 ]);
1008
1009 install.cancel();
1010
1011 ensure_test_completed();
1012
1013 install.addListener({
1014 onDownloadProgress: function() {
1015 do_throw("Download should not have continued");
1016 },
1017 onDownloadEnded: function() {
1018 do_throw("Download should not have continued");
1019 }
1020 });
1021
1022 // Allow the listener to return to see if it continues downloading. The
1023 // The listener only really tests if we give it time to see progress, the
1024 // file check isn't ideal either
1025 do_execute_soon(function() {
1026 do_check_eq(install.file, null);
1027
1028 run_test_15();
1029 });
1030 }
1031
1032 // Checks that cancelling the install from onDownloadEnded actually cancels it
1033 function run_test_15() {
1034 prepare_test({ }, [
1035 "onNewInstall"
1036 ]);
1037
1038 let url = "http://localhost:4444/addons/test_install2_1.xpi";
1039 AddonManager.getInstallForURL(url, function(install) {
1040 ensure_test_completed();
1041
1042 do_check_eq(install.file, null);
1043
1044 prepare_test({ }, [
1045 "onDownloadStarted",
1046 "onDownloadEnded"
1047 ], check_test_15);
1048 install.install();
1049 }, "application/x-xpinstall");
1050 }
1051
1052 function check_test_15(install) {
1053 prepare_test({ }, [
1054 "onDownloadCancelled"
1055 ]);
1056
1057 install.cancel();
1058
1059 ensure_test_completed();
1060
1061 install.addListener({
1062 onInstallStarted: function() {
1063 do_throw("Install should not have continued");
1064 }
1065 });
1066
1067 // Allow the listener to return to see if it starts installing
1068 do_execute_soon(run_test_16);
1069 }
1070
1071 // Verify that the userDisabled value carries over to the upgrade by default
1072 function run_test_16() {
1073 restartManager();
1074
1075 let url = "http://localhost:4444/addons/test_install2_1.xpi";
1076 AddonManager.getInstallForURL(url, function(aInstall) {
1077 aInstall.addListener({
1078 onInstallStarted: function() {
1079 do_check_false(aInstall.addon.userDisabled);
1080 aInstall.addon.userDisabled = true;
1081 },
1082
1083 onInstallEnded: function() {
1084 do_execute_soon(function test16_install1() {
1085 restartManager();
1086
1087 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1088 do_check_true(a2.userDisabled);
1089 do_check_false(a2.isActive);
1090
1091 let url = "http://localhost:4444/addons/test_install2_2.xpi";
1092 AddonManager.getInstallForURL(url, function(aInstall) {
1093 aInstall.addListener({
1094 onInstallEnded: function() {
1095 do_execute_soon(function test16_install2() {
1096 do_check_true(aInstall.addon.userDisabled);
1097
1098 restartManager();
1099
1100 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1101 do_check_true(a2.userDisabled);
1102 do_check_false(a2.isActive);
1103
1104 a2.uninstall();
1105 do_execute_soon(run_test_17);
1106 });
1107 });
1108 }
1109 });
1110 aInstall.install();
1111 }, "application/x-xpinstall");
1112 });
1113 });
1114 }
1115 });
1116 aInstall.install();
1117 }, "application/x-xpinstall");
1118 }
1119
1120 // Verify that changing the userDisabled value before onInstallEnded works
1121 function run_test_17() {
1122 restartManager();
1123
1124 let url = "http://localhost:4444/addons/test_install2_1.xpi";
1125 AddonManager.getInstallForURL(url, function(aInstall) {
1126 aInstall.addListener({
1127 onInstallEnded: function() {
1128 do_execute_soon(function test17_install1() {
1129 do_check_false(aInstall.addon.userDisabled);
1130
1131 restartManager();
1132
1133 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1134 do_check_false(a2.userDisabled);
1135 do_check_true(a2.isActive);
1136
1137 let url = "http://localhost:4444/addons/test_install2_2.xpi";
1138 AddonManager.getInstallForURL(url, function(aInstall) {
1139 aInstall.addListener({
1140 onInstallStarted: function() {
1141 do_check_false(aInstall.addon.userDisabled);
1142 aInstall.addon.userDisabled = true;
1143 },
1144
1145 onInstallEnded: function() {
1146 do_execute_soon(function test17_install1() {
1147 restartManager();
1148
1149 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1150 do_check_true(a2.userDisabled);
1151 do_check_false(a2.isActive);
1152
1153 a2.uninstall();
1154 do_execute_soon(run_test_18);
1155 });
1156 });
1157 }
1158 });
1159 aInstall.install();
1160 }, "application/x-xpinstall");
1161 });
1162 });
1163 }
1164 });
1165 aInstall.install();
1166 }, "application/x-xpinstall");
1167 }
1168
1169 // Verify that changing the userDisabled value before onInstallEnded works
1170 function run_test_18() {
1171 restartManager();
1172
1173 let url = "http://localhost:4444/addons/test_install2_1.xpi";
1174 AddonManager.getInstallForURL(url, function(aInstall) {
1175 aInstall.addListener({
1176 onInstallStarted: function() {
1177 do_check_false(aInstall.addon.userDisabled);
1178 aInstall.addon.userDisabled = true;
1179 },
1180
1181 onInstallEnded: function() {
1182 do_execute_soon(function test18_install1() {
1183 restartManager();
1184
1185 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1186 do_check_true(a2.userDisabled);
1187 do_check_false(a2.isActive);
1188
1189 let url = "http://localhost:4444/addons/test_install2_2.xpi";
1190 AddonManager.getInstallForURL(url, function(aInstall) {
1191 aInstall.addListener({
1192 onInstallStarted: function() {
1193 do_check_true(aInstall.addon.userDisabled);
1194 aInstall.addon.userDisabled = false;
1195 },
1196
1197 onInstallEnded: function() {
1198 do_execute_soon(function test18_install2() {
1199 restartManager();
1200
1201 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1202 do_check_false(a2.userDisabled);
1203 do_check_true(a2.isActive);
1204
1205 a2.uninstall();
1206 do_execute_soon(run_test_18_1);
1207 });
1208 });
1209 }
1210 });
1211 aInstall.install();
1212 }, "application/x-xpinstall");
1213 });
1214 });
1215 }
1216 });
1217 aInstall.install();
1218 }, "application/x-xpinstall");
1219 }
1220
1221
1222 // Checks that metadata is not stored if the pref is set to false
1223 function run_test_18_1() {
1224 restartManager();
1225
1226 Services.prefs.setBoolPref("extensions.getAddons.cache.enabled", true);
1227 Services.prefs.setCharPref(PREF_GETADDONS_BYIDS,
1228 "http://localhost:4444/data/test_install.xml");
1229
1230 Services.prefs.setBoolPref("extensions.addon2@tests.mozilla.org.getAddons.cache.enabled", false);
1231
1232 let url = "http://localhost:4444/addons/test_install2_1.xpi";
1233 AddonManager.getInstallForURL(url, function(aInstall) {
1234 aInstall.addListener({
1235 onInstallEnded: function(aInstall, aAddon) {
1236 do_execute_soon(function test18_install() {
1237 do_check_neq(aAddon.fullDescription, "Repository description");
1238
1239 restartManager();
1240
1241 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1242 do_check_neq(a2.fullDescription, "Repository description");
1243
1244 a2.uninstall();
1245 do_execute_soon(run_test_19);
1246 });
1247 });
1248 }
1249 });
1250 aInstall.install();
1251 }, "application/x-xpinstall");
1252 }
1253
1254 // Checks that metadata is downloaded for new installs and is visible before and
1255 // after restart
1256 function run_test_19() {
1257 restartManager();
1258 Services.prefs.setBoolPref("extensions.addon2@tests.mozilla.org.getAddons.cache.enabled", true);
1259
1260 let url = "http://localhost:4444/addons/test_install2_1.xpi";
1261 AddonManager.getInstallForURL(url, function(aInstall) {
1262 aInstall.addListener({
1263 onInstallEnded: function(aInstall, aAddon) {
1264 do_execute_soon(function test19_install() {
1265 do_check_eq(aAddon.fullDescription, "Repository description");
1266
1267 restartManager();
1268
1269 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1270 do_check_eq(a2.fullDescription, "Repository description");
1271
1272 a2.uninstall();
1273 do_execute_soon(run_test_20);
1274 });
1275 });
1276 }
1277 });
1278 aInstall.install();
1279 }, "application/x-xpinstall");
1280 }
1281
1282 // Do the same again to make sure it works when the data is already in the cache
1283 function run_test_20() {
1284 restartManager();
1285
1286 let url = "http://localhost:4444/addons/test_install2_1.xpi";
1287 AddonManager.getInstallForURL(url, function(aInstall) {
1288 aInstall.addListener({
1289 onInstallEnded: function(aInstall, aAddon) {
1290 do_execute_soon(function test20_install() {
1291 do_check_eq(aAddon.fullDescription, "Repository description");
1292
1293 restartManager();
1294
1295 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1296 do_check_eq(a2.fullDescription, "Repository description");
1297
1298 a2.uninstall();
1299 do_execute_soon(run_test_21);
1300 });
1301 });
1302 }
1303 });
1304 aInstall.install();
1305 }, "application/x-xpinstall");
1306 }
1307
1308 // Verify that installing an add-on that is already pending install cancels the
1309 // first install
1310 function run_test_21() {
1311 restartManager();
1312 Services.prefs.setBoolPref("extensions.getAddons.cache.enabled", false);
1313
1314 installAllFiles([do_get_addon("test_install2_1")], function() {
1315 AddonManager.getAllInstalls(function(aInstalls) {
1316 do_check_eq(aInstalls.length, 1);
1317
1318 prepare_test({
1319 "addon2@tests.mozilla.org": [
1320 "onOperationCancelled",
1321 "onInstalling"
1322 ]
1323 }, [
1324 "onNewInstall",
1325 "onDownloadStarted",
1326 "onDownloadEnded",
1327 "onInstallStarted",
1328 "onInstallCancelled",
1329 "onInstallEnded",
1330 ], check_test_21);
1331
1332 let url = "http://localhost:4444/addons/test_install2_1.xpi";
1333 AddonManager.getInstallForURL(url, function(aInstall) {
1334 aInstall.install();
1335 }, "application/x-xpinstall");
1336 });
1337 });
1338 }
1339
1340 function check_test_21(aInstall) {
1341 AddonManager.getAllInstalls(callback_soon(function(aInstalls) {
1342 do_check_eq(aInstalls.length, 1);
1343 do_check_eq(aInstalls[0], aInstall);
1344
1345 prepare_test({
1346 "addon2@tests.mozilla.org": [
1347 "onOperationCancelled"
1348 ]
1349 }, [
1350 "onInstallCancelled",
1351 ]);
1352
1353 aInstall.cancel();
1354
1355 ensure_test_completed();
1356
1357 restartManager();
1358
1359 AddonManager.getAddonByID("addon2@tests.mozilla.org", function(a2) {
1360 do_check_eq(a2, null);
1361
1362 run_test_22();
1363 });
1364 }));
1365 }
1366
1367 // Tests that an install can be restarted after being cancelled
1368 function run_test_22() {
1369 prepare_test({ }, [
1370 "onNewInstall"
1371 ]);
1372
1373 let url = "http://localhost:4444/addons/test_install3.xpi";
1374 AddonManager.getInstallForURL(url, function(aInstall) {
1375 ensure_test_completed();
1376
1377 do_check_neq(aInstall, null);
1378 do_check_eq(aInstall.state, AddonManager.STATE_AVAILABLE);
1379
1380 prepare_test({}, [
1381 "onDownloadStarted",
1382 "onDownloadEnded",
1383 ], check_test_22);
1384 aInstall.install();
1385 }, "application/x-xpinstall");
1386 }
1387
1388 function check_test_22(aInstall) {
1389 prepare_test({}, [
1390 "onDownloadCancelled"
1391 ]);
1392
1393 aInstall.cancel();
1394
1395 ensure_test_completed();
1396
1397 prepare_test({
1398 "addon3@tests.mozilla.org": [
1399 "onInstalling"
1400 ]
1401 }, [
1402 "onDownloadStarted",
1403 "onDownloadEnded",
1404 "onInstallStarted",
1405 "onInstallEnded"
1406 ], finish_test_22);
1407
1408 aInstall.install();
1409 }
1410
1411 function finish_test_22(aInstall) {
1412 prepare_test({
1413 "addon3@tests.mozilla.org": [
1414 "onOperationCancelled"
1415 ]
1416 }, [
1417 "onInstallCancelled"
1418 ]);
1419
1420 aInstall.cancel();
1421
1422 ensure_test_completed();
1423
1424 run_test_23();
1425 }
1426
1427 // Tests that an install can be restarted after being cancelled when a hash
1428 // was provided
1429 function run_test_23() {
1430 prepare_test({ }, [
1431 "onNewInstall"
1432 ]);
1433
1434 let url = "http://localhost:4444/addons/test_install3.xpi";
1435 AddonManager.getInstallForURL(url, function(aInstall) {
1436 ensure_test_completed();
1437
1438 do_check_neq(aInstall, null);
1439 do_check_eq(aInstall.state, AddonManager.STATE_AVAILABLE);
1440
1441 prepare_test({}, [
1442 "onDownloadStarted",
1443 "onDownloadEnded",
1444 ], check_test_23);
1445 aInstall.install();
1446 }, "application/x-xpinstall", do_get_addon_hash("test_install3"));
1447 }
1448
1449 function check_test_23(aInstall) {
1450 prepare_test({}, [
1451 "onDownloadCancelled"
1452 ]);
1453
1454 aInstall.cancel();
1455
1456 ensure_test_completed();
1457
1458 prepare_test({
1459 "addon3@tests.mozilla.org": [
1460 "onInstalling"
1461 ]
1462 }, [
1463 "onDownloadStarted",
1464 "onDownloadEnded",
1465 "onInstallStarted",
1466 "onInstallEnded"
1467 ], finish_test_23);
1468
1469 aInstall.install();
1470 }
1471
1472 function finish_test_23(aInstall) {
1473 prepare_test({
1474 "addon3@tests.mozilla.org": [
1475 "onOperationCancelled"
1476 ]
1477 }, [
1478 "onInstallCancelled"
1479 ]);
1480
1481 aInstall.cancel();
1482
1483 ensure_test_completed();
1484
1485 run_test_24();
1486 }
1487
1488 // Tests that an install with a bad hash can be restarted after it fails, though
1489 // it will only fail again
1490 function run_test_24() {
1491 prepare_test({ }, [
1492 "onNewInstall"
1493 ]);
1494
1495 let url = "http://localhost:4444/addons/test_install3.xpi";
1496 AddonManager.getInstallForURL(url, function(aInstall) {
1497 ensure_test_completed();
1498
1499 do_check_neq(aInstall, null);
1500 do_check_eq(aInstall.state, AddonManager.STATE_AVAILABLE);
1501
1502 prepare_test({}, [
1503 "onDownloadStarted",
1504 "onDownloadFailed",
1505 ], check_test_24);
1506 aInstall.install();
1507 }, "application/x-xpinstall", "sha1:foo");
1508 }
1509
1510 function check_test_24(aInstall) {
1511 prepare_test({ }, [
1512 "onDownloadStarted",
1513 "onDownloadFailed"
1514 ], run_test_25);
1515
1516 aInstall.install();
1517 }
1518
1519 // Tests that installs with a hash for a local file work
1520 function run_test_25() {
1521 prepare_test({ }, [
1522 "onNewInstall"
1523 ]);
1524
1525 let url = Services.io.newFileURI(do_get_addon("test_install3")).spec;
1526 AddonManager.getInstallForURL(url, function(aInstall) {
1527 ensure_test_completed();
1528
1529 do_check_neq(aInstall, null);
1530 do_check_eq(aInstall.state, AddonManager.STATE_DOWNLOADED);
1531 do_check_eq(aInstall.error, 0);
1532
1533 prepare_test({ }, [
1534 "onDownloadCancelled"
1535 ]);
1536
1537 aInstall.cancel();
1538
1539 ensure_test_completed();
1540
1541 run_test_26();
1542 }, "application/x-xpinstall", do_get_addon_hash("test_install3"));
1543 }
1544
1545 function run_test_26() {
1546 prepare_test({ }, [
1547 "onNewInstall",
1548 "onDownloadStarted",
1549 "onDownloadCancelled"
1550 ]);
1551
1552 let observerService = AM_Cc["@mozilla.org/network/http-activity-distributor;1"].
1553 getService(AM_Ci.nsIHttpActivityDistributor);
1554 observerService.addObserver({
1555 observeActivity: function(aChannel, aType, aSubtype, aTimestamp, aSizeData,
1556 aStringData) {
1557 aChannel.QueryInterface(AM_Ci.nsIChannel);
1558 // Wait for the final event for the redirected URL
1559 if (aChannel.URI.spec != "http://localhost:4444/addons/test_install1.xpi" ||
1560 aType != AM_Ci.nsIHttpActivityObserver.ACTIVITY_TYPE_HTTP_TRANSACTION ||
1561 aSubtype != AM_Ci.nsIHttpActivityObserver.ACTIVITY_SUBTYPE_TRANSACTION_CLOSE)
1562 return;
1563
1564 // Request should have been cancelled
1565 do_check_eq(aChannel.status, Components.results.NS_BINDING_ABORTED);
1566
1567 observerService.removeObserver(this);
1568
1569 run_test_27();
1570 }
1571 });
1572
1573 let url = "http://localhost:4444/redirect?/addons/test_install1.xpi";
1574 AddonManager.getInstallForURL(url, function(aInstall) {
1575 aInstall.addListener({
1576 onDownloadProgress: function(aInstall) {
1577 aInstall.cancel();
1578 }
1579 });
1580
1581 aInstall.install();
1582 }, "application/x-xpinstall");
1583 }
1584
1585
1586 // Tests that an install can be restarted during onDownloadCancelled after being
1587 // cancelled in mid-download
1588 function run_test_27() {
1589 prepare_test({ }, [
1590 "onNewInstall"
1591 ]);
1592
1593 let url = "http://localhost:4444/addons/test_install3.xpi";
1594 AddonManager.getInstallForURL(url, function(aInstall) {
1595 ensure_test_completed();
1596
1597 do_check_neq(aInstall, null);
1598 do_check_eq(aInstall.state, AddonManager.STATE_AVAILABLE);
1599
1600 aInstall.addListener({
1601 onDownloadProgress: function() {
1602 aInstall.removeListener(this);
1603 aInstall.cancel();
1604 }
1605 });
1606
1607 prepare_test({}, [
1608 "onDownloadStarted",
1609 "onDownloadCancelled",
1610 ], check_test_27);
1611 aInstall.install();
1612 }, "application/x-xpinstall");
1613 }
1614
1615 function check_test_27(aInstall) {
1616 prepare_test({
1617 "addon3@tests.mozilla.org": [
1618 "onInstalling"
1619 ]
1620 }, [
1621 "onDownloadStarted",
1622 "onDownloadEnded",
1623 "onInstallStarted",
1624 "onInstallEnded"
1625 ], finish_test_27);
1626
1627 aInstall.install();
1628 }
1629
1630 function finish_test_27(aInstall) {
1631 prepare_test({
1632 "addon3@tests.mozilla.org": [
1633 "onOperationCancelled"
1634 ]
1635 }, [
1636 "onInstallCancelled"
1637 ]);
1638
1639 aInstall.cancel();
1640
1641 ensure_test_completed();
1642
1643 end_test();
1644 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial