tor-browser

test_connection_online_backup.js (8238B)

---

/* Any copyright is dedicated to the Public Domain.
http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

/**
* This test file tests the backupToFileAsync function on
* mozIStorageAsyncConnection, which is implemented for mozStorageConnection.
* (but not implemented for mozilla::dom::cache::Connection).
*/

// The name of the backup database file that will be created.
const BACKUP_FILE_NAME = "test_storage.sqlite.backup";
// The number of rows to insert into the test table in the source
// database.
const TEST_ROWS = 10;
// The page size to set on the source database. During setup, we assert that
// this does not match the default page size.
const TEST_PAGE_SIZE = 512;

/**
* This setup function creates a table inside of the test database and inserts
* some test rows. Critically, it keeps the connection to the database _open_
* so that we can test the scenario where a database is copied with existing
* open connections.
*
* The database is closed in a cleanup function.
*/
add_setup(async () => {
 let conn = await openAsyncDatabase(getTestDB());

 Assert.notEqual(
   conn.defaultPageSize,
   TEST_PAGE_SIZE,
   "Should not default to having the TEST_PAGE_SIZE"
 );

 await executeSimpleSQLAsync(conn, "PRAGMA page_size = " + TEST_PAGE_SIZE);

 let createStmt = conn.createAsyncStatement("CREATE TABLE test(name TEXT)");
 await executeAsync(createStmt);
 createStmt.finalize();

 registerCleanupFunction(async () => {
   await asyncClose(conn);
 });
});

/**
* Erases the test table and inserts TEST_ROWS rows into it.
*
* @param {mozIStorageAsyncConnection} connection
*   The connection to use to prepare the database.
* @returns {Promise<undefined>}
*/
async function prepareSourceDatabase(connection) {
 await executeSimpleSQLAsync(connection, "DELETE from test");
 for (let i = 0; i < TEST_ROWS; ++i) {
   let name = `Database row #${i}`;
   let stmt = connection.createAsyncStatement(
     "INSERT INTO test (name) VALUES (:name)"
   );
   stmt.params.name = name;
   let result = await executeAsync(stmt);
   stmt.finalize();
   Assert.ok(Components.isSuccessCode(result), `Inserted test row #${i}`);
 }
}

/**
* Gets the test DB prepared with the testing table and rows.
*
* @returns {Promise<mozIStorageAsyncConnection>}
*/
async function getPreparedAsyncDatabase() {
 let connection = await openAsyncDatabase(getTestDB());
 await prepareSourceDatabase(connection);
 return connection;
}

/**
* Creates a copy of the database connected to via connection, and
* returns an nsIFile pointing at the created copy file once the
* copy is complete.
*
* @param {mozIStorageAsyncConnection} connection
*   A connection to a database that should be copied.
* @param {number} [pagesPerStep]
*   The number of pages to copy per step. If not supplied or is 0, falls back
*   to the platform default which is currently 5.
* @param {number} [stepDelayMs]
*   The number of milliseconds to wait between copying step. If not supplied
*   or is 0, falls back to the platform default which is currently 250.
* @returns {Promise<nsIFile>}
*/
async function createCopy(connection, pagesPerStep, stepDelayMs) {
 let destFilePath = PathUtils.join(PathUtils.profileDir, BACKUP_FILE_NAME);
 let destFile = await IOUtils.getFile(destFilePath);
 Assert.ok(
   !(await IOUtils.exists(destFilePath)),
   "Backup file shouldn't exist yet."
 );

 await new Promise(resolve => {
   connection.backupToFileAsync(
     destFile,
     result => {
       Assert.ok(Components.isSuccessCode(result));
       resolve(result);
     },
     pagesPerStep,
     stepDelayMs
   );
 });

 return destFile;
}

