passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/service/indexedDB_storage/ssoDataStorage.js

@@ -0,0 +1,290 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.9.0
+ */
+import SsoKitClientPartEntity from "../../model/entity/sso/ssoKitClientPartEntity";
+
+const DB_VERSION = 1;
+const DB_NAME = "sso_kit_db";
+const SSO_KEYS_OBECT_STORE = 'sso_kit';
+
+class SsoDataStorage {
+  /**
+   * Returns the local SSO client user's data.
+   *
+   * @returns {Promise<SsoKitClientPartEntity|null>}
+   * @public
+   */
+  static async get() {
+    const dbHandler = await this.getDbHandler();
+    const ssoClientData = await this.getSsoData(dbHandler);
+    dbHandler.close();
+    return ssoClientData;
+  }
+  /**
+   * Register locally the SSO client user's data.
+   *
+   * @param {SsoKitClientPartEntity} ssoKitClientPartEntity
+   * @returns {Promise<void>}
+   * @public
+   */
+  static async save(ssoKitClientPartEntity) {
+    const dbHandler = await this.getDbHandler();
+    await this.replaceSsoData(dbHandler, ssoKitClientPartEntity);
+    dbHandler.close();
+  }
+
+  /**
+   * Updates the local SSO kit with the given id.
+   * @param {SsoKitClientPartEntity} ssoKitClientPartEntity
+   * @returns {Promise<void>}
+   */
+  static async updateLocalKitIdWith(ssoKitClientPartEntity) {
+    const dbHandler = await this.getDbHandler();
+    await this.updateSsoDataWithId(dbHandler, ssoKitClientPartEntity.id);
+    dbHandler.close();
+  }
+
+  /**
+   * Updates the local SSO kit.
+   * @param {SsoKitClientPartEntity} ssoKitClientPartEntity
+   * @returns {Promise<void>}
+   */
+  static async updateLocalKitProviderWith(ssoKitClientPartEntity) {
+    const dbHandler = await this.getDbHandler();
+    await this.updateSsoDataWithProvider(dbHandler, ssoKitClientPartEntity.provider);
+    dbHandler.close();
+  }
+
+  /**
+   * Remove all existing data
+   * @return {Promise<void>}
+   */
+  static async flush() {
+    const dbHandler = await this.getDbHandler();
+    await this.clearData(dbHandler);
+  }
+
+  /**
+   * Opens the IndexedDB and returns an handler if the operation is successful.
+   *
+   * @returns {Promise<IDBDatabase>}
+   * @private
+   */
+  static async getDbHandler() {
+    return new Promise((resolve, reject) => {
+      const openRequest = indexedDB.open(DB_NAME, DB_VERSION);
+
+      openRequest.onupgradeneeded = e => {
+        const db = e.target.result;
+        console.log(`Upgrading SSO IndexedDB from version ${e.oldVersion} to version ${e.newVersion}.`);
+
+        if (e.oldVersion < 1) {
+          const objectStore = db.createObjectStore(SSO_KEYS_OBECT_STORE, {
+            keyPath: 'pk_id',
+          });
+          objectStore.createIndex("sso_kit", "sso_kit", {unique: true});
+        }
+
+        console.log("SSO IndexedDB upgrade completed.");
+      };
+
+      openRequest.onsuccess = () => {
+        resolve(openRequest.result);
+      };
+
+      openRequest.onerror = event => {
+        console.error("Database failed to open");
+        console.error(event);
+        reject();
+      };
+    });
+  }
+
+  /**
+   * Replace the current existing SSO client data or store new one.
+   *
+   * @param {IDBDatabase} dbHandler an opened IndexDB handler
+   * @param {ssoKitClientPartEntity} ssoKitClientPartEntity
+   * @returns {Promise<void>}
+   * @private
+   */
+  static async replaceSsoData(dbHandler, ssoKitClientPartEntity) {
+    await this.clearData(dbHandler);
+    await this.storeData(dbHandler, ssoKitClientPartEntity);
+  }
+
+  /**
+   * Finds the SSO client data from the IndexedDB
+   * @param {IDBDatabase} dbHandler
+   * @returns {Promise<SsoKitClientPartEntity|null>}
+   * @private
+   */
+  static async getSsoData(dbHandler) {
+    return new Promise((resolve, reject) => {
+      const transaction = dbHandler.transaction([SSO_KEYS_OBECT_STORE], 'readonly');
+      const objectStore = transaction.objectStore(SSO_KEYS_OBECT_STORE);
+      const cursor = objectStore.openCursor();
+      cursor.onsuccess = e => {
+        const cursor = e.target.result;
+
+        if (!cursor) {
+          resolve(null);
+          return;
+        }
+
+        try {
+          const ssoClientData = new SsoKitClientPartEntity(cursor.value.sso_kit);
+          resolve(ssoClientData);
+        } catch (e) {
+          // a validation error can happen if for instance the provider from the API is not supported yet on the API
+          console.error(e);
+          reject();
+        }
+      };
+
+      cursor.onerror = e => {
+        console.error("An error occured when trying to open the IndexDb cursor:", e);
+        reject();
+      };
+    });
+  }
+
+  /**
+   * Clear the current existing SSO client data.
+   *
+   * @param {IDBDatabase} dbHandler an opened IndexDB handler
+   * @returns {Promise<void>}
+   * @private
+   */
+  static async clearData(dbHandler) {
+    return new Promise((resolve, reject) => {
+      const transaction = dbHandler.transaction([SSO_KEYS_OBECT_STORE], 'readwrite');
+      const objectStore = transaction.objectStore(SSO_KEYS_OBECT_STORE);
+      const objectStoreRequest = objectStore.clear();
+
+      objectStoreRequest.onsuccess = () => {
+        console.log("IndexDB SSO client data cleared");
+        resolve();
+      };
+
+      objectStoreRequest.onerror = event => {
+        console.error(`The IndexedDB transaction couldn't be opened to clear the data`);
+        console.error(event);
+        reject();
+      };
+    });
+  }
+
+  /**
+   * Store the given SSO client data.
+   *
+   * @param {IDBDatabase} dbHandler an opened IndexDB handler
+   * @param {SsoKitClientPartEntity} ssoKitClientPartEntity
+   * @returns {Promise<void>}
+   * @private
+   */
+  static async storeData(dbHandler, ssoKitClientPartEntity) {
+    return new Promise((resolve, reject) => {
+      const transaction = dbHandler.transaction([SSO_KEYS_OBECT_STORE], 'readwrite');
+      const objectStore = transaction.objectStore(SSO_KEYS_OBECT_STORE);
+
+      const ssoKit = ssoKitClientPartEntity.toDbSerializableObject();
+      const addRequest = objectStore.add({pk_id: 1, sso_kit: ssoKit});
+
+      addRequest.onsuccess = () => {
+        console.log("New SSO client data stored successfully");
+      };
+
+      transaction.oncomplete = () => {
+        //Apparently, according to an MDN documentation, the modification is not 100% guaranteed to be flushed on disk for Firefox
+        resolve();
+      };
+
+      transaction.onerror = event => {
+        console.error(`The IndexedDB transaction couldn't be opened to add new data`);
+        console.error(event);
+        reject();
+      };
+    });
+  }
+
+  /**
+   * Updates the id of the SSO kit.
+   *
+   * @param {IDBDatabase} dbHandler an opened IndexDB handler
+   * @param {uuid} ssoKitClientPartEntity
+   * @returns {Promise<void>}
+   * @private
+   */
+  static async updateSsoDataWithId(dbHandler, ssoKitId) {
+    const ssoData = await this.getSsoData(dbHandler);
+    return new Promise((resolve, reject) => {
+      const transaction = dbHandler.transaction([SSO_KEYS_OBECT_STORE], 'readwrite');
+      const objectStore = transaction.objectStore(SSO_KEYS_OBECT_STORE);
+
+      const newSsoKit = Object.assign({}, ssoData.toDbSerializableObject(), {id: ssoKitId});
+      const putRequest = objectStore.put({pk_id: 1, sso_kit: newSsoKit});
+
+      putRequest.onsuccess = () => {
+        console.log("The SSO Kit identifier has been updated successfully");
+      };
+
+      transaction.oncomplete = () => {
+        //Apparently, according to an MDN documentation, the modification is not 100% guaranteed to be flushed on disk for Firefox
+        resolve();
+      };
+
+      transaction.onerror = event => {
+        console.error(`The IndexedDB transaction couldn't be opened to updated the SSO Kit`);
+        console.error(event);
+        reject();
+      };
+    });
+  }
+
+  /**
+   * Updates the id of the SSO kit.
+   *
+   * @param {IDBDatabase} dbHandler an opened IndexDB handler
+   * @param {string} provider the provider to set
+   * @returns {Promise<void>}
+   * @private
+   */
+  static async updateSsoDataWithProvider(dbHandler, provider) {
+    const ssoData = await this.getSsoData(dbHandler);
+    return new Promise((resolve, reject) => {
+      const transaction = dbHandler.transaction([SSO_KEYS_OBECT_STORE], 'readwrite');
+      const objectStore = transaction.objectStore(SSO_KEYS_OBECT_STORE);
+
+      const newSsoKit = Object.assign({}, ssoData.toDbSerializableObject(), {provider});
+      const putRequest = objectStore.put({pk_id: 1, sso_kit: newSsoKit});
+
+      putRequest.onsuccess = () => {
+        console.log("The SSO provider has been updated successfully");
+      };
+
+      transaction.oncomplete = () => {
+        //Apparently, according to an MDN documentation, the modification is not 100% guaranteed to be flushed on disk for Firefox
+        resolve();
+      };
+
+      transaction.onerror = event => {
+        console.error(`The IndexedDB transaction couldn't be opened to updated the SSO Kit`);
+        console.error(event);
+        reject();
+      };
+    });
+  }
+}
+
+export default SsoDataStorage;

package/src/all/background_page/service/invitation/postponeUserSettingInvitationService.js

@@ -0,0 +1,60 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+
+let isInvitationAccountRecoveryPostponed = false;
+let isInvitationMFAPolicyPostponed = false;
+
+class PostponeUserSettingInvitationService {
+  /**
+   * Returns true if the user has postponned the account recovery enrollment invitation.
+   *
+   * @returns {bool}
+   */
+  static hasPostponedAccountRecovery() {
+    return isInvitationAccountRecoveryPostponed;
+  }
+
+  /**
+   * Returns true if the user has postponned the mfa policy enrollment invitation.
+   *
+   * @returns {bool}
+   */
+  static hasPostponedMFAPolicy() {
+    return isInvitationMFAPolicyPostponed;
+  }
+
+  /**
+   * Set the account recovery enrollement invitation as postponed.
+   */
+  static postponeAccountRecovery() {
+    isInvitationAccountRecoveryPostponed = true;
+  }
+
+  /**
+   * Set the MFA policy enrollement invitation as postponed.
+   */
+  static postponeMFAPolicy() {
+    isInvitationMFAPolicyPostponed = true;
+  }
+
+  /**
+   * Set the enrollement invitation to its default value.
+   */
+  static reset() {
+    isInvitationAccountRecoveryPostponed = false;
+    isInvitationMFAPolicyPostponed = false;
+  }
+}
+
+export default PostponeUserSettingInvitationService;

