tor-browser

test_BackupService_retryHeuristic.js (7651B)

---

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

"use strict";

ChromeUtils.defineESModuleGetters(this, {
 BackupError: "resource:///modules/backup/BackupError.mjs",
 ERRORS: "chrome://browser/content/backup/backup-constants.mjs",
 TestUtils: "resource://testing-common/TestUtils.sys.mjs",
});

const BACKUP_RETRY_LIMIT_PREF_NAME = "browser.backup.backup-retry-limit";
const DISABLED_ON_IDLE_RETRY_PREF_NAME =
 "browser.backup.disabled-on-idle-backup-retry";
const BACKUP_ERROR_CODE_PREF_NAME = "browser.backup.errorCode";
const MINIMUM_TIME_BETWEEN_BACKUPS_SECONDS_PREF_NAME =
 "browser.backup.scheduled.minimum-time-between-backups-seconds";
const SCHEDULED_BACKUPS_ENABLED_PREF_NAME = "browser.backup.scheduled.enabled";
const BACKUP_DEBUG_INFO_PREF_NAME = "browser.backup.backup-debug-info";
const BACKUP_DEFAULT_LOCATION_PREF_NAME = "browser.backup.location";

const RETRIES_FOR_TEST = 4;

async function create_backup_failure_expected_calls(
 bs,
 callCount,
 assertionMsg
) {
 assertionMsg = assertionMsg
   ? assertionMsg
   : `createBackup should be called ${callCount} times`;

 let originalBackoffTime = BackupService.backoffSeconds();

 bs.createBackupOnIdleDispatch({});

 // testing that callCount remains the same, skip all the other checks
 if (callCount == bs.createBackup.callCount) {
   Assert.equal(bs.createBackup.callCount, callCount, assertionMsg);

   return;
 }

 // Wait for in progress states to change
 // so that the errorRetries can be updated

 await bsInProgressStateUpdate(bs, true);
 await bsInProgressStateUpdate(bs, false);

 // propagate prefs
 await TestUtils.waitForTick();

 // have we called createBackup more times than allowed retries?
 // if so, the retries should reset and retrying should
 // disable calling createBackup again
 if (callCount == RETRIES_FOR_TEST + 1) {
   Assert.equal(
     Glean.browserBackup.backupThrottled.testGetValue().length,
     1,
     "backupThrottled telemetry was sent"
   );

   Assert.ok(
     Services.prefs.getBoolPref(DISABLED_ON_IDLE_RETRY_PREF_NAME),
     "Disable on idle is now enabled - no more retries allowed"
   );
 }
 // we expect createBackup to be called, but it shouldn't succeed
 else {
   Assert.equal(
     BackupService.backoffSeconds(),
     2 * originalBackoffTime,
     "Backoff time should have doubled"
   );

   Assert.ok(
     !Services.prefs.getBoolPref(DISABLED_ON_IDLE_RETRY_PREF_NAME),
     "Disable on idle is disabled - which means that we can do more retries!"
   );

   Assert.equal(
     Glean.browserBackup.backupThrottled.testGetValue(),
     null,
     "backupThrottled telemetry was not sent yet"
   );
 }

 Assert.equal(bs.createBackup.callCount, callCount, assertionMsg);

 Assert.equal(
   Services.prefs.getIntPref(BACKUP_ERROR_CODE_PREF_NAME),
   ERRORS.UNKNOWN,
   "Error code has been set"
 );
}

function bsInProgressStateUpdate(bs, isBackupInProgress) {
 // Check if already in desired state
 if (bs.state.backupInProgress === isBackupInProgress) {
   return Promise.resolve();
 }

 return new Promise(resolve => {
   const listener = () => {
     if (bs.state.backupInProgress === isBackupInProgress) {
       bs.removeEventListener("BackupService:StateUpdate", listener);
       resolve();
     }
   };

   bs.addEventListener("BackupService:StateUpdate", listener);
 });
}

add_setup(async () => {
 const TEST_PROFILE_PATH = await IOUtils.createUniqueDirectory(
   PathUtils.tempDir,
   "testBackup"
 );

 Services.prefs.setStringPref(
   BACKUP_DEFAULT_LOCATION_PREF_NAME,
   TEST_PROFILE_PATH
 );
 Services.prefs.setBoolPref(SCHEDULED_BACKUPS_ENABLED_PREF_NAME, true);
 Services.prefs.setIntPref(BACKUP_RETRY_LIMIT_PREF_NAME, RETRIES_FOR_TEST);
 Services.prefs.setBoolPref(DISABLED_ON_IDLE_RETRY_PREF_NAME, false);

 setupProfile();

 registerCleanupFunction(async () => {
   Services.prefs.clearUserPref(BACKUP_DEFAULT_LOCATION_PREF_NAME);
   Services.prefs.clearUserPref(SCHEDULED_BACKUPS_ENABLED_PREF_NAME);
   Services.prefs.clearUserPref(BACKUP_RETRY_LIMIT_PREF_NAME);
   Services.prefs.clearUserPref(DISABLED_ON_IDLE_RETRY_PREF_NAME);

   await IOUtils.remove(TEST_PROFILE_PATH, { recursive: true });
 });
});

