passbolt-browser-extension 5.13.0 → 5.14.2

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

@@ -0,0 +1,271 @@
+/**
+ * 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 AccountEntity from "../../model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
+import { TestEntityLocalStorage, TestLocalStorage } from "./abstractLocalStorage.test.data";
+import { v4 as uuidv4 } from "uuid";
+import LocalStorageMetadataEntity from "../../model/entity/localStorage/localStorageMetadataEntity";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("AbstractLocalStorage", () => {
+  let account, storage;
+  beforeEach(() => {
+    account = new AccountEntity(defaultAccountDto());
+    storage = new TestLocalStorage(account);
+    // flush account related storage before each.
+    storage.flush();
+  });
+
+  describe("::constructor", () => {
+    it("throws an error if no account is provided.", () => {
+      expect.assertions(1);
+      expect(() => new TestLocalStorage()).toThrow(TypeError);
+    });
+
+    it("throws an error if parameter account is not a valid AccountEntity.", () => {
+      expect.assertions(1);
+      expect(() => new TestLocalStorage({})).toThrow(TypeError);
+    });
+  });
+
+  describe("::getMetadata", () => {
+    it("returns undefined if nothing is stored in the local storage.", async () => {
+      expect.assertions(1);
+      const result = await storage.getMetadata();
+      expect(result).toBeUndefined();
+    });
+
+    it("returns content stored in the local storage.", async () => {
+      const dto = {
+        last_updated: new Date().toISOString(),
+      };
+      expect.assertions(1);
+      browser.storage.local.set({ [storage.storageMetadataKey]: dto });
+      const result = await storage.getMetadata();
+      expect(result).toEqual(dto);
+    });
+
+    it("returns content stored in the runtime cache.", async () => {
+      const dto = {
+        last_updated: new Date().toISOString(),
+      };
+      expect.assertions(2);
+      // Force the runtime cache, to ensure it is hit even if the local storage is empty.
+      TestLocalStorage._runtimeCachedMetadata[storage.storageMetadataKey] = dto;
+      const result = await storage.getMetadata();
+      expect(result).toEqual(dto);
+      // Control the local storage was well empty.
+      expect(browser.storage.local.store[storage.storageMetadataKey]).toBeUndefined();
+    });
+  });
+
+  describe("::getData", () => {
+    it("returns undefined if nothing is stored in the local storage.", async () => {
+      expect.assertions(1);
+      const result = await storage.getData();
+      expect(result).toBeUndefined();
+    });
+
+    it("returns content stored in the local storage.", async () => {
+      const dto = {
+        id: uuidv4(),
+        name: "test",
+      };
+      expect.assertions(1);
+      browser.storage.local.set({ [storage.storageDataKey]: dto });
+      const result = await storage.getData();
+      expect(result).toEqual(dto);
+    });
+
+    it("returns content stored in the runtime cache.", async () => {
+      const dto = {
+        id: uuidv4(),
+        name: "test",
+      };
+      expect.assertions(2);
+      // Force the runtime cache, to ensure it is hit even if the local storage is empty.
+      TestLocalStorage._runtimeCachedData[storage.storageDataKey] = dto;
+      const result = await storage.getData();
+      expect(result).toEqual(dto);
+      // Control the local storage was well empty.
+      expect(browser.storage.local.store[storage.storageDataKey]).toBeUndefined();
+    });
+  });
+
+  describe("::setMetadata", () => {
+    it("stores content in the local storage.", async () => {
+      expect.assertions(3);
+      const dto = {
+        last_updated: new Date().toISOString(),
+      };
+      const entity = new LocalStorageMetadataEntity(dto);
+      await storage.setMetadata(entity);
+      // Expect the local storage (mocked here) to be set.
+      expect(browser.storage.local.store[storage.storageMetadataKey]).toEqual(dto);
+      // Expect the runtime cache to be set.
+      expect(TestLocalStorage._runtimeCachedMetadata[storage.storageMetadataKey]).toEqual(dto);
+      // Expect the get to retrieve the set metadata.
+      const resultGetMetadata = await storage.getMetadata();
+      expect(resultGetMetadata).toEqual(dto);
+    });
+
+    it("throws if no metadata is given to store.", async () => {
+      expect.assertions(3);
+      await expect(() => storage.setMetadata()).rejects.toThrow(TypeError);
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageMetadataKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(TestLocalStorage._runtimeCachedMetadata[storage.storageMetadataKey]).toBeUndefined();
+    });
+
+    it("throws if invalid metadata is given to store.", async () => {
+      expect.assertions(3);
+      await expect(() => storage.setMetadata({})).rejects.toThrow(TypeError);
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageMetadataKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(TestLocalStorage._runtimeCachedMetadata[storage.storageMetadataKey]).toBeUndefined();
+    });
+
+    it("waits any on-going call to set to perform another set.", async () => {
+      expect.assertions(3);
+      const promisesResolvers = [];
+
+      jest.spyOn(storage, "_setBrowserStorage").mockImplementation(() => {
+        let resolve;
+        const promise = new Promise((_resolve) => (resolve = _resolve));
+        promisesResolvers.push(resolve);
+        return promise;
+      });
+
+      const dto1 = {
+        last_updated: new Date().toISOString(),
+      };
+      const resultPromise1 = storage.setMetadata(new LocalStorageMetadataEntity(dto1));
+      const dto2 = {
+        last_updated: "2026-05-04T20:31:45+00:00",
+      };
+      const resultPromise2 = storage.setMetadata(new LocalStorageMetadataEntity(dto2));
+      expect(storage._setBrowserStorage).toHaveBeenCalledWith({ [storage.storageMetadataKey]: dto1 });
+      expect(storage._setBrowserStorage).not.toHaveBeenCalledWith({ [storage.storageMetadataKey]: dto2 });
+      promisesResolvers[0]();
+      await resultPromise1;
+      expect(storage._setBrowserStorage).toHaveBeenCalledWith({ [storage.storageMetadataKey]: dto2 });
+      promisesResolvers[1]();
+      await resultPromise2;
+    });
+  });
+
+  describe("::setData", () => {
+    it("stores content in the local storage.", async () => {
+      expect.assertions(4);
+      const dto = {
+        id: uuidv4(),
+        name: "test",
+      };
+      const entity = new TestEntityLocalStorage(dto);
+      await storage.setData(entity);
+      // Expect the local storage (mocked here) to be set.
+      expect(browser.storage.local.store[storage.storageDataKey]).toEqual(dto);
+      // Expect the runtime cache to be set.
+      expect(TestLocalStorage._runtimeCachedData[storage.storageDataKey]).toEqual(dto);
+      // Expect the get to retrieve the set data.
+      const resultGet = await storage.getData();
+      const resultGetMetadata = await storage.getMetadata();
+      expect(resultGet).toEqual(dto);
+      expect(resultGetMetadata.last_updated.slice(0, 10)).toEqual(new Date().toISOString().slice(0, 10));
+    });
+
+    it("throws if no data is given to store.", async () => {
+      expect.assertions(3);
+      await expect(() => storage.setData()).rejects.toThrow(TypeError);
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageDataKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(TestLocalStorage._runtimeCachedData[storage.storageDataKey]).toBeUndefined();
+    });
+
+    it("throws if invalid data is given to store.", async () => {
+      expect.assertions(3);
+      await expect(() => storage.setData({})).rejects.toThrow(TypeError);
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageDataKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(TestLocalStorage._runtimeCachedData[storage.storageDataKey]).toBeUndefined();
+    });
+
+    it("waits any on-going call to set to perform another set.", async () => {
+      expect.assertions(3);
+      const promisesResolvers = [];
+
+      jest.spyOn(storage, "_setBrowserStorage").mockImplementation(() => {
+        let resolve;
+        const promise = new Promise((_resolve) => (resolve = _resolve));
+        promisesResolvers.push(resolve);
+        return promise;
+      });
+      jest.spyOn(storage, "setMetadata").mockImplementation(() => {});
+
+      const dto1 = {
+        id: uuidv4(),
+        name: "test",
+      };
+      const resultPromise1 = storage.setData(new TestEntityLocalStorage(dto1));
+      const dto2 = {
+        id: uuidv4(),
+        name: "test2",
+      };
+      const resultPromise2 = storage.setData(new TestEntityLocalStorage(dto2));
+      expect(storage._setBrowserStorage).toHaveBeenCalledWith({ [storage.storageDataKey]: dto1 });
+      expect(storage._setBrowserStorage).not.toHaveBeenCalledWith({ [storage.storageDataKey]: dto2 });
+      promisesResolvers[0]();
+      await resultPromise1;
+      expect(storage._setBrowserStorage).toHaveBeenCalledWith({ [storage.storageDataKey]: dto2 });
+      promisesResolvers[1]();
+      await resultPromise2;
+    });
+  });
+
+  describe("::flush", () => {
+    it("flushes works with not initialized local storage.", async () => {
+      expect.assertions(3);
+      await storage.flush();
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageDataKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(TestLocalStorage._runtimeCachedData[storage.storageDataKey]).toBeUndefined();
+      expect(TestLocalStorage._runtimeCachedMetadata[storage.storageMetadataKey]).toBeUndefined();
+    });
+
+    it("flushes content of the local storage.", async () => {
+      expect.assertions(3);
+      const dto = {
+        id: uuidv4(),
+        name: "test",
+      };
+      const entity = new TestEntityLocalStorage(dto);
+      await storage.setData(entity);
+      await storage.flush();
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageDataKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(TestLocalStorage._runtimeCachedData[storage.storageDataKey]).toBeUndefined();
+      expect(TestLocalStorage._runtimeCachedMetadata[storage.storageMetadataKey]).toBeUndefined();
+    });
+  });
+});

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

@@ -0,0 +1,105 @@
+/**
+ * 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 OnlineSessionEntity from "passbolt-styleguide/src/shared/models/entity/session/onlineSessionEntity";
+import Log from "../../model/log";
+import { assertType } from "../../utils/assertions";
+import AbstractAccountEntity from "../../model/entity/account/abstractAccountEntity";
+
+export const ACTIVE_SESSION_LOCAL_STORAGE_KEY = "active_session";
+
+class ActiveSessionLocalStorage {
+  /**
+   * Runtime cached data.
+   * @type {Object} Key: account_id, value: cached data as dto.
+   * @private
+   */
+  static _runtimeCachedData = {};
+
+  /**
+   * Constructor
+   * @param 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);
+  }
+
+  /**
+   * Get the storage key.
+   * @param {AbstractAccountEntity} account The account to get the key for.
+   * @returns {string}
+   * @throws {Error} If it cannot retrieve account id.
+   */
+  getStorageKey(account) {
+    return `${ACTIVE_SESSION_LOCAL_STORAGE_KEY}-${account.id}`;
+  }
+
+  /**
+   * Flush the active session from local storage and runtime cached data.
+   * @return {Promise<void>}
+   */
+  async flush() {
+    await browser.storage.local.remove(this.storageKey);
+    delete ActiveSessionLocalStorage._runtimeCachedData[this.account.id];
+    Log.write({ level: "debug", message: `ActiveSessionLocalStorage flushed for (${this.account.id})` });
+  }
+
+  /**
+   * Get the active session from the local storage.
+   * @return {Promise<object|undefined>}
+   */
+  async get() {
+    if (!ActiveSessionLocalStorage._runtimeCachedData[this.account.id]) {
+      const data = await browser.storage.local.get([this.storageKey]);
+      if (!data[this.storageKey]) {
+        return;
+      }
+      ActiveSessionLocalStorage._runtimeCachedData[this.account.id] = data[this.storageKey];
+    }
+
+    return ActiveSessionLocalStorage._runtimeCachedData[this.account.id];
+  }
+
+  /**
+   * Set the active session in the local storage.
+   * @param {OnlineSessionEntity} activeSession The active session to insert in the local storage.
+   * @return {Promise<void>}
+   * @throws {TypeError} If parameter settings is not of type OnlineSessionEntity.
+   */
+  async set(activeSession) {
+    assertType(activeSession, OnlineSessionEntity, "Parameter `activeSession` should be of type OnlineSessionEntity");
+    await navigator.locks.request(this.storageKey, async () => {
+      const activeSessionDto = activeSession.toDto();
+      await this._setBrowserStorage({ [this.storageKey]: activeSessionDto });
+      ActiveSessionLocalStorage._runtimeCachedData[this.account.id] = activeSessionDto;
+    });
+  }
+
+  /**
+   * Set the browser storage.
+   * @todo Tool to test the semaphore. A dedicated local storage service could be implemented later on top
+   * of the browser provided one to ease the testing.
+   * @param {object} data The data to store in the local storage.
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _setBrowserStorage(data) {
+    await browser.storage.local.set(data);
+  }
+}
+
+export default ActiveSessionLocalStorage;

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

@@ -0,0 +1,153 @@
+/**
+ * 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 AccountEntity from "../../model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
+import { defaultOnlineSessionDto } from "passbolt-styleguide/src/shared/models/entity/session/onlineSessionEntity.test.data";
+import ActiveSessionLocalStorage from "./activeSessionLocalStorage";
+import OnlineSessionEntity from "passbolt-styleguide/src/shared/models/entity/session/onlineSessionEntity";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("ActiveSessionLocalStorage", () => {
+  let account, storage;
+  beforeEach(() => {
+    account = new AccountEntity(defaultAccountDto());
+    storage = new ActiveSessionLocalStorage(account);
+    // flush account related storage before each.
+    storage.flush();
+  });
+
+  describe("::constructor", () => {
+    it("throws an error if no account is provided.", () => {
+      expect.assertions(1);
+      expect(() => new ActiveSessionLocalStorage()).toThrow(TypeError);
+    });
+
+    it("throws an error if parameter account is not a valid AccountEntity.", () => {
+      expect.assertions(1);
+      expect(() => new ActiveSessionLocalStorage({})).toThrow(TypeError);
+    });
+  });
+
+  describe("::get", () => {
+    it("returns undefined if nothing is stored in the local storage.", async () => {
+      expect.assertions(1);
+      const result = await storage.get();
+      expect(result).toBeUndefined();
+    });
+
+    it("returns content stored in the local storage.", async () => {
+      const activeSessionDto = defaultOnlineSessionDto();
+      expect.assertions(1);
+      browser.storage.local.set({ [storage.storageKey]: activeSessionDto });
+      const result = await storage.get();
+      expect(result).toEqual(activeSessionDto);
+    });
+
+    it("returns content stored in the runtime cache.", async () => {
+      const activeSessionDto = defaultOnlineSessionDto();
+      expect.assertions(2);
+      // Force the runtime cache, to ensure it is hit even if the local storage is empty.
+      ActiveSessionLocalStorage._runtimeCachedData[account.id] = activeSessionDto;
+      const result = await storage.get();
+      expect(result).toEqual(activeSessionDto);
+      // Control the local storage was well empty.
+      expect(browser.storage.local.store[storage.storageKey]).toBeUndefined();
+    });
+  });
+
+  describe("::set", () => {
+    it("stores content in the local storage.", async () => {
+      expect.assertions(3);
+      const activeSessionDto = new OnlineSessionEntity(defaultOnlineSessionDto());
+      await storage.set(activeSessionDto);
+      // Expect the local storage (mocked here) to be set.
+      expect(browser.storage.local.store[storage.storageKey]).toEqual(activeSessionDto.toDto());
+      // Expect the runtime cache to be set.
+      expect(ActiveSessionLocalStorage._runtimeCachedData[account.id]).toEqual(activeSessionDto.toDto());
+      // Expect the get to retrieve the set data.
+      const resultGet = await storage.get();
+      expect(resultGet).toEqual(activeSessionDto.toDto());
+    });
+
+    it("throws if no data is given to store.", async () => {
+      expect.assertions(3);
+      await expect(() => storage.set()).rejects.toThrow(TypeError);
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(ActiveSessionLocalStorage._runtimeCachedData[account.id]).toBeUndefined();
+    });
+
+    it("throws if invalid data is given to store.", async () => {
+      expect.assertions(3);
+      await expect(() => storage.set({})).rejects.toThrow(TypeError);
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(ActiveSessionLocalStorage._runtimeCachedData[account.id]).toBeUndefined();
+    });
+
+    it("waits any on-going call to set to perform another set.", async () => {
+      expect.assertions(3);
+      const promisesResolvers = [];
+
+      jest.spyOn(storage, "_setBrowserStorage").mockImplementation(() => {
+        let resolve;
+        const promise = new Promise((_resolve) => (resolve = _resolve));
+        promisesResolvers.push(resolve);
+        return promise;
+      });
+
+      const resultPromise1 = storage.set(new OnlineSessionEntity(defaultOnlineSessionDto()));
+      const onlineSessionUpdated = defaultOnlineSessionDto({
+        is_mfa_authenticated: false,
+        last_online_logged_in: "2022-05-05T12:41:45.000Z",
+      });
+      const resultPromise2 = storage.set(new OnlineSessionEntity(onlineSessionUpdated));
+      expect(storage._setBrowserStorage).toHaveBeenCalledWith({ [storage.storageKey]: defaultOnlineSessionDto() });
+      expect(storage._setBrowserStorage).not.toHaveBeenCalledWith({ [storage.storageKey]: onlineSessionUpdated });
+      promisesResolvers[0]();
+      await resultPromise1;
+      expect(storage._setBrowserStorage).toHaveBeenCalledWith({ [storage.storageKey]: onlineSessionUpdated });
+      promisesResolvers[1]();
+      await resultPromise2;
+    });
+  });
+
+  describe("::flush", () => {
+    it("flushes works with not initialized local storage.", async () => {
+      expect.assertions(2);
+      await storage.flush();
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(ActiveSessionLocalStorage._runtimeCachedData[account.id]).toBeUndefined();
+    });
+
+    it("flushes content of the local storage.", async () => {
+      expect.assertions(2);
+      const activeSessionDto = new OnlineSessionEntity(defaultOnlineSessionDto());
+      await storage.set(activeSessionDto);
+      await storage.flush();
+      // Expect the local storage (mocked here) to not be set.
+      expect(browser.storage.local.store[storage.storageKey]).toBeUndefined();
+      // Expect the runtime cache to not be set.
+      expect(ActiveSessionLocalStorage._runtimeCachedData[account.id]).toBeUndefined();
+    });
+  });
+});

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

@@ -11,98 +11,26 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         4.1.0
  */