package/src/all/background_page/service/invitation/postponeUserSettingInvitationService.test.js

@@ -0,0 +1,52 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.10.0
+ */
+
+import PostponeUserSettingInvitationService from './postponeUserSettingInvitationService';
+
+describe("PostponedUserSettingInvitation service", () => {
+  it("Retrieve the right information for account recovery", async() => {
+    expect.assertions(2);
+    //Check that the default value is false
+    expect(PostponeUserSettingInvitationService.hasPostponedAccountRecovery()).toBe(false);
+
+    PostponeUserSettingInvitationService.postponeAccountRecovery();
+    expect(PostponeUserSettingInvitationService.hasPostponedAccountRecovery()).toBe(true);
+  });
+
+  it("Retrieve the right information for mfa", async() => {
+    expect.assertions(2);
+    //Check that the default value is false
+    expect(PostponeUserSettingInvitationService.hasPostponedMFAPolicy()).toBe(false);
+
+    PostponeUserSettingInvitationService.postponeMFAPolicy();
+    expect(PostponeUserSettingInvitationService.hasPostponedMFAPolicy()).toBe(true);
+  });
+
+
+  it("Should listen the event passbolt.auth.after-logout and reset the postpone the right information", async() => {
+    expect.assertions(6);
+    PostponeUserSettingInvitationService.reset();
+    expect(PostponeUserSettingInvitationService.hasPostponedAccountRecovery()).toBe(false);
+    expect(PostponeUserSettingInvitationService.hasPostponedMFAPolicy()).toBe(false);
+
+    PostponeUserSettingInvitationService.postponeAccountRecovery();
+    PostponeUserSettingInvitationService.postponeMFAPolicy();
+    expect(PostponeUserSettingInvitationService.hasPostponedAccountRecovery()).toBe(true);
+    expect(PostponeUserSettingInvitationService.hasPostponedMFAPolicy()).toBe(true);
+
+    PostponeUserSettingInvitationService.reset();
+    expect(PostponeUserSettingInvitationService.hasPostponedAccountRecovery()).toBe(false);
+    expect(PostponeUserSettingInvitationService.hasPostponedMFAPolicy()).toBe(false);
+  });
+});