add_task(async function test_retries_no_backoff() {
 Services.fog.testResetFOG();

 let bs = new BackupService();
 let sandbox = sinon.createSandbox();
 // Make createBackup fail intentionally
 sandbox
   .stub(bs, "resolveArchiveDestFolderPath")
   .rejects(new BackupError("forced failure", ERRORS.UNKNOWN));

 // stub out idleDispatch
 sandbox.stub(ChromeUtils, "idleDispatch").callsFake(callback => callback());

 sandbox.spy(bs, "createBackup");

 const n = Services.prefs.getIntPref(BACKUP_RETRY_LIMIT_PREF_NAME);
 // now that we have an idle service, let's call create backup RETRY_LIMIT times
 for (let i = 0; i <= n; i++) {
   // ensure that there is no error code set
   Services.prefs.setIntPref(BACKUP_ERROR_CODE_PREF_NAME, ERRORS.NONE);

   // Set the lastBackupAttempt to the current backoff threshold, to avoid hitting
   // the exponential backoff clause for this test.
   Services.prefs.setStringPref(
     BACKUP_DEBUG_INFO_PREF_NAME,
     JSON.stringify({
       lastBackupAttempt:
         Math.floor(Date.now() / 1000) - (BackupService.backoffSeconds() + 1),
       errorCode: ERRORS.UNKNOWN,
       lastRunStep: 0,
     })
   );

   await create_backup_failure_expected_calls(bs, i + 1);
 }
 // check if it switched to no longer creating backups on idle
 await create_backup_failure_expected_calls(
   bs,
   bs.createBackup.callCount,
   "createBackup was not called since we hit the retry limit"
 );

 sandbox.restore();
});

add_task(async function test_exponential_backoff() {
 Services.fog.testResetFOG();

 let bs = new BackupService();
 let sandbox = sinon.createSandbox();
 const createBackupFailureStub = sandbox
   .stub(bs, "resolveArchiveDestFolderPath")
   .rejects(new BackupError("forced failure", ERRORS.UNKNOWN));

 sandbox.stub(ChromeUtils, "idleDispatch").callsFake(callback => callback());
 sandbox.spy(bs, "createBackup");

 Services.prefs.setIntPref(BACKUP_ERROR_CODE_PREF_NAME, ERRORS.NONE);
 Services.prefs.setStringPref(
   BACKUP_DEBUG_INFO_PREF_NAME,
   JSON.stringify({
     lastBackupAttempt:
       Math.floor(Date.now() / 1000) - (BackupService.backoffSeconds() + 1),
     errorCode: ERRORS.UNKNOWN,
     lastRunStep: 0,
   })
 );

 Services.prefs.setIntPref(MINIMUM_TIME_BETWEEN_BACKUPS_SECONDS_PREF_NAME, 0);
 registerCleanupFunction(() => {
   Services.prefs.clearUserPref(
     MINIMUM_TIME_BETWEEN_BACKUPS_SECONDS_PREF_NAME
   );
 });

 await create_backup_failure_expected_calls(bs, 1);

 // Remove the stub, ensure that a success leads to the prefs
 // and retries resetting
 createBackupFailureStub.restore();

 // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
 await new Promise(resolve => setTimeout(resolve, 10));

 let testProfilePath = await IOUtils.createUniqueDirectory(
   PathUtils.tempDir,
   "testBackup_profile"
 );

 await bs.createBackup({
   profilePath: testProfilePath,
 });

 Assert.equal(
   Services.prefs.getIntPref(BACKUP_ERROR_CODE_PREF_NAME),
   ERRORS.NONE,
   "The error code is reset to NONE"
 );

 Assert.equal(
   60,
   BackupService.backoffSeconds(),
   "The exponential backoff is reset to 1 minute (60s)"
 );

 Assert.ok(
   !Services.prefs.getStringPref(BACKUP_DEBUG_INFO_PREF_NAME, null),
   "Error debug info has been cleared"
 );

 sandbox.restore();
});