passbolt-browser-extension 5.3.0 → 5.3.2

package/src/all/background_page/service/api/comment/{commentService.js → commentApiService.js}

@@ -12,12 +12,13 @@
  * @since         3.0.0
  */
 import CommentEntity from "../../../model/entity/comment/commentEntity";
+import {assertNonEmptyString} from "../../../utils/assertions";
 import AbstractService from "../abstract/abstractService";
 
 
 const COMMENT_SERVICE_RESOURCE_NAME = 'comments';
 
-class CommentService extends AbstractService {
+class CommentApiService extends AbstractService {
   /**
    * Constructor
    *
@@ -25,7 +26,7 @@ class CommentService extends AbstractService {
    * @public
    */
   constructor(apiClientOptions) {
-    super(apiClientOptions, CommentService.RESOURCE_NAME);
+    super(apiClientOptions, CommentApiService.RESOURCE_NAME);
   }
 
   /**
@@ -61,7 +62,7 @@ class CommentService extends AbstractService {
     this.assertValidId(foreignId);
     this.assertValidForeignModel(foreignModel);
 
-    contains = contains ? this.formatContainOptions(contains, CommentService.getSupportedContainOptions()) : null;
+    contains = contains ? this.formatContainOptions(contains, CommentApiService.getSupportedContainOptions()) : null;
     const urlOptions = {...contains};
 
     const url = this.apiClient.buildUrl(`${this.apiClient.baseUrl}/${foreignModel.toLowerCase()}/${foreignId}`, urlOptions || {});
@@ -122,13 +123,11 @@ class CommentService extends AbstractService {
    * @public
    */
   assertValidForeignModel(foreignModel) {
-    if (!foreignModel || typeof foreignModel !== 'string') {
-      throw new TypeError(`Comment foreign model should be a valid string.`);
-    }
+    assertNonEmptyString(foreignModel, `Comment foreign model should be a valid string.`);
     if (!CommentEntity.ALLOWED_FOREIGN_MODELS.includes(foreignModel)) {
       throw new TypeError(`Comment foreign model ${foreignModel} in not in the list of supported models.`);
     }
   }
 }
 
-export default CommentService;
+export default CommentApiService;

package/src/all/background_page/service/api/comment/commentApiService.test.js

@@ -0,0 +1,122 @@
+/**
+ * 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         5.4.0
+ */
+
+import {enableFetchMocks} from "jest-fetch-mock";
+import {v4 as uuidv4} from "uuid";
+import {mockApiResponse} from '../../../../../../test/mocks/mockApiResponse';
+import CommentApiService from "./commentApiService";
+import AccountEntity from "../../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../../model/entity/account/accountEntity.test.data";
+import BuildApiClientOptionsService from "../../account/buildApiClientOptionsService";
+import {defaultCommentCollectionDto} from "passbolt-styleguide/src/shared/models/entity/comment/commentEntityCollection.test.data";
+import {defaultCommentDto} from "passbolt-styleguide/src/shared/models/entity/comment/commentEntity.test.data";
+import PassboltServiceUnavailableError from "passbolt-styleguide/src/shared/lib/Error/PassboltServiceUnavailableError";
+import CommentEntity from "../../../model/entity/comment/commentEntity";
+import {mockApiResponseError} from "../../../../../../test/mocks/mockApiResponse";
+
+describe.only("ActionLogService", () => {
+  let apiClientOptions, account;
+  beforeEach(async() => {
+    enableFetchMocks();
+    fetch.resetMocks();
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+  });
+
+  describe('::findAll', () => {
+    it("retrieves the comments from API", async() => {
+      expect.assertions(2);
+
+      const commentsCollection = [defaultCommentCollectionDto()];
+      fetch.doMockOnceIf(/comments\/resource/, () => mockApiResponse(commentsCollection));
+
+      const service = new CommentApiService(apiClientOptions, account);
+      const resultDto = await service.findAll('Resource', uuidv4(), {creator: true});
+
+      expect(resultDto).toBeInstanceOf(Array);
+      expect(resultDto).toHaveLength(commentsCollection.length);
+    });
+
+    it("throws API error if the API encountered an issue", async() => {
+      expect.assertions(1);
+      fetch.doMockOnceIf(/comments\/resource/, () => mockApiResponseError(500, "Something wrong happened!"));
+
+      const service = new CommentApiService(apiClientOptions);
+
+      await expect(() => service.findAll('Resource')).rejects.toThrow(TypeError);
+    });
+
+    it("throws service unavailable error if an error occurred but not from the API (by instance cloudflare)", async() => {
+      expect.assertions(1);
+      fetch.doMockOnceIf(/comments\/resource/, () => { throw new Error("Service unavailable"); });
+
+      const service = new CommentApiService(apiClientOptions);
+
+      await expect(() => service.findAll('Resource', uuidv4(), {creator: true})).rejects.toThrow(PassboltServiceUnavailableError);
+    });
+  });
+
+  describe('::create', () => {
+    it("Create a comment", async() => {
+      expect.assertions(2);
+
+      const commentDto = defaultCommentDto({}, {withCreator: false, withModifier: false});
+
+      const payload = new CommentEntity(commentDto);
+      let reqPayload;
+      fetch.doMockOnceIf(/comments\/resource/, async req => {
+        expect(req.method).toEqual("POST");
+        reqPayload = await req.json();
+        return mockApiResponse(defaultCommentDto({...reqPayload, id: commentDto.id}));
+      });
+
+      const service = new CommentApiService(apiClientOptions);
+      const resultDto = await service.create(payload._props);
+
+      expect(resultDto).toEqual(expect.objectContaining(commentDto));
+    });
+
+    it("throws an error if input is invalid ", async() => {
+      expect.assertions(1);
+
+      const service = new CommentApiService(apiClientOptions);
+
+      await expect(() => service.create(42, {withCreator: false, withModifier: false})).rejects.toThrow(TypeError);
+    });
+  });
+
+
+  describe('::delete', () => {
+    it("Delete a comment", async() => {
+      expect.assertions(1);
+
+      const deleteCommentId = uuidv4();
+      fetch.doMockOnceIf(new RegExp(`/comments\/${deleteCommentId}\.json`), async req => {
+        expect(req.method).toEqual("DELETE");
+        return mockApiResponse({});
+      });
+
+      const service = new CommentApiService(apiClientOptions);
+      await service.delete(deleteCommentId);
+    });
+
+    it("throws an invalid parameter error if the id parameter is not valid", async() => {
+      expect.assertions(1);
+
+      const service = new CommentApiService(apiClientOptions);
+
+      await expect(() => service.delete(42)).rejects.toThrow(Error);
+    });
+  });
+});

package/src/all/background_page/service/auth/postLogoutService.js

@@ -19,6 +19,7 @@ import resourceInProgressCacheService from "../cache/resourceInProgressCache.ser
 import OnExtensionUpdateAvailableService from "../extension/onExtensionUpdateAvailableService";
 import InformCallToActionPagemod from "../../pagemod/informCallToActionPagemod";
 import WorkerService from "../worker/workerService";
+import CopyToClipboardService from "../clipboard/copyToClipboardService";
 class PostLogoutService {
   /**
    * Execute all processes after a logout
@@ -27,6 +28,7 @@ class PostLogoutService {
   static async exec() {
     await PostLogoutService.sendLogoutEventForWorkers();
     await LocalStorageService.flush();
+    await (new CopyToClipboardService()).flushTemporaryContentIfAny();
     await StartLoopAuthSessionCheckService.clearAlarm();
     toolbarService.handleUserLoggedOut();
     resourceInProgressCacheService.reset();

package/src/all/background_page/service/auth/postLogoutService.test.js

@@ -26,6 +26,7 @@ import StartLoopAuthSessionCheckService from "./startLoopAuthSessionCheckService
 import resourceInProgressCacheService from "../cache/resourceInProgressCache.service";
 import OnExtensionUpdateAvailableService from "../extension/onExtensionUpdateAvailableService";
 import toolbarService from "../toolbar/toolbarService";
+import CopyToClipboardService from "../clipboard/copyToClipboardService";
 
 describe("PostLogoutService", () => {
   beforeEach(() => {
@@ -84,11 +85,12 @@ describe("PostLogoutService", () => {
     });
 
     it("Should call all services that needs to run processes on logout", async() => {
-      expect.assertions(5);
+      expect.assertions(6);
       jest.spyOn(PortManager, "isPortExist").mockImplementation(() => false);
       jest.spyOn(LocalStorageService, "flush");
       jest.spyOn(toolbarService, "handleUserLoggedOut");
       jest.spyOn(StartLoopAuthSessionCheckService, "clearAlarm");
+      jest.spyOn(CopyToClipboardService.prototype, "flushTemporaryContentIfAny");
       jest.spyOn(resourceInProgressCacheService, "reset");
       jest.spyOn(OnExtensionUpdateAvailableService, "handleUserLoggedOut");
 
@@ -99,6 +101,7 @@ describe("PostLogoutService", () => {
       expect(StartLoopAuthSessionCheckService.clearAlarm).toHaveBeenCalledTimes(1);
       expect(resourceInProgressCacheService.reset).toHaveBeenCalledTimes(1);
       expect(OnExtensionUpdateAvailableService.handleUserLoggedOut).toHaveBeenCalledTimes(1);
+      expect(CopyToClipboardService.prototype.flushTemporaryContentIfAny).toHaveBeenCalledTimes(1);
     });
   });
 });

package/src/all/background_page/service/browser/browserService.js

@@ -0,0 +1,22 @@
+/**
+ * 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         5.3.2
+ */
+
+/**
+ * The service aims to help get browser information.
+ */
+export default class BrowserService {
+  static isFirefox() {
+    return browser.runtime.getURL("/").startsWith("moz-extension://");
+  }
+}

package/src/all/background_page/service/clipboard/clipboardProviderService.js

@@ -0,0 +1,40 @@
+/**
+ * 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         5.3.2
+ */
+import EdgeBackgroundPageClipboardService from "../../../../chrome/polyfill/clipboard/edgeBackgroundPageClipboardService";
+import BrowserService from "../browser/browserService";
+
+/**
+ * The service retrieves the appropriate clipboard provider for the current environment: Edge, Chrome, or Firefox.
+ */
+export default class ClipboardProviderService {
+  /**
+   * Returns a clipboard API that works for the currently used browser.
+   * @returns {Clipboard}
+   */
+  static getClipboard() {
+    //is Chrome with MV3?
+    if (typeof customNavigatorClipboard !== "undefined") {
+      // eslint-disable-next-line no-undef
+      return customNavigatorClipboard;
+    }
+
+    const isMV2 = chrome.runtime.getManifest().manifest_version === 2;
+    if (!BrowserService.isFirefox() && isMV2) {
+      //it's not firefox and it's MV2 => it's most probably Edge then
+      return EdgeBackgroundPageClipboardService;
+    }
+    //by default we provide the default clipboard
+    return navigator.clipboard;
+  }
+}

package/src/all/background_page/service/clipboard/clipboardProviderService.test.js

@@ -0,0 +1,61 @@
+/**
+ * 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         5.3.2
+ */
+import "../../../../../test/mocks/mockNavigatorClipboard";
+import ClipboardProviderService from "./clipboardProviderService";
+import BrowserService from "../browser/browserService";
+import EdgeBackgroundPageClipboardService from "../../../../chrome/polyfill/clipboard/edgeBackgroundPageClipboardService";
+
+beforeEach(() => {
+  global.customNavigatorClipboard = undefined;
+});
+
+describe("ClipboardProviderService", () => {
+  describe("::getClipboard", () => {
+    it("should return the customNavigatorClipboard if it is set", async() => {
+      expect.assertions(1);
+
+      const customNavigatorClipboard = {writeText: jest.fn()};
+      global.customNavigatorClipboard = customNavigatorClipboard;
+
+      expect(ClipboardProviderService.getClipboard()).toStrictEqual(customNavigatorClipboard);
+    });
+
+    it("should return the EdgeBackgroundPageClipboardService if not on Firefox and is on MV2", async() => {
+      expect.assertions(1);
+
+      chrome.runtime.getManifest.mockImplementation(() => ({manifest_version: 2}));
+      jest.spyOn(BrowserService, "isFirefox").mockImplementation(() => false);
+
+      expect(ClipboardProviderService.getClipboard()).toStrictEqual(EdgeBackgroundPageClipboardService);
+    });
+
+    it("should return the navigator.clipboard in every other cases: Firefox", async() => {
+      expect.assertions(1);
+
+      chrome.runtime.getManifest.mockImplementation(() => ({manifest_version: 2}));
+      jest.spyOn(BrowserService, "isFirefox").mockImplementation(() => true);
+
+      expect(ClipboardProviderService.getClipboard()).toStrictEqual(navigator.clipboard);
+    });
+
+    it("should return the navigator.clipboard in every other cases: Firefox + mv3", async() => {
+      expect.assertions(1);
+
+      chrome.runtime.getManifest.mockImplementation(() => ({manifest_version: 3}));
+      jest.spyOn(BrowserService, "isFirefox").mockImplementation(() => true);
+
+      expect(ClipboardProviderService.getClipboard()).toStrictEqual(navigator.clipboard);
+    });
+  });
+});

package/src/all/background_page/service/clipboard/copyToClipboardService.js

@@ -0,0 +1,123 @@
+/**
+ * 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         5.3.2
+ */
+import {assertString} from "../../utils/assertions";
+import BrowserService from "../browser/browserService";
+import ClipboardProviderService from "./clipboardProviderService";
+
+const CLIPBOARD_TEMPORARY_CONTENT_FLUSH_DELAY_IN_SECOND = 30;
+const CLIPBOARD_TEMPORARY_CONTENT_FLUSH_ALARM = "ClipboardTemporaryContentFlush";
+/**
+ * The service aims to use the clipboard capability on Edge MV2 where:
+ * - navigator.clipboard.writeText cannot be used in Edge MV2 background page due to a focus issue.
+ * - offscreen clipboard cannot be used due to offscreen API available only with MV3.
+ */
+export default class CopyToClipboardService {
+  /**
+   * @constructor
+   */
+  constructor() {
+    this.clipboard = ClipboardProviderService.getClipboard();
+  }
+
+  /**
+   * Copies the given data into the clipboard and sets a timer to remove after 30sec.
+   * @param {string} data
+   * @return {Promise<void>}
+   */
+  async copyTemporarily(data) {
+    assertString(data);
+
+    await this.clearAlarm();
+    await this.clipboard.writeText(data);
+
+    await browser.alarms.create(CopyToClipboardService.ALARM_NAME, {
+      when: Date.now() + CLIPBOARD_TEMPORARY_CONTENT_FLUSH_DELAY_IN_SECOND * 1000
+    });
+  }
+
+  /**
+   * Copies the given data into the clipboard and unsets any flush timer.
+   * @param {string} data
+   * @return {Promise<void>}
+   */
+  async copy(data) {
+    assertString(data);
+
+    await this.clearAlarm();
+    await this.clipboard.writeText(data);
+  }
+
+  /**
+   * Flushes the clipboard if the content is the expected one.
+   * @returns {Promise<void>}
+   */
+  async flushTemporaryContent() {
+    await this.clearAlarm();
+    await this.clipboard.writeText(this._getContentToFlushClipboard());
+  }
+
+  /**
+   * Flushes the clipboard content if there is any temporary content in it.
+   * @returns {Promise<void>}
+   */
+  async flushTemporaryContentIfAny() {
+    const hasTemporaryContent = Boolean(await browser.alarms.get(CopyToClipboardService.ALARM_NAME));
+    if (hasTemporaryContent) {
+      this.flushTemporaryContent();
+    }
+  }
+
+  /**
+   * Removes the flush alarm if any.
+   * @returns {Promise<void>}
+   */
+  async clearAlarm() {
+    await browser.alarms.clear(CopyToClipboardService.ALARM_NAME);
+  }
+
+  /**
+   * Returns a string that the browser can use to clean the clipboard.
+   * The "empty" string depends on the browser.
+   * Chromimum: "" is not accepted but "\x00" does the trick
+   * Firefox: "" is working fine but "\x00" is a bit buggy (the character could be pasted)
+   * @returns {string}
+   * @private
+   */
+  _getContentToFlushClipboard() {
+    return BrowserService.isFirefox()
+      ? ""
+      : "\x00";
+  }
+
+  /**
+   * Flush the current stored passphrase when the PassphraseStorageFlush alarm triggers.
+   * This is a top-level alarm callback
+   * @param {Alarm} alarm
+   * @returns {Promise<void>}
+   */
+  static async handleClipboardTemporaryContentFlushEvent(alarm) {
+    if (alarm.name === CopyToClipboardService.ALARM_NAME) {
+      const clipboardService = new CopyToClipboardService();
+      await clipboardService.flushTemporaryContent();
+    }
+  }
+
+  /**
+   * Returns the PASSPHRASE_FLUSH_ALARM name
+   * @returns {string}
+   */
+  static get ALARM_NAME() {
+    return CLIPBOARD_TEMPORARY_CONTENT_FLUSH_ALARM;
+  }
+}

package/src/all/background_page/service/clipboard/copyToClipboardService.test.js

@@ -0,0 +1,174 @@
+/**
+ * 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         5.3.2
+ */
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import CopyToClipboardService from "./copyToClipboardService";
+import "../../../../../test/mocks/mockNavigatorClipboard";
+import "../../../../../test/mocks/mockAlarms";
+
+beforeEach(async() => {
+  jest.clearAllMocks();
+  jest.useFakeTimers();
+  await browser.alarms.clearAll();
+});
+
+describe("CopyToClipboardService", () => {
+  describe("::copyTemporarily", () => {
+    it("should copy the given data into the clipboard and set an alarm", async() => {
+      expect.assertions(5);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      //ensures the test is not blocked by an unmocked promise
+      jest.spyOn(browser.alarms, "create").mockImplementation(() => {});
+      jest.spyOn(browser.alarms, "clear").mockImplementation(() => {});
+
+      const data = "data";
+      await service.copyTemporarily(data);
+
+      expect(await navigator.clipboard.readText()).toStrictEqual(data);
+      expect(browser.alarms.create).toHaveBeenCalledTimes(1);
+      expect(browser.alarms.create).toHaveBeenCalledWith(CopyToClipboardService.ALARM_NAME, {when: Date.now() + 30_000});
+      expect(browser.alarms.clear).toHaveBeenCalledTimes(1);
+      expect(browser.alarms.clear).toHaveBeenCalledWith(CopyToClipboardService.ALARM_NAME);
+    });
+
+    it("should throw an error if the data is not a string", async() => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      await expect(() => service.copyTemporarily(42)).rejects.toThrowError();
+    });
+  });
+
+  describe("::copy", () => {
+    it("should copy the given data into the clipboard and unset any flush alarm", async() => {
+      expect.assertions(3);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      //ensures the test is not blocked by an unmocked promise
+      jest.spyOn(browser.alarms, "clear").mockImplementation(() => {});
+
+      const data = "data";
+      await service.copy(data);
+
+      expect(await navigator.clipboard.readText()).toStrictEqual(data);
+      expect(browser.alarms.clear).toHaveBeenCalledTimes(1);
+      expect(browser.alarms.clear).toHaveBeenCalledWith(CopyToClipboardService.ALARM_NAME);
+    });
+
+    it("should throw an error if the data is not a string", async() => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      await expect(() => service.copy(42)).rejects.toThrowError();
+    });
+  });
+
+  describe("::flushTemporaryContent", () => {
+    it("should flush the data in the clipboard", async() => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      await service.copyTemporarily("data");
+      await service.flushTemporaryContent();
+
+      expect(await navigator.clipboard.readText()).toStrictEqual("\x00");
+    });
+  });
+
+  describe("::flushTemporaryContentIfAny", () => {
+    it("should flush the data in the clipboard if an alarm has been set", async() => {
+      expect.assertions(3);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      jest.spyOn(browser.alarms, "get").mockImplementation(async() => ({test: 42}));
+      jest.spyOn(navigator.clipboard, "writeText").mockImplementation(async() => {});
+
+      await service.copyTemporarily("data");
+      await service.flushTemporaryContentIfAny();
+
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledTimes(2);
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledWith("data");
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledWith("\x00");
+    });
+
+    it("should not flush the data in the clipboard if not alarm has been set", async() => {
+      expect.assertions(2);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+      const clipboardContent = "data";
+
+      jest.spyOn(browser.alarms, "get").mockImplementation(() => null);
+      jest.spyOn(navigator.clipboard, "writeText").mockImplementation(async() => {});
+
+      await service.copy(clipboardContent);
+      await service.flushTemporaryContentIfAny();
+
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledTimes(1);
+      expect(await navigator.clipboard.writeText).toHaveBeenCalledWith(clipboardContent);
+    });
+  });
+
+  describe("::clearAlarm", () => {
+    it("should remove the alarm if any", async() => {
+      expect.assertions(1);
+
+      jest.spyOn(browser.alarms, "clear").mockImplementation(() => {});
+
+      const account = new AccountEntity(defaultAccountDto());
+      const service = new CopyToClipboardService(account);
+
+      await service.clearAlarm();
+
+      expect(browser.alarms.clear).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("::handleClipboardTemporaryContentFlushEvent", () => {
+    it("should call to flush the clipboard if the alarm triggers", async() => {
+      expect.assertions(1);
+
+      jest.spyOn(CopyToClipboardService.prototype, "flushTemporaryContent").mockImplementation(() => {});
+
+      const alarm = {name: "ClipboardTemporaryContentFlush"};
+      await CopyToClipboardService.handleClipboardTemporaryContentFlushEvent(alarm);
+
+      expect(CopyToClipboardService.prototype.flushTemporaryContent).toHaveBeenCalledTimes(1);
+    });
+
+    it("should do nothing if the alarm is not the right one", async() => {
+      expect.assertions(1);
+
+      jest.spyOn(CopyToClipboardService.prototype, "flushTemporaryContent").mockImplementation(() => {});
+
+      const alarm = {name: "other-alarm"};
+      await CopyToClipboardService.handleClipboardTemporaryContentFlushEvent(alarm);
+
+      expect(CopyToClipboardService.prototype.flushTemporaryContent).not.toHaveBeenCalled();
+    });
+  });
+});