The Tor Browser: comparison toolkit/components/jsdownloads/test/unit/test_DownloadImport.js

comparison: toolkit/components/jsdownloads/test/unit/test_DownloadImport.js

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

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:e23934f8c7bb
+/* Any copyright is dedicated to the Public Domain.
+* http://creativecommons.org/publicdomain/zero/1.0/ */
+/**
+* Tests the DownloadImport object.
+*/
+"use strict";
+////////////////////////////////////////////////////////////////////////////////
+//// Globals
+XPCOMUtils.defineLazyModuleGetter(this, "Sqlite",
+"resource://gre/modules/Sqlite.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "DownloadImport",
+"resource://gre/modules/DownloadImport.jsm");
+// Importable states
+const DOWNLOAD_NOTSTARTED = -1;
+const DOWNLOAD_DOWNLOADING = 0;
+const DOWNLOAD_PAUSED = 4;
+const DOWNLOAD_QUEUED = 5;
+// Non importable states
+const DOWNLOAD_FAILED = 2;
+const DOWNLOAD_CANCELED = 3;
+const DOWNLOAD_BLOCKED_PARENTAL = 6;
+const DOWNLOAD_SCANNING = 7;
+const DOWNLOAD_DIRTY = 8;
+const DOWNLOAD_BLOCKED_POLICY = 9;
+// The TEST_DATA_TAINTED const is a version of TEST_DATA_SHORT in which the
+// beginning of the data was changed (with the TEST_DATA_REPLACEMENT value).
+// We use this to test that the entityID is properly imported and the download
+// can be resumed from where it was paused.
+// For simplification purposes, the test requires that TEST_DATA_SHORT and
+// TEST_DATA_TAINTED have the same length.
+const TEST_DATA_REPLACEMENT = "-changed- ";
+const TEST_DATA_TAINTED = TEST_DATA_REPLACEMENT +
+TEST_DATA_SHORT.substr(TEST_DATA_REPLACEMENT.length);
+const TEST_DATA_LENGTH = TEST_DATA_SHORT.length;
+// The length of the partial file that we'll write to disk as an existing
+// ongoing download.
+const TEST_DATA_PARTIAL_LENGTH = TEST_DATA_REPLACEMENT.length;
+// The value of the "maxBytes" column stored in the DB about the downloads.
+// It's intentionally different than TEST_DATA_LENGTH to test that each value
+// is seen when expected.
+const MAXBYTES_IN_DB = TEST_DATA_LENGTH - 10;
+let gDownloadsRowToImport;
+let gDownloadsRowNonImportable;
+/**
+* Creates a database with an empty moz_downloads table and leaves an
+* open connection to it.
+*
+* @param aPath
+*        String containing the path of the database file to be created.
+* @param aSchemaVersion
+*        Number with the version of the database schema to set.
+*
+* @return {Promise}
+* @resolves The open connection to the database.
+* @rejects If an error occurred during the database creation.
+*/
+function promiseEmptyDatabaseConnection({aPath, aSchemaVersion}) {
+return Task.spawn(function () {
+let connection = yield Sqlite.openConnection({ path: aPath });
+yield connection.execute("CREATE TABLE moz_downloads ("
++ "id INTEGER PRIMARY KEY,"
++ "name TEXT,"
++ "source TEXT,"
++ "target TEXT,"
++ "tempPath TEXT,"
++ "startTime INTEGER,"
++ "endTime INTEGER,"
++ "state INTEGER,"
++ "referrer TEXT,"
++ "entityID TEXT,"
++ "currBytes INTEGER NOT NULL DEFAULT 0,"
++ "maxBytes INTEGER NOT NULL DEFAULT -1,"
++ "mimeType TEXT,"
++ "preferredApplication TEXT,"
++ "preferredAction INTEGER NOT NULL DEFAULT 0,"
++ "autoResume INTEGER NOT NULL DEFAULT 0,"
++ "guid TEXT)");
+yield connection.setSchemaVersion(aSchemaVersion);
+throw new Task.Result(connection);
+});
+}
+/**
+* Inserts a new entry in the database with the given columns' values.
+*
+* @param aConnection
+*        The database connection.
+* @param aDownloadRow
+*        An object representing the values for each column of the row
+*        being inserted.
+*
+* @return {Promise}
+* @resolves When the operation completes.
+* @rejects If there's an error inserting the row.
+*/
+function promiseInsertRow(aConnection, aDownloadRow) {
+// We can't use the aDownloadRow obj directly in the execute statement
+// because the obj bind code in Sqlite.jsm doesn't allow objects
+// with extra properties beyond those being binded. So we might as well
+// use an array as it is simpler.
+let values = [
+aDownloadRow.source, aDownloadRow.target, aDownloadRow.tempPath,
+aDownloadRow.startTime.getTime() * 1000, aDownloadRow.state,
+aDownloadRow.referrer, aDownloadRow.entityID, aDownloadRow.maxBytes,
+aDownloadRow.mimeType, aDownloadRow.preferredApplication,
+aDownloadRow.preferredAction, aDownloadRow.autoResume
+];
+return aConnection.execute("INSERT INTO moz_downloads ("
++ "name, source, target, tempPath, startTime,"
++ "endTime, state, referrer, entityID, currBytes,"
++ "maxBytes, mimeType, preferredApplication,"
++ "preferredAction, autoResume, guid)"
++ "VALUES ("
++ "'', ?, ?, ?, ?, " //name,
++ "0, ?, ?, ?, 0, "  //endTime, currBytes
++ " ?, ?, ?, "       //
++ " ?, ?, '')",      //and guid are not imported
+values);
+}
+/**
+* Retrieves the number of rows in the moz_downloads table of the
+* database.
+*
+* @param aConnection
+*        The database connection.
+*
+* @return {Promise}
+* @resolves With the number of rows.
+* @rejects Never.
+*/
+function promiseTableCount(aConnection) {
+return aConnection.execute("SELECT COUNT(*) FROM moz_downloads")
+.then(res => res[0].getResultByName("COUNT(*)"))
+.then(null, Cu.reportError);
+}
+/**
+* Briefly opens a network channel to a given URL to retrieve
+* the entityID of this url, as generated by the network code.
+*
+* @param aUrl
+*        The URL to retrieve the entityID.
+*
+* @return {Promise}
+* @resolves The EntityID of the given URL.
+* @rejects When there's a problem accessing the URL.
+*/
+function promiseEntityID(aUrl) {
+let deferred = Promise.defer();
+let entityID = "";
+let channel = NetUtil.newChannel(NetUtil.newURI(aUrl));
+channel.asyncOpen({
+onStartRequest: function (aRequest) {
+if (aRequest instanceof Ci.nsIResumableChannel) {
+entityID = aRequest.entityID;
+}
+aRequest.cancel(Cr.NS_BINDING_ABORTED);
+},
+onStopRequest: function (aRequest, aContext, aStatusCode) {
+if (aStatusCode == Cr.NS_BINDING_ABORTED) {
+deferred.resolve(entityID);
+} else {
+deferred.reject("Unexpected status code received");
+}
+},
+onDataAvailable: function () {}
+}, null);
+return deferred.promise;
+}
+/**
+* Gets a file path to a temporary writeable download target, in the
+* correct format as expected to be stored in the downloads database,
+* which is file:///absolute/path/to/file
+*
+* @param aLeafName
+*        A hint leaf name for the file.
+*
+* @return String The path to the download target.
+*/
+function getDownloadTarget(aLeafName) {
+return NetUtil.newURI(getTempFile(aLeafName)).spec;
+}
+/**
+* Generates a temporary partial file to use as an in-progress
+* download. The file is written to disk with a part of the total expected
+* download content pre-written.
+*
+* @param aLeafName
+*        A hint leaf name for the file.
+* @param aTainted
+*        A boolean value. When true, the partial content of the file
+*        will be different from the expected content of the original source
+*        file. See the declaration of TEST_DATA_TAINTED for more information.
+*
+* @return {Promise}
+* @resolves When the operation completes, and returns a string with the path
+*           to the generated file.
+* @rejects If there's an error writing the file.
+*/
+function getPartialFile(aLeafName, aTainted = false) {
+let tempDownload = getTempFile(aLeafName);
+let partialContent = aTainted
+? TEST_DATA_TAINTED.substr(0, TEST_DATA_PARTIAL_LENGTH)
+: TEST_DATA_SHORT.substr(0, TEST_DATA_PARTIAL_LENGTH);
+return OS.File.writeAtomic(tempDownload.path, partialContent,
+{ tmpPath: tempDownload.path + ".tmp",
+flush: true })
+.then(() => tempDownload.path);
+}
+/**
+* Generates a Date object to be used as the startTime for the download rows
+* in the DB. A date that is obviously different from the current time is
+* generated to make sure this stored data and a `new Date()` can't collide.
+*
+* @param aOffset
+*        A offset from the base generated date is used to differentiate each
+*        row in the database.
+*
+* @return A Date object.
+*/
+function getStartTime(aOffset) {
+return new Date(1000000 + (aOffset * 10000));
+}
+/**
+* Performs various checks on an imported Download object to make sure
+* all properties are properly set as expected from the import procedure.
+*
+* @param aDownload
+*        The Download object to be checked.
+* @param aDownloadRow
+*        An object that represents a row from the original database table,
+*        with extra properties describing expected values that are not
+*        explictly part of the database.
+*
+* @return {Promise}
+* @resolves When the operation completes
+* @rejects Never
+*/
+function checkDownload(aDownload, aDownloadRow) {
+return Task.spawn(function() {
+do_check_eq(aDownload.source.url, aDownloadRow.source);
+do_check_eq(aDownload.source.referrer, aDownloadRow.referrer);
+do_check_eq(aDownload.target.path,
+NetUtil.newURI(aDownloadRow.target)
+.QueryInterface(Ci.nsIFileURL).file.path);
+do_check_eq(aDownload.target.partFilePath, aDownloadRow.tempPath);
+if (aDownloadRow.expectedResume) {
+do_check_true(!aDownload.stopped || aDownload.succeeded);
+yield promiseDownloadStopped(aDownload);
+do_check_true(aDownload.succeeded);
+do_check_eq(aDownload.progress, 100);
+// If the download has resumed, a new startTime will be set.
+// By calling toJSON we're also testing that startTime is a Date object.
+do_check_neq(aDownload.startTime.toJSON(),
+aDownloadRow.startTime.toJSON());
+} else {
+do_check_false(aDownload.succeeded);
+do_check_eq(aDownload.startTime.toJSON(),
+aDownloadRow.startTime.toJSON());
+}
+do_check_eq(aDownload.stopped, true);
+let serializedSaver = aDownload.saver.toSerializable();
+if (typeof(serializedSaver) == "object") {
+do_check_eq(serializedSaver.type, "copy");
+} else {
+do_check_eq(serializedSaver, "copy");
+}
+if (aDownloadRow.entityID) {
+do_check_eq(aDownload.saver.entityID, aDownloadRow.entityID);
+}
+do_check_eq(aDownload.currentBytes, aDownloadRow.expectedCurrentBytes);
+do_check_eq(aDownload.totalBytes, aDownloadRow.expectedTotalBytes);
+if (aDownloadRow.expectedContent) {
+let fileToCheck = aDownloadRow.expectedResume
+? aDownload.target.path
+: aDownload.target.partFilePath;
+yield promiseVerifyContents(fileToCheck, aDownloadRow.expectedContent);
+}
+do_check_eq(aDownload.contentType, aDownloadRow.expectedContentType);
+do_check_eq(aDownload.launcherPath, aDownloadRow.preferredApplication);
+do_check_eq(aDownload.launchWhenSucceeded,
+aDownloadRow.preferredAction != Ci.nsIMIMEInfo.saveToDisk);
+});
+}
+////////////////////////////////////////////////////////////////////////////////
+//// Preparation tasks
+/**
+* Prepares the list of downloads to be added to the database that should
+* be imported by the import procedure.
+*/
+add_task(function prepareDownloadsToImport() {
+let sourceUrl = httpUrl("source.txt");
+let sourceEntityId = yield promiseEntityID(sourceUrl);
+gDownloadsRowToImport = [
+// Paused download with autoResume and a partial file. By
+// setting the correct entityID the download can resume from
+// where it stopped, and to test that this works properly we
+// intentionally set different data in the beginning of the
+// partial file to make sure it was not replaced.
+{
+source: sourceUrl,
+target: getDownloadTarget("inprogress1.txt"),
+tempPath: yield getPartialFile("inprogress1.txt.part", true),
+startTime: getStartTime(1),
+state: DOWNLOAD_PAUSED,
+referrer: httpUrl("referrer1"),
+entityID: sourceEntityId,
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType1",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication1",
+autoResume: 1,
+// Even though the information stored in the DB said
+// maxBytes was MAXBYTES_IN_DB, the download turned out to be
+// a different length. Here we make sure the totalBytes property
+// was correctly set with the actual value. The same consideration
+// applies to the contentType.
+expectedCurrentBytes: TEST_DATA_LENGTH,
+expectedTotalBytes: TEST_DATA_LENGTH,
+expectedResume: true,
+expectedContentType: "text/plain",
+expectedContent: TEST_DATA_TAINTED,
+},
+// Paused download with autoResume and a partial file,
+// but missing entityID. This means that the download will
+// start from beginning, and the entire original content of the
+// source file should replace the different data that was stored
+// in the partial file.
+{
+source: sourceUrl,
+target: getDownloadTarget("inprogress2.txt"),
+tempPath: yield getPartialFile("inprogress2.txt.part", true),
+startTime: getStartTime(2),
+state: DOWNLOAD_PAUSED,
+referrer: httpUrl("referrer2"),
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType2",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication2",
+autoResume: 1,
+expectedCurrentBytes: TEST_DATA_LENGTH,
+expectedTotalBytes: TEST_DATA_LENGTH,
+expectedResume: true,
+expectedContentType: "text/plain",
+expectedContent: TEST_DATA_SHORT
+},
+// Paused download with no autoResume and a partial file.
+{
+source: sourceUrl,
+target: getDownloadTarget("inprogress3.txt"),
+tempPath: yield getPartialFile("inprogress3.txt.part"),
+startTime: getStartTime(3),
+state: DOWNLOAD_PAUSED,
+referrer: httpUrl("referrer3"),
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType3",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication3",
+autoResume: 0,
+// Since this download has not been resumed, the actual data
+// about its total size and content type is not known.
+// Therefore, we're going by the information imported from the DB.
+expectedCurrentBytes: TEST_DATA_PARTIAL_LENGTH,
+expectedTotalBytes: MAXBYTES_IN_DB,
+expectedResume: false,
+expectedContentType: "mimeType3",
+expectedContent: TEST_DATA_SHORT.substr(0, TEST_DATA_PARTIAL_LENGTH),
+},
+// Paused download with autoResume and no partial file.
+{
+source: sourceUrl,
+target: getDownloadTarget("inprogress4.txt"),
+tempPath: "",
+startTime: getStartTime(4),
+state: DOWNLOAD_PAUSED,
+referrer: httpUrl("referrer4"),
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "text/plain",
+preferredAction: Ci.nsIMIMEInfo.useHelperApp,
+preferredApplication: "prerredApplication4",
+autoResume: 1,
+expectedCurrentBytes: TEST_DATA_LENGTH,
+expectedTotalBytes: TEST_DATA_LENGTH,
+expectedResume: true,
+expectedContentType: "text/plain",
+expectedContent: TEST_DATA_SHORT
+},
+// Paused download with no autoResume and no partial file.
+{
+source: sourceUrl,
+target: getDownloadTarget("inprogress5.txt"),
+tempPath: "",
+startTime: getStartTime(5),
+state: DOWNLOAD_PAUSED,
+referrer: httpUrl("referrer4"),
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "text/plain",
+preferredAction: Ci.nsIMIMEInfo.useSystemDefault,
+preferredApplication: "prerredApplication5",
+autoResume: 0,
+expectedCurrentBytes: 0,
+expectedTotalBytes: MAXBYTES_IN_DB,
+expectedResume: false,
+expectedContentType: "text/plain",
+},
+// Queued download with no autoResume and no partial file.
+// Even though autoResume=0, queued downloads always autoResume.
+{
+source: sourceUrl,
+target: getDownloadTarget("inprogress6.txt"),
+tempPath: "",
+startTime: getStartTime(6),
+state: DOWNLOAD_QUEUED,
+referrer: httpUrl("referrer6"),
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "text/plain",
+preferredAction: Ci.nsIMIMEInfo.useHelperApp,
+preferredApplication: "prerredApplication6",
+autoResume: 0,
+expectedCurrentBytes: TEST_DATA_LENGTH,
+expectedTotalBytes: TEST_DATA_LENGTH,
+expectedResume: true,
+expectedContentType: "text/plain",
+expectedContent: TEST_DATA_SHORT
+},
+// Notstarted download with no autoResume and no partial file.
+// Even though autoResume=0, notstarted downloads always autoResume.
+{
+source: sourceUrl,
+target: getDownloadTarget("inprogress7.txt"),
+tempPath: "",
+startTime: getStartTime(7),
+state: DOWNLOAD_NOTSTARTED,
+referrer: httpUrl("referrer7"),
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "text/plain",
+preferredAction: Ci.nsIMIMEInfo.useHelperApp,
+preferredApplication: "prerredApplication7",
+autoResume: 0,
+expectedCurrentBytes: TEST_DATA_LENGTH,
+expectedTotalBytes: TEST_DATA_LENGTH,
+expectedResume: true,
+expectedContentType: "text/plain",
+expectedContent: TEST_DATA_SHORT
+},
+// Downloading download with no autoResume and a partial file.
+// Even though autoResume=0, downloading downloads always autoResume.
+{
+source: sourceUrl,
+target: getDownloadTarget("inprogress8.txt"),
+tempPath: yield getPartialFile("inprogress8.txt.part", true),
+startTime: getStartTime(8),
+state: DOWNLOAD_DOWNLOADING,
+referrer: httpUrl("referrer8"),
+entityID: sourceEntityId,
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "text/plain",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication8",
+autoResume: 0,
+expectedCurrentBytes: TEST_DATA_LENGTH,
+expectedTotalBytes: TEST_DATA_LENGTH,
+expectedResume: true,
+expectedContentType: "text/plain",
+expectedContent: TEST_DATA_TAINTED
+},
+];
+});
+/**
+* Prepares the list of downloads to be added to the database that should
+* *not* be imported by the import procedure.
+*/
+add_task(function prepareNonImportableDownloads()
+{
+gDownloadsRowNonImportable = [
+// Download with no source (should never happen in normal circumstances).
+{
+source: "",
+target: "nonimportable1.txt",
+tempPath: "",
+startTime: getStartTime(1),
+state: DOWNLOAD_PAUSED,
+referrer: "",
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType1",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication1",
+autoResume: 1
+},
+// state = DOWNLOAD_FAILED
+{
+source: httpUrl("source.txt"),
+target: "nonimportable2.txt",
+tempPath: "",
+startTime: getStartTime(2),
+state: DOWNLOAD_FAILED,
+referrer: "",
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType2",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication2",
+autoResume: 1
+},
+// state = DOWNLOAD_CANCELED
+{
+source: httpUrl("source.txt"),
+target: "nonimportable3.txt",
+tempPath: "",
+startTime: getStartTime(3),
+state: DOWNLOAD_CANCELED,
+referrer: "",
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType3",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication3",
+autoResume: 1
+},
+// state = DOWNLOAD_BLOCKED_PARENTAL
+{
+source: httpUrl("source.txt"),
+target: "nonimportable4.txt",
+tempPath: "",
+startTime: getStartTime(4),
+state: DOWNLOAD_BLOCKED_PARENTAL,
+referrer: "",
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType4",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication4",
+autoResume: 1
+},
+// state = DOWNLOAD_SCANNING
+{
+source: httpUrl("source.txt"),
+target: "nonimportable5.txt",
+tempPath: "",
+startTime: getStartTime(5),
+state: DOWNLOAD_SCANNING,
+referrer: "",
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType5",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication5",
+autoResume: 1
+},
+// state = DOWNLOAD_DIRTY
+{
+source: httpUrl("source.txt"),
+target: "nonimportable6.txt",
+tempPath: "",
+startTime: getStartTime(6),
+state: DOWNLOAD_DIRTY,
+referrer: "",
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType6",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication6",
+autoResume: 1
+},
+// state = DOWNLOAD_BLOCKED_POLICY
+{
+source: httpUrl("source.txt"),
+target: "nonimportable7.txt",
+tempPath: "",
+startTime: getStartTime(7),
+state: DOWNLOAD_BLOCKED_POLICY,
+referrer: "",
+entityID: "",
+maxBytes: MAXBYTES_IN_DB,
+mimeType: "mimeType7",
+preferredAction: Ci.nsIMIMEInfo.saveToDisk,
+preferredApplication: "prerredApplication7",
+autoResume: 1
+},
+];
+});
+////////////////////////////////////////////////////////////////////////////////
+//// Test
+/**
+* Creates a temporary Sqlite database with download data and perform an
+* import of that data to the new Downloads API to verify that the import
+* worked correctly.
+*/
+add_task(function test_downloadImport()
+{
+let connection = null;
+let downloadsSqlite = getTempFile("downloads.sqlite").path;
+try {
+// Set up the database.
+connection = yield promiseEmptyDatabaseConnection({
+aPath: downloadsSqlite,
+aSchemaVersion: 9
+});
+// Insert both the importable and non-importable
+// downloads together.
+for (let downloadRow of gDownloadsRowToImport) {
+yield promiseInsertRow(connection, downloadRow);
+}
+for (let downloadRow of gDownloadsRowNonImportable) {
+yield promiseInsertRow(connection, downloadRow);
+}
+// Check that every item was inserted.
+do_check_eq((yield promiseTableCount(connection)),
+gDownloadsRowToImport.length +
+gDownloadsRowNonImportable.length);
+} finally {
+// Close the connection so that DownloadImport can open it.
+yield connection.close();
+}
+// Import items.
+let list = yield promiseNewList(false);
+yield new DownloadImport(list, downloadsSqlite).import();
+let items = yield list.getAll();
+do_check_eq(items.length, gDownloadsRowToImport.length);
+for (let i = 0; i < gDownloadsRowToImport.length; i++) {
+yield checkDownload(items[i], gDownloadsRowToImport[i]);
+}
+})