package/src/all/background_page/service/localStorage/localStorageService.js

@@ -0,0 +1,73 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+import ResourceLocalStorage from "../local_storage/resourceLocalStorage";
+import ResourceTypeLocalStorage from "../local_storage/resourceTypeLocalStorage";
+import FolderLocalStorage from "../local_storage/folderLocalStorage";
+import AuthStatusLocalStorage from "../local_storage/authStatusLocalStorage";
+import UserLocalStorage from "../local_storage/userLocalStorage";
+import GroupLocalStorage from "../local_storage/groupLocalStorage";
+import RolesLocalStorage from "../local_storage/rolesLocalStorage";
+import PasswordGeneratorLocalStorage
+  from "../local_storage/passwordGeneratorLocalStorage";
+import PostponeUserSettingInvitationService
+  from "../invitation/postponeUserSettingInvitationService";
+import PassphraseStorageService from "../session_storage/passphraseStorageService";
+import SsoKitTemporaryStorageService
+  from "../session_storage/ssoKitTemporaryStorageService";
+import GetLegacyAccountService from "../account/getLegacyAccountService";
+import RbacsLocalStorage from "../local_storage/rbacLocalStorage";
+import UserMeSessionStorageService from "../sessionStorage/userMeSessionStorageService";
+import User from "../../model/user";
+import PasswordPoliciesLocalStorage from "../local_storage/passwordPoliciesLocalStorage";
+import PasswordExpirySettingsLocalStorage from "../local_storage/passwordExpirySettingsLocalStorage";
+
+/**
+ * Flush storage data when:
+ * - the webextension starts.
+ * - the user is signed-out.
+ */
+class LocalStorageService {
+  /**
+   * Flush all storage
+   */
+  static async flush() {
+    ResourceLocalStorage.flush();
+    ResourceTypeLocalStorage.flush();
+    FolderLocalStorage.flush();
+    AuthStatusLocalStorage.flush();
+    UserLocalStorage.flush();
+    GroupLocalStorage.flush();
+    RolesLocalStorage.flush();
+    PasswordGeneratorLocalStorage.flush();
+    PostponeUserSettingInvitationService.reset();
+    PassphraseStorageService.flush();
+    SsoKitTemporaryStorageService.flush();
+    LocalStorageService.flushAccountBasedStorages();
+  }
+
+  static async flushAccountBasedStorages() {
+    // If no user is yet configured no need to continue.
+    if (!User.getInstance().isValid()) {
+      return;
+    }
+
+    const account = await GetLegacyAccountService.get();
+    (new RbacsLocalStorage(account)).flush();
+    (new PasswordPoliciesLocalStorage(account)).flush();
+    (new PasswordExpirySettingsLocalStorage(account)).flush();
+    UserMeSessionStorageService.remove(account);
+  }
+}
+
+export default LocalStorageService;

package/src/all/background_page/service/localStorage/localStorageService.test.js

