passbolt-browser-extension 5.13.0 → 5.14.2

package/src/all/background_page/service/local_storage/resourceTypeLocalStorage.js

@@ -11,59 +11,26 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         3.0.0
  */
-import Log from "../../model/log";
 import ResourceTypesCollection from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypesCollection";
-import { assertType } from "../../utils/assertions";
+import AbstractLocalStorage from "./abstractLocalStorage";
 
-const RESOURCE_TYPES_LOCAL_STORAGE_KEY = "resourceTypes";
+export const RESOURCE_TYPES_LOCAL_STORAGE_KEY = "resource_types";
 
-class ResourceTypeLocalStorage {
+class ResourceTypeLocalStorage extends AbstractLocalStorage {
   /**
-   * Get the storage key.
-   * @private
+   * Get the key property
+   * @return {string}
    */
-  static get storageKey() {
+  get key() {
     return RESOURCE_TYPES_LOCAL_STORAGE_KEY;
   }
 
   /**
-   * Flush the resourceTypes local storage
-   *
-   * @throws {Error} if operation failed
-   * @return {Promise<void>}
+   * Get the entityClass
+   * @return {ResourceTypesCollection}
    */
-  static async flush() {
-    Log.write({ level: "debug", message: "ResourceTypeLocalStorage flushed" });
-    return await browser.storage.local.remove(this.storageKey);
-  }
-
-  /**
-   * Set the resourceTypes local storage.
-   *
-   * @throws {Error} if operation failed
-   * @return {Promise<ResourceTypesCollectionDto>} results object, containing every object in keys that was found in the storage area.
-   * If storage is not set, undefined will be returned.
-   */
-  static async get() {
-    const { resourceTypes } = await browser.storage.local.get([this.storageKey]);
-    return resourceTypes;
-  }
-
-  /**
-   * Set the resourceTypes in local storage.
-   * @param {ResourceTypesCollection} resourceTypesCollection The folders to insert in the local storage.
-   * @return {Promise<void>}
-   * @throws {TypeError} if the given argument is not a ResourceTypesCollection
-   */
-  static async set(resourceTypesCollection) {
-    assertType(
-      resourceTypesCollection,
-      ResourceTypesCollection,
-      "ResourceTypeLocalStorage::set expects a ResourceTypesCollection",
-    );
-    await navigator.locks.request(this.storageKey, async () => {
-      await browser.storage.local.set({ [this.storageKey]: resourceTypesCollection.toDto() });
-    });
+  get entityClass() {
+    return ResourceTypesCollection;
   }
 }
 

package/src/all/background_page/service/local_storage/resourceTypeLocalStorage.test.js

@@ -0,0 +1,68 @@
+/**
+ * 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.1.0
+ */
+import ResourceTypeLocalStorage from "./resourceTypeLocalStorage";
+import { resourceTypeV5DefaultDto } from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypeEntity.test.data";
+import ResourceTypeEntity from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypeEntity";
+import ResourceTypesCollection from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypesCollection";
+import GetLegacyAccountService from "../account/getLegacyAccountService";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
+
+describe("ResourceTypeLocalStorage", () => {
+  // mock data
+  const account = new AccountEntity(defaultAccountDto());
+  // spy on
+  jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
+
+  describe("ResourceTypeLocalStorage::get", () => {
+    it("Should return undefined if nothing stored in the storage", async () => {
+      expect.assertions(1);
+      const resourceTypeLocalstorage = new ResourceTypeLocalStorage(account);
+      const result = await resourceTypeLocalstorage.getData();
+      expect(result).toEqual(undefined);
+    });
+
+    it("Should return content stored in the local storage", async () => {
+      const resourceTypes = [resourceTypeV5DefaultDto()];
+      expect.assertions(1);
+      const resourceTypeLocalstorage = new ResourceTypeLocalStorage(account);
+      browser.storage.local.set({ [resourceTypeLocalstorage.storageDataKey]: resourceTypes });
+      const result = await resourceTypeLocalstorage.getData();
+      expect(result).toEqual(resourceTypes);
+    });
+  });
+
+  describe("ResourceTypeLocalStorage::setData", () => {
+    it("Should setData a resourceType colection in the local storage", async () => {
+      expect.assertions(2);
+      const resourceTypeLocalstorage = new ResourceTypeLocalStorage(account);
+      const resourceType = new ResourceTypeEntity(resourceTypeV5DefaultDto());
+      const resourceTypesCollection = new ResourceTypesCollection([resourceType]);
+      await resourceTypeLocalstorage.setData(resourceTypesCollection);
+      const resourceTypes = await resourceTypeLocalstorage.getData();
+      expect(resourceTypes).toHaveLength(1);
+      expect(resourceTypes[0]).toEqual(resourceType.toDto(ResourceTypeEntity.ALL_CONTAIN_OPTIONS));
+    });
+  });
+
+  describe("ResourceTypeLocalStorage::flush", () => {
+    it("Should flush all the resourceType from the local storage", async () => {
+      expect.assertions(1);
+      const resourceTypeLocalstorage = new ResourceTypeLocalStorage(account);
+      await resourceTypeLocalstorage.flush();
+      const resourceTypes = await resourceTypeLocalstorage.getData();
+      expect(resourceTypes).toEqual(undefined);
+    });
+  });
+});

package/src/all/background_page/service/local_storage/siteSettingsLocalStorage.js

@@ -0,0 +1,104 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 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) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         6.0.0
+ */
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import AbstractAccountEntity from "../../model/entity/account/abstractAccountEntity";
+
+export const SITE_SETTINGS = "site-settings";
+
+/**
+ * Per-account local storage for site settings, backed by `browser.storage.local`
+ * under the key `site-settings-{accountId}`, with an in-memory runtime cache.
+ */
+class SiteSettingsLocalStorage {
+  /**
+   * Runtime cached data.
+   * @key {string} account id
+   * @value {object} site settings dto
+   * @private
+   */
+  static _runtimeCachedData = {};
+
+  /**
+   * @param {AccountEntity} account The user account.
+   */
+  constructor(account) {
+    if (!account || !(account instanceof AbstractAccountEntity)) {
+      throw new TypeError("Parameter `account` should be of type AbstractAccountEntity.");
+    }
+    this.account = account;
+    this.storageKey = this.getStorageKey(account);
+  }
+
+  /**
+   * Build the storage key for the given account.
+   * @param {AccountEntity} account
+   * @returns {string}
+   */
+  getStorageKey(account) {
+    return `${SITE_SETTINGS}-${account.id}`;
+  }
+
+  /**
+   * Flush site settings from the local storage and runtime cache.
+   * @returns {Promise<void>}
+   */
+  async flush() {
+    await browser.storage.local.remove(this.storageKey);
+    delete SiteSettingsLocalStorage._runtimeCachedData[this.account.id];
+    console.debug(`Site settings flushed for (${this.account.id})`);
+  }
+
+  /**
+   * Get the site settings dto from local storage (or in-memory cache).
+   * @returns {Promise<object|undefined>}
+   */
+  async get() {
+    if (!SiteSettingsLocalStorage._runtimeCachedData[this.account.id]) {
+      const data = await browser.storage.local.get([this.storageKey]);
+      if (!data[this.storageKey]) {
+        return;
+      }
+      SiteSettingsLocalStorage._runtimeCachedData[this.account.id] = data[this.storageKey];
+    }
+    return SiteSettingsLocalStorage._runtimeCachedData[this.account.id];
+  }
+
+  /**
+   * Set the site settings in local storage.
+   * @param {SiteSettingsEntity} settings
+   * @returns {Promise<void>}
+   * @throws {TypeError} If parameter settings is not of type SiteSettingsEntity.
+   */
+  async set(settings) {
+    if (!settings || !(settings instanceof SiteSettingsEntity)) {
+      throw new TypeError("Parameter `settings` should be of type SiteSettingsEntity.");
+    }
+    await navigator.locks.request(this.storageKey, async () => {
+      const settingsDto = settings.toDto();
+      await this._setBrowserStorage({ [this.storageKey]: settingsDto });
+      SiteSettingsLocalStorage._runtimeCachedData[this.account.id] = settingsDto;
+    });
+  }
+
+  /**
+   * @param {object} data
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _setBrowserStorage(data) {
+    await browser.storage.local.set(data);
+  }
+}
+
+export default SiteSettingsLocalStorage;

package/src/all/background_page/service/local_storage/siteSettingsLocalStorage.test.js

@@ -0,0 +1,114 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 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) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         6.0.0
+ */
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
+import { defaultProSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import SiteSettingsLocalStorage, { SITE_SETTINGS } from "./siteSettingsLocalStorage";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("SiteSettingsLocalStorage", () => {
+  let account, storage;
+
+  beforeEach(async () => {
+    account = new AccountEntity(defaultAccountDto());
+    storage = new SiteSettingsLocalStorage(account);
+    await storage.flush();
+  });
+
+  describe("::constructor", () => {
+    it("derives a per-account storage key", () => {
+      expect.assertions(1);
+      expect(storage.storageKey).toBe(`${SITE_SETTINGS}-${account.id}`);
+    });
+
+    it("throws when account is missing", () => {
+      expect.assertions(1);
+      expect(() => new SiteSettingsLocalStorage(null)).toThrow(TypeError);
+    });
+
+    it("throws when account is not an AccountEntity", () => {
+      expect.assertions(1);
+      expect(() => new SiteSettingsLocalStorage({ id: "abc" })).toThrow(TypeError);
+    });
+  });
+
+  describe("::get", () => {
+    it("returns undefined when nothing is stored", async () => {
+      expect.assertions(1);
+      const result = await storage.get();
+      expect(result).toBeUndefined();
+    });
+
+    it("returns content stored in the local storage", async () => {
+      expect.assertions(1);
+      const dto = defaultProSiteSettings();
+      await browser.storage.local.set({ [storage.storageKey]: dto });
+      const result = await storage.get();
+      expect(result).toEqual(dto);
+    });
+
+    it("populates the runtime cache on the first read", async () => {
+      expect.assertions(2);
+      const dto = defaultProSiteSettings();
+      await browser.storage.local.set({ [storage.storageKey]: dto });
+      expect(SiteSettingsLocalStorage._runtimeCachedData[account.id]).toBeUndefined();
+      await storage.get();
+      expect(SiteSettingsLocalStorage._runtimeCachedData[account.id]).toEqual(dto);
+    });
+
+    it("subsequent reads come from the runtime cache and skip browser.storage", async () => {
+      expect.assertions(2);
+      const dto = defaultProSiteSettings();
+      await browser.storage.local.set({ [storage.storageKey]: dto });
+      await storage.get();
+      const spy = jest.spyOn(browser.storage.local, "get");
+      const result = await storage.get();
+      expect(spy).not.toHaveBeenCalled();
+      expect(result).toEqual(dto);
+    });
+  });
+
+  describe("::set", () => {
+    it("writes the entity dto to local storage and runtime cache", async () => {
+      expect.assertions(3);
+      const entity = new SiteSettingsEntity(defaultProSiteSettings());
+      await storage.set(entity);
+      expect(browser.storage.local.store[storage.storageKey]).toEqual(entity.toDto());
+      expect(SiteSettingsLocalStorage._runtimeCachedData[account.id]).toEqual(entity.toDto());
+      const result = await storage.get();
+      expect(result).toEqual(entity.toDto());
+    });
+
+    it("throws when settings is not a SiteSettingsEntity", async () => {
+      expect.assertions(2);
+      await expect(storage.set(null)).rejects.toThrow(TypeError);
+      await expect(storage.set({ status: "enabled" })).rejects.toThrow(TypeError);
+    });
+  });
+
+  describe("::flush", () => {
+    it("clears both browser.storage and the runtime cache", async () => {
+      expect.assertions(2);
+      const entity = new SiteSettingsEntity(defaultProSiteSettings());
+      await storage.set(entity);
+      await storage.flush();
+      expect(browser.storage.local.store[storage.storageKey]).toBeUndefined();
+      expect(SiteSettingsLocalStorage._runtimeCachedData[account.id]).toBeUndefined();
+    });
+  });
+});

package/src/all/background_page/service/local_storage/userMeLocalStorage.js

@@ -0,0 +1,50 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 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) 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.1.0
+ */
+
+import UserEntity from "../../model/entity/user/userEntity";
+import AbstractLocalStorage from "./abstractLocalStorage";
+
+export const USER_ME_STORAGE_KEY_PREFIX = "user-me";
+
+/**
+ * A cache service used to store the result of the requests made on the users me entry point.
+ */
+class UserMeLocalStorage extends AbstractLocalStorage {
+  /**
+   * Get the key property
+   * @return {string}
+   */
+  get key() {
+    return USER_ME_STORAGE_KEY_PREFIX;
+  }
+
+  /**
+   * Get the en
+   * @return {BextUserEntity}
+   */
+  get entityClass() {
+    return UserEntity;
+  }
+
+  /**
+   * Get the contain options
+   * @return {{profile: function(): {avatar: boolean}, role: boolean, gpgkey: boolean, groups_users: boolean, account_recovery_user_setting: boolean, pending_account_recovery_request: boolean}}
+   * @constructor
+   */
+  static get DEFAULT_CONTAIN() {
+    return UserEntity.ALL_CONTAIN_OPTIONS;
+  }
+}
+
+export default UserMeLocalStorage;

package/src/all/background_page/service/{sessionStorage/userMeSessionStorageService.test.js → local_storage/userMeLocalStorage.test.js}

@@ -12,38 +12,42 @@
  * @since         4.1.0
  */
 
-import UserMeSessionStorageService from "./userMeSessionStorageService";
+import UserMeLocalStorage from "./userMeLocalStorage";
 import AccountEntity from "../../model/entity/account/accountEntity";
 import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
 import { defaultUserDto } from "passbolt-styleguide/src/shared/models/entity/user/userEntity.test.data";
 import UserEntity from "../../model/entity/user/userEntity";
 import ProfileEntity from "passbolt-styleguide/src/shared/models/entity/profile/profileEntity";
 import { v4 as uuidv4 } from "uuid";
+import browser from "../../../common/polyfill/browserPolyfill";
 
-describe("UserMeSessionStorageService", () => {
+describe("UserMeLocalStorage", () => {
   beforeEach(async () => {
-    await browser.storage.session.clear();
+    await browser.storage.local.clear();
   });
 
-  describe("UserMeSessionStorageService::get", () => {
+  describe("UserMeLocalStorage::get", () => {
     it("should return null if there is no data in the storage", async () => {
       expect.assertions(1);
       const account = new AccountEntity(defaultAccountDto());
-      const cachedUser = await UserMeSessionStorageService.get(account);
-      expect(cachedUser).toBeNull();
+      const userMeLocalStorage = new UserMeLocalStorage(account);
+      const cachedUser = await userMeLocalStorage.getData();
+      expect(cachedUser).toBeUndefined();
     });
 
     it("should return the user in cache associated to the passed account if one in cache", async () => {
       expect.assertions(4);
       const account = new AccountEntity(defaultAccountDto());
       const user = new UserEntity(defaultUserDto());
-      await UserMeSessionStorageService.set(account, user);
+      const userMeLocalStorage = new UserMeLocalStorage(account);
+      await userMeLocalStorage.setData(user);
 
-      const cachedUser = await UserMeSessionStorageService.get(account);
+      const cachedUser = new UserEntity(await userMeLocalStorage.getData());
       expect(cachedUser).not.toBeNull();
       expect(cachedUser).toBeInstanceOf(UserEntity);
       expect(cachedUser.id).toEqual(user.id);
       expect(cachedUser.profile).toBeInstanceOf(ProfileEntity);
+      await userMeLocalStorage.flush();
     });
 
     it("should return null if trying to access the cache of another account", async () => {
@@ -55,64 +59,74 @@ describe("UserMeSessionStorageService", () => {
           user_id: uuidv4(),
         }),
       );
+
+      const userMeLocalStorage = new UserMeLocalStorage(account);
+      const userMeLocalStorageOtherAccount = new UserMeLocalStorage(otherAccount);
       const user = new UserEntity(defaultUserDto());
-      await UserMeSessionStorageService.set(account, user);
+      await userMeLocalStorage.setData(user);
 
-      const cachedUserOtherAccount = await UserMeSessionStorageService.get(otherAccount);
-      expect(cachedUserOtherAccount).toBeNull();
+      const cachedUserOtherAccount = await userMeLocalStorageOtherAccount.getData();
+      expect(cachedUserOtherAccount).toBeUndefined();
     });
 
     it("should return the cached user for the given account even if there are other cached users for other accounts", async () => {
       expect.assertions(2);
       const otherAccount = new AccountEntity(defaultAccountDto());
       const userOtherAccount = new UserEntity(defaultUserDto());
-      await UserMeSessionStorageService.set(otherAccount, userOtherAccount);
+      const userMeLocalStorageOtherAccount = new UserMeLocalStorage(otherAccount);
+      await userMeLocalStorageOtherAccount.setData(userOtherAccount);
 
       const account = new AccountEntity(defaultAccountDto());
       const user = new UserEntity(defaultUserDto());
-      await UserMeSessionStorageService.set(account, user);
+      const userMeLocalStorage = new UserMeLocalStorage(account);
+      await userMeLocalStorage.setData(user);
 
-      const cachedUser = await UserMeSessionStorageService.get(account);
+      const cachedUser = await userMeLocalStorage.getData();
       expect(cachedUser).not.toBeNull();
       expect(cachedUser.id).toEqual(user.id);
     });
   });
 
-  describe("UserMeSessionStorageService::set", () => {
+  describe("UserMeLocalStorage::set", () => {
     it("should override an existing cached user if one already present", async () => {
       expect.assertions(3);
 
       const account = new AccountEntity(defaultAccountDto());
       const user = new UserEntity(defaultUserDto());
-      await UserMeSessionStorageService.set(account, user);
-      await UserMeSessionStorageService.set(account, user);
+      const userMeLocalStorage = new UserMeLocalStorage(account);
+      await userMeLocalStorage.setData(user);
+      await userMeLocalStorage.setData(user);
 
-      expect(Object.keys(await browser.storage.session.get()).length).toEqual(1);
-      const cachedUser = await UserMeSessionStorageService.get(account);
+      // One for data and another one for metadata
+      expect(Object.keys(await browser.storage.local.get()).length).toEqual(2);
+      const cachedUser = await userMeLocalStorage.getData();
       expect(cachedUser).not.toBeNull();
       expect(cachedUser.id).toEqual(user.id);
     });
   });
 
-  describe("UserMeSessionStorageService::remove", () => {
-    it("should not crash if nothing to remove", async () => {
+  describe("UserMeLocalStorage::flush", () => {
+    it("should not crash if nothing to flush", async () => {
       expect.assertions(1);
 
       const account = new AccountEntity(defaultAccountDto());
-      await UserMeSessionStorageService.remove(account);
-      expect(true).toBeTruthy();
+      const userMeLocalStorage = new UserMeLocalStorage(account);
+      await userMeLocalStorage.flush();
+      const cachedUser = await userMeLocalStorage.getData();
+      expect(cachedUser).toBeUndefined();
     });
 
-    it("should remove a cached user", async () => {
+    it("should flush a cached user", async () => {
       expect.assertions(1);
 
       const account = new AccountEntity(defaultAccountDto());
       const user = new UserEntity(defaultUserDto());
-      await UserMeSessionStorageService.set(account, user);
+      const userMeLocalStorage = new UserMeLocalStorage(account);
+      await userMeLocalStorage.setData(user);
 
-      await UserMeSessionStorageService.remove(account);
+      await userMeLocalStorage.flush();
 
-      expect(Object.keys(await browser.storage.session.get()).length).toEqual(0);
+      expect(Object.keys(await browser.storage.local.get()).length).toEqual(0);
     });
 
     it("should not remove another cached user if there is none for the given account", async () => {
@@ -124,13 +138,15 @@ describe("UserMeSessionStorageService", () => {
         }),
       );
       const userOtherAccount = new UserEntity(defaultUserDto());
-      await UserMeSessionStorageService.set(otherAccount, userOtherAccount);
+      const userMeLocalStorageOtherAccount = new UserMeLocalStorage(otherAccount);
+      await userMeLocalStorageOtherAccount.setData(userOtherAccount);
 
       const account = new AccountEntity(defaultAccountDto());
+      const userMeLocalStorage = new UserMeLocalStorage(account);
+      await userMeLocalStorage.flush();
 
-      await UserMeSessionStorageService.remove(account);
-
-      expect(Object.keys(await browser.storage.session.get()).length).toEqual(1);
+      // One for data and another one for metadata
+      expect(Object.keys(await browser.storage.local.get()).length).toEqual(2);
     });
 
     it("should not remove another cached user if there is a cached user for the given account", async () => {
@@ -142,16 +158,19 @@ describe("UserMeSessionStorageService", () => {
         }),
       );
       const userOtherAccount = new UserEntity(defaultUserDto());
-      await UserMeSessionStorageService.set(otherAccount, userOtherAccount);
+      const userMeLocalStorageOtherAccount = new UserMeLocalStorage(otherAccount);
+      await userMeLocalStorageOtherAccount.setData(userOtherAccount);
 
       const account = new AccountEntity(defaultAccountDto());
       const user = new UserEntity(defaultUserDto());
-      await UserMeSessionStorageService.set(account, user);
+      const userMeLocalStorage = new UserMeLocalStorage(account);
+      await userMeLocalStorage.setData(user);
 
-      await UserMeSessionStorageService.remove(account);
+      await userMeLocalStorage.flush();
 
-      expect(Object.keys(await browser.storage.session.get()).length).toEqual(1);
-      const cachedUserOtherAccount = await UserMeSessionStorageService.get(otherAccount);
+      // One for data and another one for metadata
+      expect(Object.keys(await browser.storage.local.get()).length).toEqual(2);
+      const cachedUserOtherAccount = await userMeLocalStorageOtherAccount.getData();
       expect(cachedUserOtherAccount).not.toBeNull();
       expect(cachedUserOtherAccount.id).toEqual(userOtherAccount.id);
     });

package/src/all/background_page/service/metadata/encryptMetadataService.js

@@ -25,13 +25,13 @@ import FolderEntity from "../../model/entity/folder/folderEntity";
 import GetOrFindMetadataSettingsService from "./getOrFindMetadataSettingsService";
 import FoldersCollection from "../../model/entity/folder/foldersCollection";
 import ResourcesCollection from "../../model/entity/resource/resourcesCollection";
-import ResourceTypeModel from "../../model/resourceType/resourceTypeModel";
 import { RESOURCE_TYPE_VERSION_5 } from "passbolt-styleguide/src/shared/models/entity/metadata/metadataTypesSettingsEntity";
 import Keyring from "../../model/keyring";
 import ExternalGpgKeyEntity from "passbolt-styleguide/src/shared/models/entity/gpgkey/externalGpgKeyEntity";
 import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
 import CollectionValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/collectionValidationError";
 import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
+import GetOrFindResourceTypesService from "../resourceType/getOrFindResourceTypesService";
 
 class EncryptMetadataService {
   /**
@@ -42,7 +42,7 @@ class EncryptMetadataService {
   constructor(apiClientOptions, account) {
     this.getOrFindMetadataSettingsService = new GetOrFindMetadataSettingsService(account, apiClientOptions);
     this.getOrFindMetadataKeysService = new GetOrFindMetadataKeysService(account, apiClientOptions);
-    this.resourceTypesModel = new ResourceTypeModel(apiClientOptions);
+    this.getOrFindResourceTypesService = new GetOrFindResourceTypesService(account, apiClientOptions);
     this.account = account;
     this.keyring = new Keyring();
     this._usersPublicGpgKeys = {};
@@ -123,7 +123,7 @@ class EncryptMetadataService {
       throw new Error("Unable to encrypt the collection metadata, a resource metadata is already encrypted.");
     }
 
-    const resourceTypesV5Collection = await this.resourceTypesModel.getOrFindAll();
+    const resourceTypesV5Collection = await this.getOrFindResourceTypesService.getOrFindAll();
     resourceTypesV5Collection.filterByResourceTypeVersion(RESOURCE_TYPE_VERSION_5);
     // No need to encrypt metadata of resource type v4.
     if (