passbolt-browser-extension 5.12.1 → 5.13.0

package/src/all/background_page/model/keyring.js

@@ -32,6 +32,8 @@ const PRIVATE = "PRIVATE";
 const MY_KEY_ID = "MY_KEY_ID";
 const STORAGE_KEY_PUBLIC = "passbolt-public-gpgkeys";
 const STORAGE_KEY_PRIVATE = "passbolt-private-gpgkeys";
+// Number of public keys parsed concurrently during a keyring sync, to bound peak memory.
+const SYNC_CHUNK_SIZE = 500;
 
 /**
  * The class that deals with Passbolt Keyring.
@@ -88,6 +90,31 @@ class Keyring {
    *  if the user id is not valid
    */
   async importPublic(armoredPublicKey, userId) {
+    const keyInfo = await this.buildPublicKeyInfo(armoredPublicKey, userId);
+
+    // Add the key in the keyring.
+    const publicKeys = this.getPublicKeysFromStorage();
+    publicKeys[userId] = keyInfo;
+    this.store(Keyring.PUBLIC, publicKeys);
+
+    return true;
+  }
+
+  /**
+   * Validate, parse and read the metadata of a public armored key, without persisting it.
+   * Used by importPublic (single key) and sync (batch), so the keyring is stored only once
+   * instead of once per key.
+   *
+   * @param {string} armoredPublicKey The key to read
+   * @param {string} userId The owner of the key
+   * @returns {Promise<object>} The key info DTO, with its user_id set.
+   * @throw Error
+   *  if the key cannot be read by openpgp
+   *  if the key is not public
+   *  if the user id is not valid
+   * @private
+   */
+  async buildPublicKeyInfo(armoredPublicKey, userId) {
     // Check user id
     if (typeof userId === "undefined") {
       throw new Error("The user id is undefined");
@@ -107,14 +134,9 @@ class Keyring {
 
     // Get the keyInfo.
     const keyInfo = (await GetGpgKeyInfoService.getKeyInfo(primaryPublicKey)).toDto();
+    keyInfo.user_id = userId;
 
-    // Add the key in the keyring.
-    const publicKeys = this.getPublicKeysFromStorage();
-    publicKeys[userId] = keyInfo;
-    publicKeys[userId].user_id = userId;
-    this.store(Keyring.PUBLIC, publicKeys);
-
-    return true;
+    return keyInfo;
   }
 
   /**
@@ -259,20 +281,25 @@ class Keyring {
       throw new Error("Could not synchronize the keyring. The server response body is missing.");
     }
 
-    // Store all the new keys in the keyring.
-    let meta, i;
-    const imports = [];
-    for (i in json.body) {
-      if (Object.prototype.hasOwnProperty.call(json.body, i)) {
-        meta = json.body[i];
-        imports.push(this.importPublic(meta.armored_key, meta.user_id));
-      }
+    /*
+     * Build the keyring in memory and persist it once, rather than reading and re-serializing
+     * the whole keyring for every key (which is quadratic and exhausts memory on large orgs).
+     * Keys are read in bounded-size batches so we never parse the entire payload at once.
+     */
+    const publicKeys = this.getPublicKeysFromStorage();
+    const metas = Object.values(json.body).filter((meta) => meta?.armored_key && meta?.user_id);
+    for (let i = 0; i < metas.length; i += Keyring.SYNC_CHUNK_SIZE) {
+      const chunk = metas.slice(i, i + Keyring.SYNC_CHUNK_SIZE);
+      const keysInfo = await Promise.all(chunk.map((meta) => this.buildPublicKeyInfo(meta.armored_key, meta.user_id)));
+      keysInfo.forEach((keyInfo) => {
+        publicKeys[keyInfo.user_id] = keyInfo;
+      });
     }
-    await Promise.all(imports);
+    this.store(Keyring.PUBLIC, publicKeys);
 
     storage.setItem("latestSync", json.header.servertime);
 
-    return json.body.length;
+    return metas.length;
   }
 
   /*
@@ -402,6 +429,14 @@ class Keyring {
     return PUBLIC;
   }
 
+  /**
+   * Keyring.SYNC_CHUNK_SIZE
+   * @returns {number}
+   */
+  static get SYNC_CHUNK_SIZE() {
+    return SYNC_CHUNK_SIZE;
+  }
+
   /**
    * Keyring.PRIVATE
    * @returns {string}

package/src/all/background_page/model/keyring.test.js

@@ -0,0 +1,110 @@
+/**
+ * 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.13.0
+ */
+import { enableFetchMocks } from "jest-fetch-mock";
+import { v4 as uuidv4 } from "uuid";
+import { pgpKeys } from "passbolt-styleguide/test/fixture/pgpKeys/keys";
+import Keyring from "./keyring";
+import UserSettings from "./userSettings/userSettings";
+
+beforeAll(() => {
+  enableFetchMocks();
+});
+
+beforeEach(() => {
+  jest.restoreAllMocks();
+  fetch.resetMocks();
+  jest.spyOn(UserSettings.prototype, "getDomain").mockImplementation(() => "https://passbolt.dev");
+  new Keyring().flush(Keyring.PUBLIC);
+});
+
+const syncResponse = (body) => JSON.stringify({ header: { servertime: "2026-06-02T00:00:00+00:00" }, body });
+
+describe("Keyring", () => {
+  describe("::sync", () => {
+    it("should store every synced public key, tagged with its user id", async () => {
+      expect.assertions(5);
+      const keyring = new Keyring();
+      const adaId = uuidv4();
+      const bettyId = uuidv4();
+      fetch.mockResponseOnce(
+        syncResponse([
+          { user_id: adaId, armored_key: pgpKeys.ada.public },
+          { user_id: bettyId, armored_key: pgpKeys.betty.public },
+        ]),
+      );
+
+      const count = await keyring.sync();
+
+      const publicKeys = keyring.getPublicKeysFromStorage();
+      expect(count).toEqual(2);
+      expect(publicKeys[adaId]).toBeDefined();
+      expect(publicKeys[adaId].user_id).toEqual(adaId);
+      expect(publicKeys[bettyId]).toBeDefined();
+      expect(publicKeys[bettyId].user_id).toEqual(bettyId);
+    });
+
+    it("should persist the keyring only once, not once per key (O(n^2) regression guard)", async () => {
+      expect.assertions(2);
+      const keyring = new Keyring();
+      // Reuse one armored key across many distinct users — we only assert the persistence strategy.
+      const body = Array.from({ length: 50 }, () => ({ user_id: uuidv4(), armored_key: pgpKeys.ada.public }));
+      fetch.mockResponseOnce(syncResponse(body));
+      const storeSpy = jest.spyOn(Keyring.prototype, "store");
+
+      await keyring.sync();
+
+      expect(Object.keys(keyring.getPublicKeysFromStorage())).toHaveLength(50);
+      // The bug stored the whole keyring once per key (50 times); the fix stores once.
+      expect(storeSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it("should ignore body entries missing an armored key or user id", async () => {
+      expect.assertions(2);
+      const keyring = new Keyring();
+      const adaId = uuidv4();
+      fetch.mockResponseOnce(
+        syncResponse([
+          { user_id: adaId, armored_key: pgpKeys.ada.public },
+          { user_id: uuidv4() }, // missing armored_key
+          { armored_key: pgpKeys.betty.public }, // missing user_id
+        ]),
+      );
+
+      const count = await keyring.sync();
+
+      expect(count).toEqual(1);
+      expect(keyring.getPublicKeysFromStorage()[adaId]).toBeDefined();
+    });
+  });
+
+  describe("::importPublic", () => {
+    it("should still import and store a single public key", async () => {
+      expect.assertions(2);
+      const keyring = new Keyring();
+      const adaId = uuidv4();
+      const storeSpy = jest.spyOn(Keyring.prototype, "store");
+
+      await keyring.importPublic(pgpKeys.ada.public, adaId);
+
+      expect(keyring.getPublicKeysFromStorage()[adaId].user_id).toEqual(adaId);
+      expect(storeSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it("should reject an invalid user id", async () => {
+      expect.assertions(1);
+      const keyring = new Keyring();
+      await expect(keyring.importPublic(pgpKeys.ada.public, "not-a-uuid")).rejects.toThrow("The user id is not valid");
+    });
+  });
+});

package/src/all/background_page/model/resource/resourceModel.js

@@ -13,8 +13,8 @@
 import ResourceLocalStorage from "../../service/local_storage/resourceLocalStorage";
 import ResourceTypeModel from "../../model/resourceType/resourceTypeModel";
 import ResourcesCollection from "../entity/resource/resourcesCollection";
-import PermissionEntity from "../entity/permission/permissionEntity";
-import PermissionsCollection from "../entity/permission/permissionsCollection";
+import PermissionEntity from "passbolt-styleguide/src/shared/models/entity/permission/permissionEntity";
+import PermissionsCollection from "passbolt-styleguide/src/shared/models/entity/permission/permissionsCollection";
 import ResourceEntity from "../entity/resource/resourceEntity";
 import PermissionChangesCollection from "../entity/permission/change/permissionChangesCollection";
 import ResourceService from "../../service/api/resource/resourceService";
@@ -88,59 +88,6 @@ class ResourceModel {
    *  Permission changes
    * ==============================================================
    */
-  /**
-   * Calculate permission changes for a move
-   * From current permissions, remove the parent folder permissions, add the destination permissions
-   * From this new set of permission and the original permission calculate the needed changed
-   *
-   * NOTE: This function requires permissions to be set for all objects
-   *
-   * @param {ResourceEntity} resource
-   * @param {(FolderEntity|null)} parentFolder
-   * @param {(FolderEntity|null)} destFolder
-   * @returns {PermissionChangesCollection}
-   */
-  calculatePermissionsChangesForMove(resource, parentFolder, destFolder) {
-    let remainingPermissions = new PermissionsCollection([], { assertAtLeastOneOwner: false });
-
-    // Remove permissions from parent if any
-    if (parentFolder !== null) {
-      if (!resource.permissions || !parentFolder.permissions) {
-        throw new TypeError("Resource model calculatePermissionsChangesForMove requires permissions to be set.");
-      }
-      remainingPermissions = PermissionsCollection.diff(resource.permissions, parentFolder.permissions, false);
-    }
-    // Add parent permissions
-    let permissionsFromParent = new PermissionsCollection([], { assertAtLeastOneOwner: false });
-    if (destFolder) {
-      if (!destFolder.permissions) {
-        throw new TypeError(
-          "Resource model calculatePermissionsChangesForMove requires destination permissions to be set.",
-        );
-      }
-      permissionsFromParent = destFolder.permissions.cloneForAco(PermissionEntity.ACO_RESOURCE, resource.id, false);
-    }
-
-    const newPermissions = PermissionsCollection.sum(remainingPermissions, permissionsFromParent, false);
-    if (!destFolder) {
-      /*
-       * If the move is toward the root
-       * Reuse highest permission
-       */
-      newPermissions.addOrReplace(
-        new PermissionEntity({
-          aco: PermissionEntity.ACO_RESOURCE,
-          aro: resource.permission.aro,
-          aco_foreign_key: resource.id,
-          aro_foreign_key: resource.permission.aroForeignKey,
-          type: PermissionEntity.PERMISSION_OWNER,
-        }),
-      );
-    }
-    newPermissions.assertAtLeastOneOwner();
-    return PermissionChangesCollection.calculateChanges(resource.permissions, newPermissions);
-  }
-
   /**
    * Calculate permission changes for a create
    * From current permissions add the destination permissions

package/src/all/background_page/model/setup/setupModel.js

@@ -11,7 +11,7 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  */
 import AccountRecoveryOrganizationPolicyEntity from "../entity/accountRecovery/accountRecoveryOrganizationPolicyEntity";
-import UserService from "../../service/api/user/userService";
+import UserApiService from "passbolt-styleguide/src/shared/services/api/user/userApiService";
 import SetupService from "../../service/api/setup/setupService";
 import UserEntity from "../entity/user/userEntity";
 import Validator from "validator";
@@ -26,7 +26,7 @@ class SetupModel {
    */
   constructor(apiClientOptions) {
     this.setupService = new SetupService(apiClientOptions);
-    this.userService = new UserService(apiClientOptions);
+    this.userService = new UserApiService(apiClientOptions);
   }
 
   /**

package/src/all/background_page/model/user/userModel.js

@@ -12,9 +12,9 @@
  * @since         3.0.0
  */
 import UserLocalStorage from "../../service/local_storage/userLocalStorage";
-import UserService from "../../service/api/user/userService";
+import UserApiService from "passbolt-styleguide/src/shared/services/api/user/userApiService";
 import UserEntity from "../entity/user/userEntity";
-import UsersCollection from "../entity/user/usersCollection";
+import UsersCollection from "passbolt-styleguide/src/shared/models/entity/user/usersCollection";
 import Validator from "validator";
 import RoleEntity from "passbolt-styleguide/src/shared/models/entity/role/roleEntity";
 import UserMeSessionStorageService from "../../service/sessionStorage/userMeSessionStorageService";
@@ -32,7 +32,7 @@ class UserModel {
    * @public
    */
   constructor(apiClientOptions, account = null) {
-    this.userService = new UserService(apiClientOptions);
+    this.userApiService = new UserApiService(apiClientOptions);
     this.organisationSettingsModel = new OrganizationSettingsModel(apiClientOptions);
     this.account = account;
   }
@@ -62,7 +62,7 @@ class UserModel {
         contains.missing_metadata_key_ids = true;
       }
     }
-    const usersCollection = await this.findAll(contains, null, null, true);
+    const usersCollection = await this.findAll(contains, null, true);
     await UserLocalStorage.set(usersCollection);
     return usersCollection;
   }
@@ -75,7 +75,7 @@ class UserModel {
    * @public
    */
   async resendInvite(username) {
-    return this.userService.resendInvite(username);
+    return this.userApiService.resendInvite(username);
   }
 
   /**
@@ -128,7 +128,7 @@ class UserModel {
    * @returns {Promise<UserEntity>}
    */
   async findOne(userId, contains, ignoreInvalidEntity) {
-    const userDto = await this.userService.get(userId, contains);
+    const userDto = await this.userApiService.get(userId, contains);
     return new UserEntity(userDto, { ignoreInvalidEntity: ignoreInvalidEntity });
   }
 
@@ -137,12 +137,11 @@ class UserModel {
    *
    * @param {Object} [contains] optional example: {groups_users: true}
    * @param {Object} [filters] optional
-   * @param {Object} [orders] optional
    * @param {boolean?} [ignoreInvalidEntity] Should invalid entities be ignored.
    * @returns {Promise<UsersCollection>}
    */
-  async findAll(contains, filters, orders, ignoreInvalidEntity) {
-    const usersDto = await this.userService.findAll(contains, filters, orders);
+  async findAll(contains, filters, ignoreInvalidEntity) {
+    const usersDto = (await this.userApiService.findAll(contains, filters)).body ?? [];
     return new UsersCollection(usersDto, { clone: false, ignoreInvalidEntity: ignoreInvalidEntity });
   }
 
@@ -157,9 +156,9 @@ class UserModel {
     if (!Validator.isUUID(userId)) {
       throw new TypeError("Error in find all users for users updates. The user id is not a valid uuid.");
     }
-    const usersDto = await this.userService.findAll(null, { "has-access": userId });
+    const usersDto = (await this.userApiService.findAll(null, { "has-access": userId })).body ?? [];
     const usersCollection = new UsersCollection(usersDto);
-    return usersCollection.ids;
+    return usersCollection.extract("id");
   }
 
   /*
@@ -176,7 +175,7 @@ class UserModel {
    */
   async create(userEntity) {
     const data = userEntity.toDto({ profile: { avatar: false } });
-    const userDto = await this.userService.create(data);
+    const userDto = await this.userApiService.create(data);
     const newUserEntity = new UserEntity(userDto);
     await UserLocalStorage.addUser(newUserEntity);
     return newUserEntity;
@@ -192,7 +191,7 @@ class UserModel {
    */
   async update(userEntity, ignoreInvalidEntity) {
     const data = userEntity.toDto({ profile: { avatar: false } });
-    const userDto = await this.userService.update(userEntity.id, data);
+    const userDto = await this.userApiService.update(userEntity.id, data);
     const updatedUserEntity = new UserEntity(userDto, { ignoreInvalidEntity });
     await UserLocalStorage.updateUser(updatedUserEntity);
     return updatedUserEntity;
@@ -208,7 +207,11 @@ class UserModel {
    * @public
    */
   async updateAvatar(userId, avatarUpdateEntity, ignoreInvalidEntity) {
-    const userDto = await this.userService.updateAvatar(userId, avatarUpdateEntity.file, avatarUpdateEntity.filename);
+    const userDto = await this.userApiService.updateAvatar(
+      userId,
+      avatarUpdateEntity.file,
+      avatarUpdateEntity.filename,
+    );
     return new UserEntity(userDto, { ignoreInvalidEntity });
   }
 
@@ -222,7 +225,7 @@ class UserModel {
       username: account.username,
       case: "lost-passphrase",
     };
-    await this.userService.requestHelpCredentialsLost(requestHelpDto);
+    await this.userApiService.requestHelpCredentialsLost(requestHelpDto);
   }
 }
 

package/src/all/background_page/model/user/userModel.test.js

@@ -169,7 +169,6 @@ describe("UserModel", () => {
           profile: true,
         },
         null,
-        null,
         true,
       );
     });
@@ -218,7 +217,6 @@ describe("UserModel", () => {
           profile: true,
         },
         null,
-        null,
         true,
       );
     });
@@ -431,7 +429,7 @@ describe("UserModel", () => {
 
       const apiClientOption = defaultApiClientOptions();
       const model = new UserModel(apiClientOption);
-      const collection = await model.findAll({}, {}, {}, true);
+      const collection = await model.findAll({}, {}, true);
 
       expect(collection).toHaveLength(3);
       expect(collection.items[0]._props.id).toEqual(dto1.id);

package/src/all/background_page/service/api/abstract/abstractService.js

@@ -13,6 +13,9 @@
 import { ApiClient } from "passbolt-styleguide/src/shared/lib/apiClient/apiClient";
 import Validator from "validator";
 
+/**
+ * @deprecated: to be replaced with AbstractService from the styleguide
+ */
 class AbstractService {
   /**
    *
@@ -75,23 +78,6 @@ class AbstractService {
     return result;
   }
 
-  /**
-   * Format contain orders
-   *
-   * @param {object} orders example: {"orders": ['Resources.name ASC']}
-   * @param {array} supportedOrders example: ['Resources.name ASC', 'Resources.name DESC']
-   * @returns {object} to be used in API request
-   */
-  formatOrderOptions(orders, supportedOrders) {
-    const result = {};
-    for (const order in orders) {
-      if (supportedOrders.includes(order)) {
-        result[`order[]`] = order;
-      }
-    }
-    return result;
-  }
-
   /**
    * Assert that an id is a valid uuid or throw a TypeError
    *

package/src/all/background_page/service/api/edition/passboltEditionApiService.js

@@ -0,0 +1,64 @@
+/**
+ * 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.13.0
+ */
+
+import AbstractService from "../abstract/abstractService";
+
+export const PASSBOLT_EDITION_API_SERVICE_RESOURCE_NAME = "edition/subscription/key";
+
+class PassboltEditionApiService extends AbstractService {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    super(apiClientOptions, PassboltEditionApiService.RESOURCE_NAME);
+  }
+
+  /**
+   * API Resource Name
+   *
+   * @returns {string}
+   * @public
+   */
+  static get RESOURCE_NAME() {
+    return PASSBOLT_EDITION_API_SERVICE_RESOURCE_NAME;
+  }
+
+  /**
+   * Create the subscription on the API (upgrade CE to PRO).
+   *
+   * @param {Object} keyDto the new subscription key dto
+   * @throws {Error} if API call fails, service unreachable, etc.
+   * @returns {Promise<Object>} subscriptionDto
+   */
+  async create(keyDto) {
+    const response = await this.apiClient.create(keyDto);
+    return response.body;
+  }
+
+  /**
+   * Delete the subscription on the API (downgrade PRO to CE).
+   *
+   * @throws {Error} if API call fails, service unreachable, etc.
+   * @returns {Promise<void>}
+   */
+  async delete() {
+    const url = this.apiClient.buildUrl(this.apiClient.baseUrl.toString());
+    await this.apiClient.fetchAndHandleResponse("DELETE", url);
+  }
+}
+
+export default PassboltEditionApiService;

package/src/all/background_page/service/api/edition/passboltEditionApiService.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.13.0
+ */
+
+import { enableFetchMocks } from "jest-fetch-mock";
+
+import PassboltBadResponseError from "passbolt-styleguide/src/shared/lib/Error/PassboltBadResponseError";
+import SubscriptionEntity from "passbolt-styleguide/src/shared/models/entity/subscription/subscriptionEntity";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import { mockSubscriptionUpdated } from "passbolt-styleguide/src/react-extension/components/Administration/DisplaySubscriptionKey/DisplaySubscriptionKey.test.data";
+
+import { mockApiResponse } from "../../../../../../test/mocks/mockApiResponse";
+import PassboltEditionApiService, { PASSBOLT_EDITION_API_SERVICE_RESOURCE_NAME } from "./passboltEditionApiService";
+
+describe("PassboltEditionApiService", () => {
+  /**
+   * @type {PassboltEditionApiService}
+   */
+  let service;
+
+  beforeEach(() => {
+    enableFetchMocks();
+    fetch.resetMocks();
+    service = new PassboltEditionApiService(defaultApiClientOptions());
+  });
+
+  it("Should return the expected resource name", () => {
+    expect(PassboltEditionApiService.RESOURCE_NAME).toEqual(PASSBOLT_EDITION_API_SERVICE_RESOURCE_NAME);
+  });
+
+  describe("::create", () => {
+    it("Should POST the subscription key and return the response", async () => {
+      expect.assertions(4);
+
+      const subscriptionEntity = new SubscriptionEntity(mockSubscriptionUpdated);
+
+      fetch.doMockOnceIf(new RegExp(`/${PASSBOLT_EDITION_API_SERVICE_RESOURCE_NAME}\\.json`), async () =>
+        mockApiResponse(subscriptionEntity),
+      );
+
+      const result = await service.create({ data: mockSubscriptionUpdated.data });
+
+      expect(fetch).toHaveBeenCalledTimes(1);
+
+      const { method, body } = fetch.mock.calls[0][1];
+      expect(method).toEqual("POST");
+      expect(JSON.parse(body).data).toEqual(mockSubscriptionUpdated.data);
+
+      expect(result).toEqual(subscriptionEntity.toDto());
+    });
+
+    it("Should throw an error if the response is not properly formatted", async () => {
+      expect.assertions(2);
+
+      fetch.doMockOnceIf(new RegExp(`/${PASSBOLT_EDITION_API_SERVICE_RESOURCE_NAME}\\.json`), async () => "wrong");
+
+      await expect(service.create({ data: mockSubscriptionUpdated.data })).rejects.toBeInstanceOf(
+        PassboltBadResponseError,
+      );
+
+      expect(fetch).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("::delete", () => {
+    it("Should DELETE the subscription key and resolve", async () => {
+      expect.assertions(3);
+
+      fetch.doMockOnceIf(new RegExp(`/${PASSBOLT_EDITION_API_SERVICE_RESOURCE_NAME}\\.json`), async () =>
+        mockApiResponse({}),
+      );
+
+      await expect(service.delete()).resolves.not.toThrow();
+
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(fetch.mock.calls[0][1].method).toEqual("DELETE");
+    });
+
+    it("Should throw an error if the response is not properly formatted", async () => {
+      expect.assertions(2);
+
+      fetch.doMockOnceIf(new RegExp(`/${PASSBOLT_EDITION_API_SERVICE_RESOURCE_NAME}\\.json`), async () => "wrong");
+
+      await expect(service.delete()).rejects.toBeInstanceOf(PassboltBadResponseError);
+
+      expect(fetch).toHaveBeenCalledTimes(1);
+    });
+  });
+});