/* 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);
});