passbolt-browser-extension 5.2.0 → 5.3.2

package/src/chrome-mv3/offscreens/service/network/fetchOffscreenService.test.js

@@ -11,7 +11,6 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         4.7.0
  */
-import {v4 as uuid} from 'uuid';
 import {enableFetchMocks} from "jest-fetch-mock";
 import FetchOffscreenService from './fetchOffscreenService';
 import each from "jest-each";
@@ -19,97 +18,119 @@ import {defaultFetchMessage, defaultFetchResponse} from "./fetchOffscreenService
 
 beforeEach(() => {
   enableFetchMocks();
-  fetch.resetMocks();
   jest.clearAllMocks();
   // Flush runtime memory cache.
   FetchOffscreenService.pollingIntervalId = null;
   FetchOffscreenService.pendingRequestsCount = 0;
+
+  jest.spyOn(chrome.runtime, "sendMessage").mockImplementation(() => {});
 });
 
 describe("FetchOffscreenService", () => {
-  describe("::handleFetchRequest", () => {
-    it("should not proceed message if the message doesn't have a target", async() => {
+  describe("::handleSuccessResponse", () => {
+    it("should send a message through the chrome.runtime", async() => {
       expect.assertions(1);
-      const spyOnFetch = jest.spyOn(self, "fetch");
-      await FetchOffscreenService.handleFetchRequest({});
 
-      expect(spyOnFetch).not.toHaveBeenCalled();
+      const message = defaultFetchMessage();
+      const fetchResponse = {
+        headers: new Array([]),
+        status: 200,
+        statusText: "OK",
+        text: async() => "",
+        ok: true,
+        url: message.data.resource,
+        redirected: false,
+      };
+
+      const result = await FetchOffscreenService.handleSuccessResponse(fetchResponse);
+
+      const expectedResult = {
+        target: "service-worker-fetch-offscreen-response-handler",
+        type: "success",
+        data: await FetchOffscreenService.serializeResponse(fetchResponse),
+      };
+
+      expect(result).toStrictEqual(expectedResult);
     });
+  });
 
-    it("should not proceed message if targetting another process", async() => {
+  describe("::handleErrorResponse", () => {
+    it("should send an error message through the chrome.runtime", async() => {
       expect.assertions(1);
-      const spyOnFetch = jest.spyOn(self, "fetch");
-      await FetchOffscreenService.handleFetchRequest({target: "wrong-target"});
-      expect(spyOnFetch).not.toHaveBeenCalled();
+
+      const error = new Error("Something went wrong");
+      error.name = "A fake error name";
+
+      const result = await FetchOffscreenService.handleErrorResponse(error);
+
+      const expectedResult = {
+        target: "service-worker-fetch-offscreen-response-handler",
+        type: "error",
+        data: {
+          name: error.name,
+          message: error.message
+        }
+      };
+
+      expect(result).toStrictEqual(expectedResult);
     });
+  });
 
+  describe("::handleFetchRequest", () => {
     it("should increase and decrease the pending request count", async() => {
       expect.assertions(5);
       const message = defaultFetchMessage();
-      const spyOnFetch = jest.spyOn(self, "fetch").mockImplementation(async() => ({header: {}, body: {}}));
-      const spyOnIncreaseRequestCount = jest.spyOn(FetchOffscreenService, "increaseAwaitingRequests");
-      const spyOnDecreaseRequestCount = jest.spyOn(FetchOffscreenService, "decreaseAwaitingRequests");
-      await FetchOffscreenService.handleFetchRequest(message);
-
-      expect(spyOnFetch).toHaveBeenCalledTimes(1);
-      expect(spyOnFetch).toHaveBeenCalledWith(message.data.resource, message.data.options);
-      expect(spyOnIncreaseRequestCount).toHaveBeenCalledTimes(1);
-      expect(spyOnDecreaseRequestCount).toHaveBeenCalledTimes(1);
+      jest.spyOn(self, "fetch").mockImplementation(async() => ({header: {}, body: {}}));
+      jest.spyOn(FetchOffscreenService, "increaseAwaitingRequests");
+      jest.spyOn(FetchOffscreenService, "decreaseAwaitingRequests");
+
+      await FetchOffscreenService.handleFetchRequest(message.data);
+
+      expect(self.fetch).toHaveBeenCalledTimes(1);
+      expect(self.fetch).toHaveBeenCalledWith(message.data.resource, message.data.options);
+      expect(FetchOffscreenService.increaseAwaitingRequests).toHaveBeenCalledTimes(1);
+      expect(FetchOffscreenService.decreaseAwaitingRequests).toHaveBeenCalledTimes(1);
       expect(FetchOffscreenService.pendingRequestsCount).toStrictEqual(0);
     });
 
     it("should handle a successful response", async() => {
       expect.assertions(3);
       const message = defaultFetchMessage();
-      const expectedResponse = {header: {}, body: {}};
-      const spyOnFetch = jest.spyOn(self, "fetch").mockImplementation(async() => expectedResponse);
-      const spyOnSuccessResponse = jest.spyOn(FetchOffscreenService, "handleSuccessResponse");
-      const spyOnErrorResponse = jest.spyOn(FetchOffscreenService, "handleErrorResponse");
-      await FetchOffscreenService.handleFetchRequest(message);
-
-      expect(spyOnFetch).toHaveBeenCalledTimes(1);
-      expect(spyOnSuccessResponse).toHaveBeenCalledWith(message.data.id, expectedResponse);
-      expect(spyOnErrorResponse).not.toHaveBeenCalledWith();
+      const expectedResponse = {headers: new Array([]), body: {}};
+
+      jest.spyOn(self, "fetch").mockImplementation(async() => expectedResponse);
+      jest.spyOn(FetchOffscreenService, "handleSuccessResponse").mockImplementation(() => {});
+      jest.spyOn(FetchOffscreenService, "handleErrorResponse").mockImplementation(() => {});
+
+      await FetchOffscreenService.handleFetchRequest(message.data);
+
+      expect(self.fetch).toHaveBeenCalledTimes(1);
+      expect(FetchOffscreenService.handleSuccessResponse).toHaveBeenCalledWith(expectedResponse);
+      expect(FetchOffscreenService.handleErrorResponse).not.toHaveBeenCalled();
     });
 
     it("should handle a erroneous response", async() => {
       expect.assertions(3);
       const message = defaultFetchMessage();
       const expectedError = new Error("Something went wrong!");
-      const spyOnFetch = jest.spyOn(self, "fetch").mockImplementation(async() => { throw expectedError; });
-      const spyOnSuccessResponse = jest.spyOn(FetchOffscreenService, "handleSuccessResponse");
-      const spyOnErrorResponse = jest.spyOn(FetchOffscreenService, "handleErrorResponse");
-      await FetchOffscreenService.handleFetchRequest(message);
-
-      expect(spyOnFetch).toHaveBeenCalledTimes(1);
-      expect(spyOnSuccessResponse).not.toHaveBeenCalledWith();
-      expect(spyOnErrorResponse).toHaveBeenCalledWith(message.data.id, expectedError);
+
+      jest.spyOn(self, "fetch").mockImplementation(async() => { throw expectedError; });
+      jest.spyOn(FetchOffscreenService, "handleSuccessResponse").mockImplementation(() => {});
+      jest.spyOn(FetchOffscreenService, "handleErrorResponse").mockImplementation(() => {});
+
+      await FetchOffscreenService.handleFetchRequest(message.data);
+
+      expect(self.fetch).toHaveBeenCalledTimes(1);
+      expect(FetchOffscreenService.handleSuccessResponse).not.toHaveBeenCalledWith();
+      expect(FetchOffscreenService.handleErrorResponse).toHaveBeenCalledWith(expectedError);
     });
   });
 
   describe("::validateMessageData", () => {
-    it("should validate if the message data respects the format", async() => {
+    it("should validate if the message data respects the format", () => {
       const message = defaultFetchMessage();
-      const validation = await FetchOffscreenService.validateMessageData(message.data);
-      expect(validation).toBeTruthy();
-      expect(chrome.runtime.sendMessage).not.toHaveBeenCalled();
-    });
-
-    each([
-      {scenario: "undefined", id: undefined},
-      {scenario: "null", id: null},
-      {scenario: "invalid string", id: "invalid"},
-      {scenario: "boolean", id: true},
-      {scenario: "object", id: {data: crypto.randomUUID()}},
-    ]).describe("should fail if message id is not valid", _props => {
-      it(`should trow if message id: ${_props.scenario}`, async() => {
-        const message = defaultFetchMessage();
-        message.data.id = _props.id;
-        const spyOnErrorResponse = jest.spyOn(FetchOffscreenService, "handleErrorResponse");
-        const validation = await FetchOffscreenService.validateMessageData(message.data);
-        expect(validation).toBeFalsy();
-        expect(spyOnErrorResponse).toHaveBeenCalledWith(message.data.id, expect.any(Error));
-      });
+      const validation = FetchOffscreenService.validateMessageData(message.data.resource, message.data.options);
+      expect(validation).toBeNull();
     });
 
     each([
@@ -122,10 +143,13 @@ describe("FetchOffscreenService", () => {
       it(`should fail if message resource: ${_props.scenario}`, async() => {
         const message = defaultFetchMessage();
         message.data.resource = _props.resource;
-        const spyOnErrorResponse = jest.spyOn(FetchOffscreenService, "handleErrorResponse");
-        const validation = await FetchOffscreenService.validateMessageData(message.data);
+
+        jest.spyOn(FetchOffscreenService, "handleErrorResponse").mockImplementation(() => {});
+
+        const validation = await FetchOffscreenService.validateMessageData(message.data.resource, message.data.options);
+
         expect(validation).toBeFalsy();
-        expect(spyOnErrorResponse).toHaveBeenCalledWith(message.data.id, expect.any(Error));
+        expect(FetchOffscreenService.handleErrorResponse).toHaveBeenCalledWith(expect.any(Error));
       });
     });
 
@@ -139,68 +163,14 @@ describe("FetchOffscreenService", () => {
       it(`should fail if message options: ${_props.scenario}`, async() => {
         const message = defaultFetchMessage();
         message.data.options = _props.options;
-        const spyOnErrorResponse = jest.spyOn(FetchOffscreenService, "handleErrorResponse");
-        const validation = await FetchOffscreenService.validateMessageData(message.data);
-        expect(validation).toBeFalsy();
-        expect(spyOnErrorResponse).toHaveBeenCalledWith(message.data.id, expect.any(Error));
-      });
-    });
-  });
-
-  describe("::handleSuccessResponse", () => {
-    it("should send a message through the chrome.runtime", async() => {
-      expect.assertions(2);
-
-      const message = defaultFetchMessage();
-
-      const fetchResponse = {
-        headers: new Array([]),
-        status: 200,
-        statusText: "OK",
-        text: async() => "",
-        ok: true,
-        url: message.data.resource,
-        redirected: false,
-      };
-      await FetchOffscreenService.handleSuccessResponse(message.data.id, fetchResponse);
 
-      const expectedCall = {
-        target: "service-worker-fetch-offscreen-response-handler",
-        id: message.data.id,
-        type: "success",
-        data: await FetchOffscreenService.serializeResponse(fetchResponse),
-      };
+        jest.spyOn(FetchOffscreenService, "handleErrorResponse").mockImplementation(() => {});
 
-      expect(chrome.runtime.sendMessage).toHaveBeenCalledTimes(1);
-      expect(chrome.runtime.sendMessage).toHaveBeenCalledWith(expectedCall);
-    });
-  });
+        const validation = await FetchOffscreenService.validateMessageData(message.data.resource, message.data.options);
 
-  describe("::handleErrorResponse", () => {
-    it("should send an error message through the chrome.runtime", async() => {
-      expect.assertions(2);
-
-      const dataFetch = {
-        id: uuid(),
-      };
-
-      const error = new Error("Something went wrong");
-      error.name = "A fake error name";
-      const spyOnChromeRuntime = jest.spyOn(chrome.runtime, "sendMessage");
-      await FetchOffscreenService.handleErrorResponse(dataFetch.id, error);
-
-      const expectedCall = {
-        target: "service-worker-fetch-offscreen-response-handler",
-        id: dataFetch.id,
-        type: "error",
-        data: {
-          name: error.name,
-          message: error.message
-        }
-      };
-
-      expect(spyOnChromeRuntime).toHaveBeenCalledTimes(1);
-      expect(spyOnChromeRuntime).toHaveBeenCalledWith(expectedCall);
+        expect(validation).toBeFalsy();
+        expect(FetchOffscreenService.handleErrorResponse).toHaveBeenCalledWith(expect.any(Error));
+      });
     });
   });
 

package/src/chrome-mv3/offscreens/service/offscreen/handleOffscreenRequestService.js

@@ -0,0 +1,85 @@
+/**
+ * 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 FetchOffscreenService, {SEND_MESSAGE_TARGET_FETCH_OFFSCREEN} from "../network/fetchOffscreenService";
+import WriteClipobardOffscreenService, {SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN} from "../clipboard/writeClipobardOffscreenService";
+import {assertUuid} from "../../../../all/background_page/utils/assertions";
+
+export const SEND_MESSAGE_TARGET_OFFSCREEN_ERROR_RESPONSE_HANDLER = "service-worker-offscreen-error-response-handler";
+
+export default class HandleOffscreenRequestService {
+  /**
+   * Handle fetch request.
+   * @param {object} message Browser runtime.onMessage listener message.
+   * @returns {Promise<void>}
+   */
+  static async handleOffscreenRequest(message) {
+    HandleOffscreenRequestService._assertOffscreenRequest(message);
+
+    const REQUEST_HANDLE_MAP = {
+      [SEND_MESSAGE_TARGET_FETCH_OFFSCREEN]: FetchOffscreenService.handleFetchRequest,
+      [SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN]: WriteClipobardOffscreenService.handleClipboardRequest,
+    };
+
+    const requestHandler = REQUEST_HANDLE_MAP[message.target];
+    if (!requestHandler) {
+      console.debug(`HandleOffscreenRequestService received an unsupported request: "${message.target}".`);
+      return;
+    }
+
+    try {
+      const result = await requestHandler(message.data);
+      HandleOffscreenRequestService._sendResponseBack(message.id, result);
+    } catch (error) {
+      HandleOffscreenRequestService._sendErrorResponseBack(message.id, error);
+    }
+  }
+
+  /**
+   * Handle fetch success, and send response to the service worker.
+   * @param {string} id The fetch offscreen request id
+   * @param {object} data the data to send back to the requester.
+   * @returns {Promise<void>}
+   */
+  static async _sendResponseBack(id, data) {
+    await chrome.runtime.sendMessage({
+      id: id,
+      ...data,
+    });
+  }
+
+  /**
+   * Handle fetch success, and send response to the service worker.
+   * @param {string} id The fetch offscreen request id
+   * @param {object} data the data to send back to the requester.
+   * @returns {Promise<void>}
+   */
+  static async _sendErrorResponseBack(id, error) {
+    await chrome.runtime.sendMessage({
+      id: id,
+      target: SEND_MESSAGE_TARGET_OFFSCREEN_ERROR_RESPONSE_HANDLER,
+      data: {error: JSON.stringify(error, Object.getOwnPropertyNames(error))},
+    });
+  }
+
+  /**
+   * Asserts that the given message is a valid offscreen response message.
+   * @param {object} message
+   * @throws {Error} if message.id is not a valid UUID
+   * @private
+   */
+  static _assertOffscreenRequest(message) {
+    assertUuid(message.id, "HandleOffscreenRequestService: message.id should be a valid uuid.");
+  }
+}

package/src/chrome-mv3/offscreens/service/offscreen/handleOffscreenRequestService.test.js

@@ -0,0 +1,99 @@
+/**
+ * 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 FetchOffscreenService, {FETCH_OFFSCREEN_DATA_TYPE_JSON} from "../network/fetchOffscreenService";
+import WriteClipobardOffscreenService from "../clipboard/writeClipobardOffscreenService";
+import HandleOffscreenRequestService, {SEND_MESSAGE_TARGET_OFFSCREEN_ERROR_RESPONSE_HANDLER} from "./handleOffscreenRequestService";
+import {v4 as uuidv4} from "uuid";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("HandleOffscreenRequestService", () => {
+  describe("::handleOffscreenRequest", () => {
+    it("should redirect fetch request to FetchOffscreenService", async() => {
+      expect.assertions(3);
+
+      const message = {
+        id: uuidv4(),
+        target: "fetch-offscreen",
+        data: {
+          resource: "https://www.passbolt.com",
+          options: {
+            body: {
+              data: "test",
+              dataType: FETCH_OFFSCREEN_DATA_TYPE_JSON
+            }
+          }
+        },
+      };
+
+      jest.spyOn(FetchOffscreenService, "handleFetchRequest").mockImplementation(() => {});
+      jest.spyOn(WriteClipobardOffscreenService, "handleClipboardRequest");
+
+      await HandleOffscreenRequestService.handleOffscreenRequest(message);
+
+      expect(FetchOffscreenService.handleFetchRequest).toHaveBeenCalledTimes(1);
+      expect(FetchOffscreenService.handleFetchRequest).toHaveBeenCalledWith(message.data);
+      expect(WriteClipobardOffscreenService.handleClipboardRequest).not.toHaveBeenCalled();
+    });
+
+    it("should redirect clipboard write request to WriteClipobardOffscreenService", async() => {
+      expect.assertions(3);
+
+      const message = {
+        id: uuidv4(),
+        target: "clipboard-write-offscreen",
+        data: {
+          clipboardContent: "test",
+        },
+      };
+
+      jest.spyOn(FetchOffscreenService, "handleFetchRequest");
+      jest.spyOn(WriteClipobardOffscreenService, "handleClipboardRequest").mockImplementation(() => {});
+
+      await HandleOffscreenRequestService.handleOffscreenRequest(message);
+
+      expect(FetchOffscreenService.handleFetchRequest).not.toHaveBeenCalled();
+      expect(WriteClipobardOffscreenService.handleClipboardRequest).toHaveBeenCalledTimes(1);
+      expect(WriteClipobardOffscreenService.handleClipboardRequest).toHaveBeenCalledWith(message.data);
+    });
+
+    it("should send back a generic offscreen message if something wrong happens during the offscreen process", async() => {
+      expect.assertions(2);
+
+      const message = {
+        id: uuidv4(),
+        target: "clipboard-write-offscreen",
+        data: {},
+      };
+
+      const error = new Error("Impossible to copy to clipboard");
+      jest.spyOn(WriteClipobardOffscreenService, "handleClipboardRequest").mockImplementation(() => { throw error; });
+      jest.spyOn(chrome.runtime, "sendMessage").mockImplementation(() => {});
+
+      await HandleOffscreenRequestService.handleOffscreenRequest(message);
+
+      const expectedMessage = {
+        id: message.id,
+        target: SEND_MESSAGE_TARGET_OFFSCREEN_ERROR_RESPONSE_HANDLER,
+        data: {error: JSON.stringify(error, Object.getOwnPropertyNames(error))},
+      };
+
+      expect(chrome.runtime.sendMessage).toHaveBeenCalledTimes(1);
+      expect(chrome.runtime.sendMessage).toHaveBeenCalledWith(expectedMessage);
+    });
+  });
+});

package/src/chrome-mv3/polyfill/clipboardOffscreenPolyfill.js

@@ -0,0 +1,19 @@
+/**
+ * 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
+ */
+
+const {RequestClipboardOffscreenService} = require("../serviceWorker/service/clipboard/requestClipboardOffscreenService");
+
+module.exports = {
+  writeText: async data => RequestClipboardOffscreenService.writeText(data),
+};

package/src/chrome-mv3/serviceWorker/service/clipboard/requestClipboardOffscreenService.js

@@ -0,0 +1,51 @@
+/**
+ * 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 CreateOffscreenDocumentService from "../offscreen/createOffscreenDocumentService";
+import HandleOffscreenResponseService from "../offscreen/handleOffscreenResponseService";
+
+const {SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN} = require("../../../offscreens/service/clipboard/writeClipobardOffscreenService");
+
+export class RequestClipboardOffscreenService {
+  /**
+   * Run the equivalent of navigator.clipboard::writeText(content) through offscreen.
+   * @param {string} clipboardContent the content to copy to clipboard
+   * @returns {Promise<void>}
+   */
+  static async writeText(clipboardContent) {
+    await CreateOffscreenDocumentService.createIfNotExistOffscreenDocument();
+
+    const requestId = crypto.randomUUID();
+    const offscreenClipboardData = {clipboardContent};
+
+    return new Promise((resolve, reject) => {
+      // Stack the response listener callbacks.
+      HandleOffscreenResponseService.setResponseCallback(requestId, {resolve, reject});
+      return RequestClipboardOffscreenService.sendWriteTextOffscreenMessage(requestId, offscreenClipboardData)
+        .catch(reject);
+    });
+  }
+
+  /**
+   * Send message to the offscreen document for emulating a navigator.clipboard::writeText(data) operation.
+   * @param {object} offscreenData The data to copy to clipboard.
+   * @returns {Promise<*>}
+   */
+  static async sendWriteTextOffscreenMessage(id, data) {
+    return chrome.runtime.sendMessage({
+      id: id,
+      data: data,
+      target: SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN,
+    });
+  }
+}

package/src/chrome-mv3/serviceWorker/service/clipboard/requestClipboardOffscreenService.test.js

@@ -0,0 +1,70 @@
+/**
+ * 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 Validator from "validator";
+import {RequestClipboardOffscreenService} from "./requestClipboardOffscreenService";
+import {v4 as uuidv4} from "uuid";
+import HandleOffscreenResponseService from "../offscreen/handleOffscreenResponseService";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("RequestClipboardOffscreenService", () => {
+  describe("::sendWriteTextOffscreenMessage", () => {
+    it("should send a message to the offscreen document", async() => {
+      expect.assertions(1);
+      const id = uuidv4();
+      const data = {clipboardContent: "test-data"};
+      const target = "clipboard-write-offscreen";
+
+      await RequestClipboardOffscreenService.sendWriteTextOffscreenMessage(id, data);
+
+      expect(chrome.runtime.sendMessage).toHaveBeenCalledWith({id, data, target});
+    });
+  });
+
+  describe("::writeText", () => {
+    it("should send a message to the offscreen document and stack the response callback handlers", async() => {
+      expect.assertions(5);
+
+      let sentMessage;
+      jest.spyOn(chrome.runtime, "sendMessage").mockImplementationOnce(message => {
+        sentMessage = message;
+        HandleOffscreenResponseService._offscreenResponsePromisesCallbacks[message.id].resolve();
+      });
+
+      const clipboardContentToWrite = "clipboard-content";
+      const requestPromise = RequestClipboardOffscreenService.writeText(clipboardContentToWrite);
+
+      expect(requestPromise).toBeInstanceOf(Promise);
+      await expect(requestPromise).resolves.not.toThrow();
+
+      expect(Validator.isUUID(sentMessage.id)).toBe(true);
+      expect(chrome.runtime.sendMessage).toHaveBeenCalledTimes(1);
+      expect(chrome.runtime.sendMessage).toHaveBeenCalledWith({
+        id: sentMessage.id,
+        data: {clipboardContent: clipboardContentToWrite},
+        target: "clipboard-write-offscreen",
+      });
+    });
+
+    it("should throw if the message cannot be sent to the offscreen document for unexpected reason", async() => {
+      expect.assertions(1);
+      jest.spyOn(chrome.runtime, "sendMessage").mockImplementationOnce(() => { throw new Error("Test error"); });
+
+      await expect(() => RequestClipboardOffscreenService.writeText("test")).rejects.toThrow();
+    });
+  });
+});

package/src/chrome-mv3/serviceWorker/service/clipboard/responseClipboardOffscreenService.js

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+
+export default class ResponseClipboardOffscreenService {
+  /**
+   * Handle clipboard::writeText offscreen response message.
+   * @param {object} message.
+   * @param {{resolve: function, reject: function}} promise the offscreen response callback.
+   * @return {void}
+   */
+  static handleClipboardResponse(message, promise) {
+    promise.resolve();
+  }
+}

package/src/chrome-mv3/serviceWorker/service/clipboard/responseClipboardOffscreenService.test.data.js

@@ -0,0 +1,21 @@
+/**
+ * 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 {SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER} from "../../../offscreens/service/clipboard/writeClipobardOffscreenService";
+
+export const defaultClipboardWriteResponseMessage = (message = {}) => ({
+  id: crypto.randomUUID(),
+  target: SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER,
+  ...message
+});