The Tor Browser: toolkit/components/jsdownloads/test/unit/test_DownloadIntegration.js@b8a032363ba2 (annotated)

toolkit/components/jsdownloads/test/unit/test_DownloadIntegration.js@b8a032363ba2 (annotated)

toolkit/components/jsdownloads/test/unit/test_DownloadIntegration.js

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
 /**
  * Tests the DownloadIntegration object.
  */
 "use strict";
 ////////////////////////////////////////////////////////////////////////////////
 //// Globals
 /**
  * Enable test mode for the _confirmCancelDownloads method to return
  * the number of downloads instead of showing the prompt to cancel or not.
  */
 function enableObserversTestMode() {
   DownloadIntegration.testMode = true;
   DownloadIntegration.dontLoadObservers = false;
   function cleanup() {
     DownloadIntegration.testMode = false;
     DownloadIntegration.dontLoadObservers = true;
   }
   do_register_cleanup(cleanup);
 }
 /**
  * Notifies the prompt observers and verify the expected downloads count.
  *
  * @param aIsPrivate
  *        Flag to know is test private observers.
  * @param aExpectedCount
  *        the expected downloads count for quit and offline observers.
  * @param aExpectedPBCount
  *        the expected downloads count for private browsing observer.
  */
 function notifyPromptObservers(aIsPrivate, aExpectedCount, aExpectedPBCount) {
   let cancelQuit = Cc["@mozilla.org/supports-PRBool;1"].
                    createInstance(Ci.nsISupportsPRBool);
   // Notify quit application requested observer.
   DownloadIntegration.testPromptDownloads = -1;
   Services.obs.notifyObservers(cancelQuit, "quit-application-requested", null);
   do_check_eq(DownloadIntegration.testPromptDownloads, aExpectedCount);
   // Notify offline requested observer.
   DownloadIntegration.testPromptDownloads = -1;
   Services.obs.notifyObservers(cancelQuit, "offline-requested", null);
   do_check_eq(DownloadIntegration.testPromptDownloads, aExpectedCount);
   if (aIsPrivate) {
     // Notify last private browsing requested observer.
     DownloadIntegration.testPromptDownloads = -1;
     Services.obs.notifyObservers(cancelQuit, "last-pb-context-exiting", null);
     do_check_eq(DownloadIntegration.testPromptDownloads, aExpectedPBCount);
   }
 }
 ////////////////////////////////////////////////////////////////////////////////
 //// Tests
 XPCOMUtils.defineLazyGetter(this, "gStringBundle", function() {
   return Services.strings.
     createBundle("chrome://mozapps/locale/downloads/downloads.properties");
 });
 /**
  * Tests that the getSystemDownloadsDirectory returns a valid download
  * directory string path.
  */
 add_task(function test_getSystemDownloadsDirectory()
 {
   // Enable test mode for the getSystemDownloadsDirectory method to return
   // temp directory instead so we can check whether the desired directory
   // is created or not.
   DownloadIntegration.testMode = true;
   function cleanup() {
     DownloadIntegration.testMode = false;
   }
   do_register_cleanup(cleanup);
   let tempDir = Services.dirsvc.get("TmpD", Ci.nsIFile);
   let downloadDir;
   // OSX / Linux / Windows but not XP/2k
   if (Services.appinfo.OS == "Darwin" ||
       Services.appinfo.OS == "Linux" ||
       (Services.appinfo.OS == "WINNT" &&
        parseFloat(Services.sysinfo.getProperty("version")) >= 6)) {
     downloadDir = yield DownloadIntegration.getSystemDownloadsDirectory();
     do_check_eq(downloadDir, tempDir.path);
     do_check_true(yield OS.File.exists(downloadDir));
     let info = yield OS.File.stat(downloadDir);
     do_check_true(info.isDir);
   } else {
     let targetPath = OS.Path.join(tempDir.path,
                        gStringBundle.GetStringFromName("downloadsFolder"));
     try {
       yield OS.File.removeEmptyDir(targetPath);
     } catch(e) {}
     downloadDir = yield DownloadIntegration.getSystemDownloadsDirectory();
     do_check_eq(downloadDir, targetPath);
     do_check_true(yield OS.File.exists(downloadDir));
     let info = yield OS.File.stat(downloadDir);
     do_check_true(info.isDir);
     yield OS.File.removeEmptyDir(targetPath);
   }
   let downloadDirBefore = yield DownloadIntegration.getSystemDownloadsDirectory();
   cleanup();
   let downloadDirAfter = yield DownloadIntegration.getSystemDownloadsDirectory();
   do_check_neq(downloadDirBefore, downloadDirAfter);
 });
 /**
  * Tests that the getPreferredDownloadsDirectory returns a valid download
  * directory string path.
  */
 add_task(function test_getPreferredDownloadsDirectory()
 {
   let folderListPrefName = "browser.download.folderList";
   let dirPrefName = "browser.download.dir";
   function cleanup() {
     Services.prefs.clearUserPref(folderListPrefName);
     Services.prefs.clearUserPref(dirPrefName);
   }
   do_register_cleanup(cleanup);
   // Should return the system downloads directory.
   Services.prefs.setIntPref(folderListPrefName, 1);
   let systemDir = yield DownloadIntegration.getSystemDownloadsDirectory();
   let downloadDir = yield DownloadIntegration.getPreferredDownloadsDirectory();
   do_check_neq(downloadDir, "");
   do_check_eq(downloadDir, systemDir);
   // Should return the desktop directory.
   Services.prefs.setIntPref(folderListPrefName, 0);
   downloadDir = yield DownloadIntegration.getPreferredDownloadsDirectory();
   do_check_neq(downloadDir, "");
   do_check_eq(downloadDir, Services.dirsvc.get("Desk", Ci.nsIFile).path);
   // Should return the system downloads directory because the dir preference
   // is not set.
   Services.prefs.setIntPref(folderListPrefName, 2);
   let downloadDir = yield DownloadIntegration.getPreferredDownloadsDirectory();
   do_check_neq(downloadDir, "");
   do_check_eq(downloadDir, systemDir);
   // Should return the directory which is listed in the dir preference.
   let time = (new Date()).getTime();
   let tempDir = Services.dirsvc.get("TmpD", Ci.nsIFile);
   tempDir.append(time);
   Services.prefs.setComplexValue("browser.download.dir", Ci.nsIFile, tempDir);
   downloadDir = yield DownloadIntegration.getPreferredDownloadsDirectory();
   do_check_neq(downloadDir, "");
   do_check_eq(downloadDir,  tempDir.path);
   do_check_true(yield OS.File.exists(downloadDir));
   yield OS.File.removeEmptyDir(tempDir.path);
   // Should return the system downloads directory beacause the path is invalid
   // in the dir preference.
   tempDir = Services.dirsvc.get("TmpD", Ci.nsIFile);
   tempDir.append("dir_not_exist");
   tempDir.append(time);
   Services.prefs.setComplexValue("browser.download.dir", Ci.nsIFile, tempDir);
   downloadDir = yield DownloadIntegration.getPreferredDownloadsDirectory();
   do_check_eq(downloadDir, systemDir);
   // Should return the system downloads directory because the folderList
   // preference is invalid
   Services.prefs.setIntPref(folderListPrefName, 999);
   let downloadDir = yield DownloadIntegration.getPreferredDownloadsDirectory();
   do_check_eq(downloadDir, systemDir);
   cleanup();
 });
 /**
  * Tests that the getTemporaryDownloadsDirectory returns a valid download
  * directory string path.
  */
 add_task(function test_getTemporaryDownloadsDirectory()
 {
   let downloadDir = yield DownloadIntegration.getTemporaryDownloadsDirectory();
   do_check_neq(downloadDir, "");
   if ("nsILocalFileMac" in Ci) {
     let preferredDownloadDir = yield DownloadIntegration.getPreferredDownloadsDirectory();
     do_check_eq(downloadDir, preferredDownloadDir);
   } else {
     let tempDir = Services.dirsvc.get("TmpD", Ci.nsIFile);
     do_check_eq(downloadDir, tempDir.path);
   }
 });
 ////////////////////////////////////////////////////////////////////////////////
 //// Tests DownloadObserver
 /**
  * Tests notifications prompts when observers are notified if there are public
  * and private active downloads.
  */
 add_task(function test_notifications()
 {
   enableObserversTestMode();
   for (let isPrivate of [false, true]) {
     mustInterruptResponses();
     let list = yield promiseNewList(isPrivate);
     let download1 = yield promiseNewDownload(httpUrl("interruptible.txt"));
     let download2 = yield promiseNewDownload(httpUrl("interruptible.txt"));
     let download3 = yield promiseNewDownload(httpUrl("interruptible.txt"));
     let promiseAttempt1 = download1.start();
     let promiseAttempt2 = download2.start();
     download3.start();
     // Add downloads to list.
     yield list.add(download1);
     yield list.add(download2);
     yield list.add(download3);
     // Cancel third download
     yield download3.cancel();
     notifyPromptObservers(isPrivate, 2, 2);
     // Allow the downloads to complete.
     continueResponses();
     yield promiseAttempt1;
     yield promiseAttempt2;
     // Clean up.
     yield list.remove(download1);
     yield list.remove(download2);
     yield list.remove(download3);
   }
 });
 /**
  * Tests that notifications prompts observers are not notified if there are no
  * public or private active downloads.
  */
 add_task(function test_no_notifications()
 {
   enableObserversTestMode();
   for (let isPrivate of [false, true]) {
     let list = yield promiseNewList(isPrivate);
     let download1 = yield promiseNewDownload(httpUrl("interruptible.txt"));
     let download2 = yield promiseNewDownload(httpUrl("interruptible.txt"));
     download1.start();
     download2.start();
     // Add downloads to list.
     yield list.add(download1);
     yield list.add(download2);
     yield download1.cancel();
     yield download2.cancel();
     notifyPromptObservers(isPrivate, 0, 0);
     // Clean up.
     yield list.remove(download1);
     yield list.remove(download2);
   }
 });
 /**
  * Tests notifications prompts when observers are notified if there are public
  * and private active downloads at the same time.
  */
 add_task(function test_mix_notifications()
 {
   enableObserversTestMode();
   mustInterruptResponses();
   let publicList = yield promiseNewList();
   let privateList = yield Downloads.getList(Downloads.PRIVATE);
   let download1 = yield promiseNewDownload(httpUrl("interruptible.txt"));
   let download2 = yield promiseNewDownload(httpUrl("interruptible.txt"));
   let promiseAttempt1 = download1.start();
   let promiseAttempt2 = download2.start();
   // Add downloads to lists.
   yield publicList.add(download1);
   yield privateList.add(download2);
   notifyPromptObservers(true, 2, 1);
   // Allow the downloads to complete.
   continueResponses();
   yield promiseAttempt1;
   yield promiseAttempt2;
   // Clean up.
   yield publicList.remove(download1);
   yield privateList.remove(download2);
 });
 /**
  * Tests suspending and resuming as well as going offline and then online again.
  * The downloads should stop when suspending and start again when resuming.
  */
 add_task(function test_suspend_resume()
 {
   enableObserversTestMode();
   // The default wake delay is 10 seconds, so set the wake delay to be much
   // faster for these tests.
   Services.prefs.setIntPref("browser.download.manager.resumeOnWakeDelay", 5);
   let addDownload = function(list)
   {
     return Task.spawn(function () {
       let download = yield promiseNewDownload(httpUrl("interruptible.txt"));
       download.start();
       list.add(download);
       throw new Task.Result(download);
     });
   }
   let publicList = yield promiseNewList();
   let privateList = yield promiseNewList(true);
   let download1 = yield addDownload(publicList);
   let download2 = yield addDownload(publicList);
   let download3 = yield addDownload(privateList);
   let download4 = yield addDownload(privateList);
   let download5 = yield addDownload(publicList);
   // First, check that the downloads are all canceled when going to sleep.
   Services.obs.notifyObservers(null, "sleep_notification", null);
   do_check_true(download1.canceled);
   do_check_true(download2.canceled);
   do_check_true(download3.canceled);
   do_check_true(download4.canceled);
   do_check_true(download5.canceled);
   // Remove a download. It should not be started again.
   publicList.remove(download5);
   do_check_true(download5.canceled);
   // When waking up again, the downloads start again after the wake delay. To be
   // more robust, don't check after a delay but instead just wait for the
   // downloads to finish.
   Services.obs.notifyObservers(null, "wake_notification", null);
   yield download1.whenSucceeded();
   yield download2.whenSucceeded();
   yield download3.whenSucceeded();
   yield download4.whenSucceeded();
   // Downloads should no longer be canceled. However, as download5 was removed
   // from the public list, it will not be restarted.
   do_check_false(download1.canceled);
   do_check_true(download5.canceled);
   // Create four new downloads and check for going offline and then online again.
   download1 = yield addDownload(publicList);
   download2 = yield addDownload(publicList);
   download3 = yield addDownload(privateList);
   download4 = yield addDownload(privateList);
   // Going offline should cancel the downloads.
   Services.obs.notifyObservers(null, "network:offline-about-to-go-offline", null);
   do_check_true(download1.canceled);
   do_check_true(download2.canceled);
   do_check_true(download3.canceled);
   do_check_true(download4.canceled);
   // Going back online should start the downloads again.
   Services.obs.notifyObservers(null, "network:offline-status-changed", "online");
   yield download1.whenSucceeded();
   yield download2.whenSucceeded();
   yield download3.whenSucceeded();
   yield download4.whenSucceeded();
   Services.prefs.clearUserPref("browser.download.manager.resumeOnWakeDelay");
 });
 /**
  * Tests both the downloads list and the in-progress downloads are clear when
  * private browsing observer is notified.
  */
 add_task(function test_exit_private_browsing()
 {
   enableObserversTestMode();
   mustInterruptResponses();
   let privateList = yield promiseNewList(true);
   let download1 = yield promiseNewDownload(httpUrl("source.txt"));
   let download2 = yield promiseNewDownload(httpUrl("interruptible.txt"));
   let promiseAttempt1 = download1.start();
   let promiseAttempt2 = download2.start();
   // Add downloads to list.
   yield privateList.add(download1);
   yield privateList.add(download2);
   // Complete the download.
   yield promiseAttempt1;
   do_check_eq((yield privateList.getAll()).length, 2);
   // Simulate exiting the private browsing.
   DownloadIntegration._deferTestClearPrivateList = Promise.defer();
   Services.obs.notifyObservers(null, "last-pb-context-exited", null);
   let result = yield DownloadIntegration._deferTestClearPrivateList.promise;
   do_check_eq(result, "success");
   do_check_eq((yield privateList.getAll()).length, 0);
   continueResponses();
 });
 ////////////////////////////////////////////////////////////////////////////////
 //// Termination
 let tailFile = do_get_file("tail.js");
 Services.scriptloader.loadSubScript(NetUtil.newURI(tailFile).spec);