The Tor Browser / file comparison

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

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

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial