passbolt-browser-extension 5.2.0 → 5.3.2

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

@@ -0,0 +1,33 @@
+/**
+ * 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 ResponseClipboardOffscreenService from "./responseClipboardOffscreenService";
+import {defaultClipboardWriteResponseMessage} from "./responseClipboardOffscreenService.test.data";
+import {defaultCallbacks} from "../network/responseFetchOffscreenService.test.data";
+
+describe("ResponseClipboardOffscreenService", () => {
+  describe("::handleClipboardResponse", () => {
+    it("should resolve the promise from the response callback", () => {
+      expect.assertions(1);
+
+      const id = crypto.randomUUID();
+      const callbacks = defaultCallbacks();
+
+      const message = defaultClipboardWriteResponseMessage({id});
+      ResponseClipboardOffscreenService.handleClipboardResponse(message, callbacks);
+
+      expect(callbacks.resolve).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/chrome-mv3/serviceWorker/service/network/requestFetchOffscreenService.js

@@ -16,27 +16,21 @@ import {
   FETCH_OFFSCREEN_DATA_TYPE_FORM_DATA,
   FETCH_OFFSCREEN_DATA_TYPE_JSON
 } from "../../../offscreens/service/network/fetchOffscreenService";
+import CreateOffscreenDocumentService from "../offscreen/createOffscreenDocumentService";
+import HandleOffscreenResponseService from "../offscreen/handleOffscreenResponseService";
 
 const {SEND_MESSAGE_TARGET_FETCH_OFFSCREEN} = require("../../../offscreens/service/network/fetchOffscreenService");
 
 export const IS_FETCH_OFFSCREEN_PREFERRED_STORAGE_KEY = "IS_FETCH_OFFSCREEN_PREFERRED_STORAGE_KEY";
-const LOCK_CREATE_OFFSCREEN_FETCH_DOCUMENT = "LOCK_CREATE_OFFSCREEN_FETCH_DOCUMENT";
-const FETCH_OFFSCREEN_DOCUMENT_REASON = "WORKERS";
-const OFFSCREEN_URL = "offscreens/fetch.html";
 
 export class RequestFetchOffscreenService {
   /**
    * Preferred strategy cache.
    * @type {boolean|null}
+   * @private
    */
   static isFetchOffscreenPreferredCache = null;
 