/**
* Opens up the database at file, asserts that the page_size matches
* TEST_PAGE_SIZE, and that the number of rows in the test table matches
* expectedEntries. Closes the connection after these assertions.
*
* @param {nsIFile} file
*   The database file to be opened and queried.
* @param {number} [expectedEntries=TEST_ROWS]
*   The expected number of rows in the test table. Defaults to TEST_ROWS.
* @returns {Promise<undefined>}
*/
async function assertSuccessfulCopy(file, expectedEntries = TEST_ROWS) {
 let conn = await openAsyncDatabase(file);

 await executeSimpleSQLAsync(conn, "PRAGMA page_size", resultSet => {
   let result = resultSet.getNextRow();
   Assert.equal(TEST_PAGE_SIZE, result.getResultByIndex(0));
 });

 let stmt = conn.createAsyncStatement("SELECT COUNT(*) FROM test");
 let results = await new Promise(resolve => {
   executeAsync(stmt, resolve);
 });
 stmt.finalize();
 let row = results.getNextRow();
 let count = row.getResultByName("COUNT(*)");
 Assert.equal(count, expectedEntries, "Got the expected entries");

 Assert.ok(
   !file.leafName.endsWith(".tmp"),
   "Should not end in .tmp extension"
 );

 await asyncClose(conn);
}

/**
* Test the basic behaviour of backupToFileAsync, and ensure that the copied
* database has the same characteristics and contents as the source database.
*/
add_task(async function test_backupToFileAsync() {
 let newConnection = await getPreparedAsyncDatabase();
 let copyFile = await createCopy(newConnection);
 Assert.ok(
   await IOUtils.exists(copyFile.path),
   "A new file was created by backupToFileAsync"
 );

 await assertSuccessfulCopy(copyFile);
 await IOUtils.remove(copyFile.path);
 await asyncClose(newConnection);
});

/**
* Tests that if insertions are underway during a copy, that those insertions
* show up in the copied database.
*/
add_task(async function test_backupToFileAsync_during_insert() {
 let newConnection = await getPreparedAsyncDatabase();
 const NEW_ENTRIES = 5;

 let copyFilePromise = createCopy(newConnection);
 let inserts = [];
 for (let i = 0; i < NEW_ENTRIES; ++i) {
   let name = `New database row #${i}`;
   let stmt = newConnection.createAsyncStatement(
     "INSERT INTO test (name) VALUES (:name)"
   );
   stmt.params.name = name;
   inserts.push(executeAsync(stmt));
   stmt.finalize();
 }
 await Promise.all(inserts);
 let copyFile = await copyFilePromise;

 Assert.ok(
   await IOUtils.exists(copyFile.path),
   "A new file was created by backupToFileAsync"
 );

 await assertSuccessfulCopy(copyFile, TEST_ROWS + NEW_ENTRIES);
 await IOUtils.remove(copyFile.path);
 await asyncClose(newConnection);
});

/**
* Tests that alternative pages-per-step and step delay values can be set when
* calling backupToFileAsync.
*/
add_task(async function test_backupToFileAsync_during_insert() {
 let newConnection = await getPreparedAsyncDatabase();

 // Let's try some higher values...
 let copyFile = await createCopy(newConnection, 15, 500);
 Assert.ok(
   await IOUtils.exists(copyFile.path),
   "A new file was created by backupToFileAsync"
 );

 await assertSuccessfulCopy(copyFile);
 await IOUtils.remove(copyFile.path);

 // And now we'll try some lower values...
 copyFile = await createCopy(newConnection, 1, 25);
 Assert.ok(
   await IOUtils.exists(copyFile.path),
   "A new file was created by backupToFileAsync"
 );

 await assertSuccessfulCopy(copyFile);
 await IOUtils.remove(copyFile.path);

 await asyncClose(newConnection);
});

/**
* Tests the behaviour of backupToFileAsync as exposed through Sqlite.sys.mjs.
*/
add_task(async function test_backupToFileAsync_via_Sqlite_module() {
 let xpcomConnection = await getPreparedAsyncDatabase();
 let moduleConnection = await Sqlite.openConnection({
   path: xpcomConnection.databaseFile.path,
 });

 let copyFilePath = PathUtils.join(PathUtils.profileDir, BACKUP_FILE_NAME);
 await moduleConnection.backup(copyFilePath);
 let copyFile = await IOUtils.getFile(copyFilePath);
 Assert.ok(await IOUtils.exists(copyFilePath), "A new file was created");

 await assertSuccessfulCopy(copyFile);
 await IOUtils.remove(copyFile.path);

 // Also check that we can plumb through pagesPerStep and stepDelayMs.
 await moduleConnection.backup(copyFilePath, 15, 500);
 Assert.ok(await IOUtils.exists(copyFilePath), "A new file was created");
 await assertSuccessfulCopy(copyFile);
 await IOUtils.remove(copyFile.path);

 await moduleConnection.close();
 await asyncClose(xpcomConnection);
});