-import Log from "../../model/log";
-import RbacEntity from "passbolt-styleguide/src/shared/models/entity/rbac/rbacEntity";
 import RbacsCollection from "passbolt-styleguide/src/shared/models/entity/rbac/rbacsCollection";
+import AbstractLocalStorage from "./abstractLocalStorage";
 
 export const RBACS_LOCAL_STORAGE_KEY = "rbac";
 
-class RbacsLocalStorage {
+class RbacsLocalStorage extends AbstractLocalStorage {
   /**
-   * Constructor
-   * @param account the user account
+   * Get the key property
+   * @return {string}
    */
-  constructor(account) {
-    this.storageKey = this.getStorageKey(account);
+  get key() {
+    return RBACS_LOCAL_STORAGE_KEY;
   }
 
   /**
-   * Get the storage key.
-   * @param {AbstractAccountEntity} account The account to get the key for.
-   * @returns {string}
-   * @throws {Error} If it cannot retrieve account id.
+   * Get the entity class
+   * @return {RbacsCollection}
    */
-  getStorageKey(account) {
-    if (!account.id) {
-      throw new Error("Cannot retrieve account id, necessary to get a rbac storage key.");
-    }
-    return `${RBACS_LOCAL_STORAGE_KEY}-${account.id}`;
-  }
-
-  /**
-   * Flush the rbacs local storage
-   * @throws {Error} if operation failed
-   * @return {Promise<void>}
-   */
-  async flush() {
-    Log.write({ level: "debug", message: "RbacLocalStorage flushed" });
-    return await browser.storage.local.remove(this.storageKey);
-  }
-
-  /**
-   * Get the rbacs local storage.
-   * @throws {Error} if operation failed
-   * @return {Promise<array|undefined>} results object, containing every object in keys that was found in the storage area.
-   * If storage is not set, undefined will be returned.
-   */
-  async get() {
-    const data = await browser.storage.local.get([this.storageKey]);
-    return data[this.storageKey];
-  }
-
-  /**
-   * Set the rbacs in local storage.
-   * @param {RbacsCollection} rbacsCollection The rbacs collection to insert in the local storage.
-   * @return {Promise<void>}
-   */
-  async set(rbacsCollection) {
-    await navigator.locks.request(this.storageKey, async () => {
-      const rbacs = [];
-      if (rbacsCollection) {
-        if (!(rbacsCollection instanceof RbacsCollection)) {
-          throw new TypeError("RbacsLocalStorage::set expects a RbacsCollection");
-        }
-        for (const rbacEntity of rbacsCollection) {
-          RbacsLocalStorage.assertEntityBeforeSave(rbacEntity);
-          rbacs.push(rbacEntity.toDto(RbacEntity.ALL_CONTAIN_OPTIONS));
-        }
-      }
-      await browser.storage.local.set({ [this.storageKey]: rbacs });
-    });
-  }
-
-  /*
-   * =================================================
-   * Static methods
-   * =================================================
-   */
-  /**
-   * Make sure the entity meet some minimal requirements before being stored
-   *
-   * @param {RbacEntity} rbacEntity
-   * @throw {TypeError} if requirements are not met
-   * @private
-   */
-  static assertEntityBeforeSave(rbacEntity) {
-    if (!rbacEntity) {
-      throw new TypeError("RolesLocalStorage expects a RbacEntity to be set");
-    }
-    if (!(rbacEntity instanceof RbacEntity)) {
-      throw new TypeError("RolesLocalStorage expects an object of type RbacEntity");
-    }
-    if (!rbacEntity.id) {
-      throw new TypeError("RolesLocalStorage expects RbacEntity id to be set");
-    }
+  get entityClass() {
+    return RbacsCollection;
   }
 }
 

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

@@ -29,7 +29,7 @@ describe("RbacLocalStorage", () => {
     it("Should return undefined if nothing stored in the storage", async () => {
       expect.assertions(1);
       const rbacLocalstorage = new RbacLocalStorage(account);
-      const result = await rbacLocalstorage.get();
+      const result = await rbacLocalstorage.getData();
       expect(result).toEqual(undefined);
     });
 
@@ -37,20 +37,20 @@ describe("RbacLocalStorage", () => {
       const rbacs = [defaultRbacWithUiActionData()];
       expect.assertions(1);
       const rbacLocalstorage = new RbacLocalStorage(account);
-      browser.storage.local.set({ [rbacLocalstorage.storageKey]: rbacs });
-      const result = await rbacLocalstorage.get();
+      browser.storage.local.set({ [rbacLocalstorage.storageDataKey]: rbacs });
+      const result = await rbacLocalstorage.getData();
       expect(result).toEqual(rbacs);
     });
   });
 
-  describe("RbacLocalStorage::set", () => {
-    it("Should set a rbac colection in the local storage", async () => {
+  describe("RbacLocalStorage::setData", () => {
+    it("Should setData a rbac colection in the local storage", async () => {
       expect.assertions(2);
       const rbacLocalstorage = new RbacLocalStorage(account);
       const rbac = new RbacEntity(defaultRbacWithUiActionData());
       const rbacsCollection = new RbacsCollection([rbac]);
-      await rbacLocalstorage.set(rbacsCollection);
-      const rbacs = await rbacLocalstorage.get();
+      await rbacLocalstorage.setData(rbacsCollection);
+      const rbacs = await rbacLocalstorage.getData();
       expect(rbacs).toHaveLength(1);
       expect(rbacs[0]).toEqual(rbac.toDto(RbacEntity.ALL_CONTAIN_OPTIONS));
     });
@@ -61,7 +61,7 @@ describe("RbacLocalStorage", () => {
       expect.assertions(1);
       const rbacLocalstorage = new RbacLocalStorage(account);
       await rbacLocalstorage.flush();
-      const rbacs = await rbacLocalstorage.get();
+      const rbacs = await rbacLocalstorage.getData();
       expect(rbacs).toEqual(undefined);
     });
   });