-  /**
-   * The stack of requests promises callbacks using the request id as reference.
-   * @type {object}
-   */
-  static offscreenRequestsPromisesCallbacks = {};
-
   /**
    * Fetch external service through fetch offscreen document.
    * @param {string} resource The fetch url resource, similar to the native fetch resource parameter.
@@ -54,6 +48,7 @@ export class RequestFetchOffscreenService {
   /**
    * Check if the fetch offscreen strategy is preferred.
    * @returns {Promise<boolean>}
+   * @private
    */
   static async isFetchOffscreenPreferred() {
     if (RequestFetchOffscreenService.isFetchOffscreenPreferredCache === null) {
@@ -69,6 +64,7 @@ export class RequestFetchOffscreenService {
    * @param {string} resource The fetch url resource, similar to the native fetch resource parameter.
    * @param {object} options The fetch options, similar to the native fetch option parameter.
    * @returns {Promise<Response>}
+   * @private
    */
   static async fetchNative(resource, options) {
     try {
@@ -89,53 +85,30 @@ export class RequestFetchOffscreenService {
    * @param {string} resource The fetch url resource, similar to the native fetch resource parameter.
    * @param {object} options The fetch options, similar to the native fetch option parameter.
    * @returns {Promise<Response>}
+   * @private
    */
   static async fetchOffscreen(resource, options) {
-    // Create offscreen document if it does not already exist.
-    await navigator.locks.request(
-      LOCK_CREATE_OFFSCREEN_FETCH_DOCUMENT,
-      RequestFetchOffscreenService.createIfNotExistOffscreenDocument);
+    await CreateOffscreenDocumentService.createIfNotExistOffscreenDocument();
 
-    const offscreenFetchId = crypto.randomUUID();
-    const offscreenFetchData = await RequestFetchOffscreenService.buildOffscreenData(offscreenFetchId, resource, options);
+    const requestId = crypto.randomUUID();
+    const offscreenFetchData = await RequestFetchOffscreenService.buildOffscreenData(resource, options);
 
     return new Promise((resolve, reject) => {
       // Stack the response listener callbacks.
-      RequestFetchOffscreenService.offscreenRequestsPromisesCallbacks[offscreenFetchId] = {resolve, reject};
-      return RequestFetchOffscreenService.sendOffscreenMessage(offscreenFetchData)
+      HandleOffscreenResponseService.setResponseCallback(requestId, {resolve, reject});
+      return RequestFetchOffscreenService.sendOffscreenMessage(requestId, offscreenFetchData)
         .catch(reject);
     });
   }
 
-  /**
-   * Create fetch offscreen document if it does not exist yet.
-   * @returns {Promise<void>}
-   */
-  static async createIfNotExistOffscreenDocument() {
-    const existingContexts = await chrome.runtime.getContexts({
-      contextTypes: ["OFFSCREEN_DOCUMENT"],
-      documentUrls: [chrome.runtime.getURL(OFFSCREEN_URL)]
-    });
-
-    if (existingContexts.length > 0) {
-      return;
-    }
-
-    await chrome.offscreen.createDocument({
-      url: OFFSCREEN_URL,
-      reasons: [FETCH_OFFSCREEN_DOCUMENT_REASON],
-      justification: "Used to perform fetch to services such as the passbolt API serving invalid certificate.",
-    });
-  }
-
   /**
    * Build offscreen message data.
-   * @param {string} id The identifier of the offscreen fetch request.
    * @param {string} resource The fetch url resource, similar to the native fetch resource parameter.
-   * @param {object} fetchOptions The fetch options, similar to the native fetch option parameter.
-   * @returns {object}
+   * @param {object} [fetchOptions = {}] The fetch options, similar to the native fetch option parameter.
+   * @returns {Promise<object>}
+   * @private
    */
-  static async buildOffscreenData(id, resource, fetchOptions = {}) {
+  static async buildOffscreenData(resource, fetchOptions = {}) {
     const options = JSON.parse(JSON.stringify(fetchOptions));
 
     // Format FormData fetch options to allow its serialization.
@@ -152,27 +125,29 @@ export class RequestFetchOffscreenService {
       };
     }
 
-    return {id, resource, options};
+    return {resource, options};
   }
 
   /**
    * Send message to the offscreen fetch document.
-   * @param {object} offscreenData The offscreen message data.
-   * @param {string} offscreenData.id The identifier of the offscreen fetch request.
+   * @param {string} id the identified of the request
    * @param {string} offscreenData.resource The fetch url resource, similar to the native fetch resource parameter.
-   * @param {object} offscreenData.fetchOptions The fetch options, similar to the native fetch option parameter.
-   * @returns {Promise<*>}
+   * @param {object} offscreenData.options The fetch options, similar to the native fetch option parameter.
+   * @returns {Promise<void>}
+   * @private
    */
-  static async sendOffscreenMessage(offscreenData) {
+  static async sendOffscreenMessage(id, data) {
     return chrome.runtime.sendMessage({
+      id: id,
+      data: data,
       target: SEND_MESSAGE_TARGET_FETCH_OFFSCREEN,
-      data: offscreenData
     });
   }
 
   /**
    * Mark the fetch offscreen strategy as preferred.
-   * return {Promise<void>}
+   * @returns {Promise<void>}
+   * @private
    */
   static async markFetchOffscreenStrategyAsPreferred() {
     RequestFetchOffscreenService.isFetchOffscreenPreferredCache = true;

package/src/chrome-mv3/serviceWorker/service/network/requestFetchOffscreenService.test.js

@@ -25,6 +25,8 @@ import {
 } from "../../../offscreens/service/network/fetchOffscreenService";
 import {fetchOptionsWithBodyFormData, fetchOptionWithBodyData} from "./requestFetchOffscreenService.test.data";
 import FormDataUtils from "../../../../all/background_page/utils/format/formDataUtils";
+import {v4 as uuidv4} from "uuid";
+import HandleOffscreenResponseService from "../offscreen/handleOffscreenResponseService";
 
 beforeEach(() => {
   enableFetchMocks();
@@ -79,54 +81,25 @@ describe("RequestFetchOffscreenService", () => {
     });
   });
 
-  describe("::createIfNotExistOffscreenDocument", () => {
-    it("should create the offscreen document if it does not exist yet ", async() => {
-      expect.assertions(2);
-      jest.spyOn(chrome.runtime, "getContexts").mockImplementationOnce(() => []);
-      await RequestFetchOffscreenService.createIfNotExistOffscreenDocument();
-
-      const expectedGetContextsData = {
-        contextTypes: ["OFFSCREEN_DOCUMENT"],
-        documentUrls: ["chrome-extension://didegimhafipceonhjepacocaffmoppf/offscreens/fetch.html"]
-      };
-      const expectedCreateDocumentData = {
-        url: "offscreens/fetch.html",
-        reasons: ["WORKERS"],
-        justification: "Used to perform fetch to services such as the passbolt API serving invalid certificate."
-      };
-      expect(chrome.runtime.getContexts).toHaveBeenCalledWith(expectedGetContextsData);
-      expect(chrome.offscreen.createDocument).toHaveBeenCalledWith(expectedCreateDocumentData);
-    });
-
-    it("should not create the offscreen document if it already exist ", async() => {
-      expect.assertions(1);
-      jest.spyOn(chrome.runtime, "getContexts").mockImplementationOnce(() => ["shallow-offscreen-document-mock"]);
-      await RequestFetchOffscreenService.createIfNotExistOffscreenDocument();
-      expect(chrome.offscreen.createDocument).not.toHaveBeenCalled();
-    });
-  });
-
   describe("::buildOffscreenData", () => {
     it("should build data to send to the offscreen document", async() => {
       expect.assertions(1);
-      const id = crypto.randomUUID();
       const resource = "https://test.passbolt.com/passbolt-unit-test/test.json";
       const options = fetchOptionWithBodyData();
-      const offscreenData = await RequestFetchOffscreenService.buildOffscreenData(id, resource, options);
+      const offscreenData = await RequestFetchOffscreenService.buildOffscreenData(resource, options);
       options.body = {
         data: options.body,
         dataType: FETCH_OFFSCREEN_DATA_TYPE_JSON
       };
       // Ensure body remains a form data after serialization.
-      expect(offscreenData).toEqual({id, resource, options});
+      expect(offscreenData).toEqual({resource, options});
     });
 
     it("should ensure given fetch options body will not be altered", async() => {
       expect.assertions(2);
-      const id = crypto.randomUUID();
       const resource = "https://test.passbolt.com/passbolt-unit-test/test.json";
       const fetchOptions = fetchOptionsWithBodyFormData();
-      const offscreenData = await RequestFetchOffscreenService.buildOffscreenData(id, resource, fetchOptions);
+      const offscreenData = await RequestFetchOffscreenService.buildOffscreenData(resource, fetchOptions);
       // Ensure body remains a form data after serialization.
       expect(offscreenData.options.body.data).toBeInstanceOf(Array);
       expect(offscreenData.options.body.dataType).toStrictEqual(FETCH_OFFSCREEN_DATA_TYPE_FORM_DATA);
@@ -134,14 +107,12 @@ describe("RequestFetchOffscreenService", () => {
 
     it("should transform FormData body into serialized encoded url parameters", async() => {
       expect.assertions(1);
-      const id = crypto.randomUUID();
       const resource = "https://test.passbolt.com/passbolt-unit-test/test.json";
       const options = fetchOptionsWithBodyFormData();
 
-      const offscreenData = await RequestFetchOffscreenService.buildOffscreenData(id, resource, options);
+      const offscreenData = await RequestFetchOffscreenService.buildOffscreenData(resource, options);
       // eslint-disable-next-line object-shorthand
       const expectedOffscreenMessageData = {
-        id,
         resource,
         options: {
           ...options,
@@ -161,21 +132,27 @@ describe("RequestFetchOffscreenService", () => {
   describe("::sendOffscreenMessage", () => {
     it("should send a message to the offscreen document", async() => {
       expect.assertions(1);
+      const id = uuidv4();
       const data = {prop1: "value1"};
-      await RequestFetchOffscreenService.sendOffscreenMessage(data);
       const target = SEND_MESSAGE_TARGET_FETCH_OFFSCREEN;
-      expect(chrome.runtime.sendMessage).toHaveBeenCalledWith({target, data});
+
+      await RequestFetchOffscreenService.sendOffscreenMessage(id, data);
+
+      expect(chrome.runtime.sendMessage).toHaveBeenCalledWith({id, target, data});
     });
   });
 
   describe("::fetchOffscreen", () => {
     it("should send a message to the offscreen document and stack the response callback handlers", async() => {
       expect.assertions(4);
+
       const resource = "https://test.passbolt.com/passbolt-unit-test/test.json";
       const options = fetchOptionsWithBodyFormData();
+
       jest.spyOn(chrome.runtime, "sendMessage").mockImplementationOnce(message => {
-        expect(Validator.isUUID(message.data.id)).toBe(true);
+        expect(Validator.isUUID(message.id)).toBe(true);
         const expectedMessageData = {
+          id: message.id,
           target: SEND_MESSAGE_TARGET_FETCH_OFFSCREEN,
           data: {
             ...message.data,
@@ -195,7 +172,7 @@ describe("RequestFetchOffscreenService", () => {
           },
         };
         expect(message).toEqual(expectedMessageData);
-        RequestFetchOffscreenService.offscreenRequestsPromisesCallbacks[message.data.id].resolve();
+        HandleOffscreenResponseService._offscreenResponsePromisesCallbacks[message.id].resolve();
       });
       const requestPromise = RequestFetchOffscreenService.fetchOffscreen(resource, options);
       expect(requestPromise).toBeInstanceOf(Promise);

package/src/chrome-mv3/serviceWorker/service/network/responseFetchOffscreenService.js

@@ -12,85 +12,54 @@
  * @since         4.7.0
  */
 
-import {assertUuid} from "../../../../all/background_page/utils/assertions";
 import {
   FETCH_OFFSCREEN_RESPONSE_TYPE_ERROR,
   FETCH_OFFSCREEN_RESPONSE_TYPE_SUCCESS,
-  SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER,
-  SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_POLLING_HANDLER,
 } from "../../../offscreens/service/network/fetchOffscreenService";
-import {RequestFetchOffscreenService} from "./requestFetchOffscreenService";
+
+const FETCH_OFFSCREEN_RESPONSE_TYPES = [FETCH_OFFSCREEN_RESPONSE_TYPE_SUCCESS, FETCH_OFFSCREEN_RESPONSE_TYPE_ERROR];
 
 export default class ResponseFetchOffscreenService {
   /**
    * Handle fetch offscreen response message.
    * @param {object} message The message itself.
+   * @param {{resolve: function, reject: function}} message The message itself.
    * @return {void}
    */
-  static handleFetchResponse(message) {
-    // This is a polling message for long request to keep the service worker alive.
-    if (message.target === SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_POLLING_HANDLER) {
-      console.debug("ResponseFetchOffscreenService: polled");
-      return;
-    }
-
-    // Return early if this message isn't meant for the offscreen document.
-    if (message.target !== SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER) {
-      console.debug("ResponseFetchOffscreenService: received message not specific to the service worker fetch offscreen response handler.");
-      return;
-    }
-
+  static handleFetchResponse(message, callbacks) {
     ResponseFetchOffscreenService.assertMessage(message);
-    const {id, type, data} = message;
-    const offscreenRequestPromiseCallbacks = ResponseFetchOffscreenService.consumeRequestPromiseCallbacksOrFail(id);
+
+    const {type, data} = message;
 
     if (type === FETCH_OFFSCREEN_RESPONSE_TYPE_SUCCESS) {
-      offscreenRequestPromiseCallbacks.resolve(ResponseFetchOffscreenService.buildFetchResponse(data));
-    } else if (type === FETCH_OFFSCREEN_RESPONSE_TYPE_ERROR) {
-      offscreenRequestPromiseCallbacks.reject(new Error(data.message));
+      callbacks.resolve(ResponseFetchOffscreenService.buildFetchResponse(data));
+    } else {
+      callbacks.reject(new Error(data.message));
     }
   }
 
   /**
    * Assert message data.
    * @param {object} message The message.
-   * @returns {void}
-   * @throws {Error} If the message id is not a valid uuid.
-   * @throws {Error} If the message data is not an object.
-   * @throws {Error} If the message type is not valid.
+   * @throws {Error} If the message.data is not an object.
+   * @throws {Error} If the message.type is not valid.
+   * @private
    */
   static assertMessage(message) {
-    const FETCH_OFFSCREEN_RESPONSE_TYPES = [FETCH_OFFSCREEN_RESPONSE_TYPE_SUCCESS, FETCH_OFFSCREEN_RESPONSE_TYPE_ERROR];
-
     if (!FETCH_OFFSCREEN_RESPONSE_TYPES.includes(message?.type)) {
       throw new Error(`ResponseFetchOffscreenService: message.type should be one of the following ${FETCH_OFFSCREEN_RESPONSE_TYPES.join(", ")}.`);
     }
-    assertUuid(message?.id, "ResponseFetchOffscreenService: message.id should be a valid uuid.");
+
     if (!(message?.data instanceof Object)) {
       throw new Error("ResponseFetchOffscreenService: message.data should be an object.");
     }
   }
 
-  /**
-   * Consume the offscreen request promise callbacks or fail.
-   * @param {string} id The identifier of the offscreen fetch request.
-   * @returns {object}
-   * @throws {Error} If no request promise callbacks can be found for the given offscreen fetch request id.
-   */
-  static consumeRequestPromiseCallbacksOrFail(id) {
-    const offscreenRequestPromiseCallback = RequestFetchOffscreenService.offscreenRequestsPromisesCallbacks[id];
-    if (!offscreenRequestPromiseCallback) {
-      throw new Error("ResponseFetchOffscreenService: No request promise callbacks found for the given offscreen fetch request id.");
-    }
-    delete RequestFetchOffscreenService.offscreenRequestsPromisesCallbacks[id];
-
-    return offscreenRequestPromiseCallback;
-  }
-
   /**
    * Build native fetch response object based on offscreen message response data.
    * @param {object} data The fetch offscreen message response data.
    * @returns {Response}
+   * @private
    */
   static buildFetchResponse(data) {
     return new Response(data.text, {

package/src/chrome-mv3/serviceWorker/service/network/responseFetchOffscreenService.test.js

@@ -109,25 +109,6 @@ describe("ResponseFetchOffscreenService", () => {
     });
   });
 
-  describe("::consumeRequestPromiseCallbacksOrFail", () => {
-    it("should consume the response handler associated to the given id", () => {
-      expect.assertions(3);
-      const id = crypto.randomUUID();
-      const callbacks = defaultCallbacks();
-      RequestFetchOffscreenService.offscreenRequestsPromisesCallbacks[id] = callbacks;
-      const consumedCallbacks = ResponseFetchOffscreenService.consumeRequestPromiseCallbacksOrFail(id);
-      expect(consumedCallbacks).not.toBeNull();
-      expect(consumedCallbacks).toEqual(callbacks);
-      expect(Object.keys(RequestFetchOffscreenService.offscreenRequestsPromisesCallbacks).length).toEqual(0);
-    });
-
-    it("should throw if no associated callbacks found for the given id", () => {
-      expect.assertions(1);
-      const id = crypto.randomUUID();
-      expect(() => ResponseFetchOffscreenService.consumeRequestPromiseCallbacksOrFail(id)).toThrow();
-    });
-  });
-
   describe("::buildFetchResponse", () => {
     it("should build the fetch response object based on the offscreen message data", async() => {
       expect.assertions(8);
@@ -149,9 +130,9 @@ describe("ResponseFetchOffscreenService", () => {
       expect.assertions(1);
       const id = crypto.randomUUID();
       const callbacks = defaultCallbacks();
-      RequestFetchOffscreenService.offscreenRequestsPromisesCallbacks[id] = callbacks;
       const message = defaultResponseMessage({id});
-      ResponseFetchOffscreenService.handleFetchResponse(message);
+
+      ResponseFetchOffscreenService.handleFetchResponse(message, callbacks);
       expect(callbacks.resolve).toHaveBeenCalledWith(expect.any(Response));
     });
 
@@ -159,23 +140,10 @@ describe("ResponseFetchOffscreenService", () => {
       expect.assertions(1);
       const id = crypto.randomUUID();
       const callbacks = defaultCallbacks();
-      RequestFetchOffscreenService.offscreenRequestsPromisesCallbacks[id] = callbacks;
-      // eslint-disable-next-line object-shorthand
-      const message = defaultResponseMessage({id, type: FETCH_OFFSCREEN_RESPONSE_TYPE_ERROR});
-      ResponseFetchOffscreenService.handleFetchResponse(message);
-      expect(callbacks.reject).toHaveBeenCalledWith(expect.any(Error));
-    });
+      const message = defaultResponseMessage({id: id, type: FETCH_OFFSCREEN_RESPONSE_TYPE_ERROR});
 
-    it("should ignore message having the wrong target", () => {
-      expect.assertions(2);
-      const id = crypto.randomUUID();
-      const callbacks = defaultCallbacks();
-      RequestFetchOffscreenService.offscreenRequestsPromisesCallbacks[id] = callbacks;
-      // eslint-disable-next-line object-shorthand
-      const message = defaultResponseMessage({id, target: "other-target"});
-      ResponseFetchOffscreenService.handleFetchResponse(message);
-      expect(callbacks.resolve).not.toHaveBeenCalled();
-      expect(callbacks.reject).not.toHaveBeenCalled();
+      ResponseFetchOffscreenService.handleFetchResponse(message, callbacks);
+      expect(callbacks.reject).toHaveBeenCalledWith(expect.any(Error));
     });
   });
 });

package/src/chrome-mv3/serviceWorker/service/offscreen/createOffscreenDocumentService.js

@@ -0,0 +1,43 @@
+/**
+ * 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 CLIPBOARD_OFFSCREEN_DOCUMENT_REASON = "CLIPBOARD";
+const FETCH_OFFSCREEN_DOCUMENT_REASON = "WORKERS";
+const OFFSCREEN_URL = "offscreens/offscreen.html";
+const LOCK_CREATE_OFFSCREEN_DOCUMENT = "LOCK_CREATE_OFFSCREEN_DOCUMENT";
+
+export default class CreateOffscreenDocumentService {
+  /**
+   * Create clipboard offscreen document if it does not exist yet.
+   * @returns {Promise<void>}
+   */
+  static async createIfNotExistOffscreenDocument() {
+    // Create offscreen document if it does not already exist.
+    await navigator.locks.request(LOCK_CREATE_OFFSCREEN_DOCUMENT, async() => {
+      const existingContexts = await chrome.runtime.getContexts({
+        contextTypes: ["OFFSCREEN_DOCUMENT"],
+        documentUrls: [chrome.runtime.getURL(OFFSCREEN_URL)]
+      });
+
+      if (existingContexts.length > 0) {
+        return;
+      }
+
+      await chrome.offscreen.createDocument({
+        url: OFFSCREEN_URL,
+        reasons: [FETCH_OFFSCREEN_DOCUMENT_REASON, CLIPBOARD_OFFSCREEN_DOCUMENT_REASON],
+        justification: "1. Read/write clipboard as clipboard API is unavailable in MV3 service workers 2. Perform requests to self hosted Passbolt API serving invalid certificate.",
+      });
+    });
+  }
+}

package/src/chrome-mv3/serviceWorker/service/offscreen/createOffscreenDocumentService.test.js

@@ -0,0 +1,48 @@
+/**
+ * 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 "./createOffscreenDocumentService";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("CreateOffscreenDocumentService", () => {
+  describe("::createIfNotExistOffscreenDocument", () => {
+    it("should create the offscreen document if it does not exist yet ", async() => {
+      expect.assertions(2);
+      jest.spyOn(chrome.runtime, "getContexts").mockImplementationOnce(() => []);
+      await CreateOffscreenDocumentService.createIfNotExistOffscreenDocument();
+
+      const expectedGetContextsData = {
+        contextTypes: ["OFFSCREEN_DOCUMENT"],
+        documentUrls: ["chrome-extension://didegimhafipceonhjepacocaffmoppf/offscreens/offscreen.html"]
+      };
+      const expectedCreateDocumentData = {
+        url: "offscreens/offscreen.html",
+        reasons: ["WORKERS", "CLIPBOARD"],
+        justification: "1. Read/write clipboard as clipboard API is unavailable in MV3 service workers 2. Perform requests to self hosted Passbolt API serving invalid certificate.",
+      };
+      expect(chrome.runtime.getContexts).toHaveBeenCalledWith(expectedGetContextsData);
+      expect(chrome.offscreen.createDocument).toHaveBeenCalledWith(expectedCreateDocumentData);
+    });
+
+    it("should not create the offscreen document if it already exist ", async() => {
+      expect.assertions(1);
+      jest.spyOn(chrome.runtime, "getContexts").mockImplementationOnce(() => ["shallow-offscreen-document-mock"]);
+      await CreateOffscreenDocumentService.createIfNotExistOffscreenDocument();
+      expect(chrome.offscreen.createDocument).not.toHaveBeenCalled();
+    });
+  });
+});