@@ -0,0 +1,102 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+
+import LocalStorageService from "./localStorageService";
+import GetLegacyAccountService from "../account/getLegacyAccountService";
+import UserMeSessionStorageService from "../sessionStorage/userMeSessionStorageService";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {RBACS_LOCAL_STORAGE_KEY} from "../local_storage/rbacLocalStorage";
+import MockExtension from "../../../../../test/mocks/mockExtension";
+import PostponeUserSettingInvitationService from "../invitation/postponeUserSettingInvitationService";
+import {PASSWORD_POLICIES_LOCAL_STORAGE_KEY} from "../local_storage/passwordPoliciesLocalStorage";
+import {PASSWORD_EXPIRY_SETTINGS_LOCAL_STORAGE_KEY} from "../local_storage/passwordExpirySettingsLocalStorage";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("LocalStorageService", () => {
+  describe("LocalStorageService::flush", () => {
+    it("Should flush all storage (with no account set)", async() => {
+      expect.assertions(18);
+      // spy on
+      jest.spyOn(browser.storage.local, "remove");
+      jest.spyOn(browser.storage.session, "remove");
+      jest.spyOn(browser.alarms, "clear");
+      jest.spyOn(GetLegacyAccountService, "get");
+      jest.spyOn(UserMeSessionStorageService, "remove");
+      jest.spyOn(PostponeUserSettingInvitationService, "reset");
+      // process
+      await LocalStorageService.flush();
+      // expectations
+      expect(browser.storage.local.remove).toHaveBeenCalledTimes(8);
+      expect(browser.storage.session.remove).toHaveBeenCalledTimes(2);
+      expect(browser.alarms.clear).toHaveBeenCalledTimes(2);
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("resources");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("resourceTypes");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("folders");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("auth_status");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("users");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("groups");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("roles");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("passwordGenerator");
+      expect(PostponeUserSettingInvitationService.reset).toHaveBeenCalled();
+      expect(browser.storage.session.remove).toHaveBeenCalledWith("passphrase");
+      expect(browser.alarms.clear).toHaveBeenCalledWith("PassphraseStorageFlush");
+      expect(browser.alarms.clear).toHaveBeenCalledWith("SessionKeepAlive");
+      expect(browser.storage.session.remove).toHaveBeenCalledWith("temp_server_part_sso_kit");
+      expect(GetLegacyAccountService.get).not.toHaveBeenCalled();
+      expect(UserMeSessionStorageService.remove).not.toHaveBeenCalled();
+    });
+
+    it("Should flush all storage (with an account set)", async() => {
+      expect.assertions(21);
+      // mock data
+      MockExtension.withConfiguredAccount();
+      const account = new AccountEntity(defaultAccountDto());
+      // spy on
+      jest.spyOn(browser.storage.local, "remove");
+      jest.spyOn(browser.storage.session, "remove");
+      jest.spyOn(browser.alarms, "clear");
+      jest.spyOn(PostponeUserSettingInvitationService, "reset");
+      jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
+      jest.spyOn(UserMeSessionStorageService, "remove");
+      // process
+      await LocalStorageService.flush();
+      // expectations
+      expect(browser.storage.local.remove).toHaveBeenCalledTimes(11);
+      expect(browser.storage.session.remove).toHaveBeenCalledTimes(3);
+      expect(browser.alarms.clear).toHaveBeenCalledTimes(2);
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("resources");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("resourceTypes");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("folders");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("auth_status");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("users");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("groups");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("roles");
+      expect(browser.storage.local.remove).toHaveBeenCalledWith("passwordGenerator");
+      expect(PostponeUserSettingInvitationService.reset).toHaveBeenCalled();
+      expect(browser.storage.session.remove).toHaveBeenCalledWith("passphrase");
+      expect(browser.alarms.clear).toHaveBeenCalledWith("PassphraseStorageFlush");
+      expect(browser.alarms.clear).toHaveBeenCalledWith("SessionKeepAlive");
+      expect(browser.storage.session.remove).toHaveBeenCalledWith("temp_server_part_sso_kit");
+      expect(GetLegacyAccountService.get).toHaveBeenCalled();
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(`${RBACS_LOCAL_STORAGE_KEY}-${account.id}`);
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(`${PASSWORD_POLICIES_LOCAL_STORAGE_KEY}-${account.id}`);
+      expect(browser.storage.local.remove).toHaveBeenCalledWith(`${PASSWORD_EXPIRY_SETTINGS_LOCAL_STORAGE_KEY}-${account.id}`);
+      expect(UserMeSessionStorageService.remove).toHaveBeenCalledWith(account);
+    });
+  });
+});