passbolt-browser-extension 5.3.2 → 5.4.1

package/src/all/background_page/controller/import/importResourcesFileController.test.js

@@ -219,7 +219,7 @@ describe("ImportResourcesFileController", () => {
             id: importedResources[0].id,
             name: 'Password 1',
             username: 'username1',
-            uri: 'https://url1.com',
+            uris: ['https://url1.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[0].folderParentPath,
             folder_parent_path_expected: "/Root/Folder 1/Folder 2",
@@ -229,7 +229,7 @@ describe("ImportResourcesFileController", () => {
             id: importedResources[1].id,
             name: 'Password 2',
             username: 'username2',
-            uri: 'https://url2.com',
+            uris: ['https://url2.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[1].folderParentPath,
             folder_parent_path_expected: "/Root/Folder 1",
@@ -239,7 +239,7 @@ describe("ImportResourcesFileController", () => {
             id: importedResources[2].id,
             name: 'Password 4',
             username: 'username4',
-            uri: 'https://url4.com',
+            uris: ['https://url4.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[2].folderParentPath,
             folder_parent_path_expected: "/Root/Folder 2/Folder 1",
@@ -249,7 +249,7 @@ describe("ImportResourcesFileController", () => {
             id: importedResources[3].id,
             name: 'Password 3',
             username: 'username3',
-            uri: 'https://url3.com',
+            uris: ['https://url3.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[3].folderParentPath,
             folder_parent_path_expected: "/Root/Folder 3/Folder 4",
@@ -292,7 +292,7 @@ describe("ImportResourcesFileController", () => {
             id: importedResources[0].id,
             name: 'Password 1',
             username: 'username1',
-            uri: 'https://url1.com',
+            uris: ['https://url1.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[0].folderParentPath,
             folder_parent_path_expected: "/Root",
@@ -329,7 +329,7 @@ describe("ImportResourcesFileController", () => {
             id: importedResources[0].id,
             name: 'Password 1',
             username: 'username1',
-            uri: 'https://url1.com',
+            uris: ['https://url1.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[0].folderParentPath,
             folder_parent_path_expected: "/Root",
@@ -393,7 +393,7 @@ describe("ImportResourcesFileController", () => {
             id: importedResources[0].id,
             name: 'Password 1',
             username: 'Username 1',
-            uri: 'https://url1.com',
+            uris: ['https://url1.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[0].folderParentPath,
             folder_parent_path_expected: ""
@@ -464,7 +464,7 @@ describe("ImportResourcesFileController", () => {
             id: importedResources[0].id,
             name: 'Password 1',
             username: 'Username 1',
-            uri: 'https://url1.com',
+            uris: ['https://url1.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[0].folderParentPath,
           }));
@@ -487,18 +487,6 @@ describe("ImportResourcesFileController", () => {
           metadataTypesSettings: defaultMetadataTypesSettingsV50FreshDto(),
           resourceType: RESOURCE_TYPE_V5_DEFAULT_SLUG
         },
-        {
-          scenario: "bitwarden",
-          file: bitwardenCsvFile,
-          metadataTypesSettings: defaultMetadataTypesSettingsV4Dto(),
-          resourceType: RESOURCE_TYPE_PASSWORD_AND_DESCRIPTION_SLUG
-        },
-        {
-          scenario: "bitwarden",
-          file: bitwardenCsvFile,
-          metadataTypesSettings: defaultMetadataTypesSettingsV50FreshDto(),
-          resourceType: RESOURCE_TYPE_V5_DEFAULT_SLUG
-        },
         {
           scenario: "lastpass", file: lastpassCsvFile,
           metadataTypesSettings: defaultMetadataTypesSettingsV4Dto(),
@@ -545,7 +533,7 @@ describe("ImportResourcesFileController", () => {
             id: importedResources[0].id,
             name: 'Password 1',
             username: 'Username 1',
-            uri: 'https://url1.com',
+            uris: ['https://url1.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[0].folderParentPath,
             folder_parent_path_expected: "/Folder 1"
@@ -571,6 +559,18 @@ describe("ImportResourcesFileController", () => {
           metadataTypesSettings: defaultMetadataTypesSettingsV50FreshDto(),
           resourceType: RESOURCE_TYPE_V5_DEFAULT_TOTP_SLUG
         },
+        {
+          scenario: "bitwarden",
+          file: bitwardenCsvFile,
+          metadataTypesSettings: defaultMetadataTypesSettingsV4Dto(),
+          resourceType: RESOURCE_TYPE_PASSWORD_DESCRIPTION_TOTP_SLUG
+        },
+        {
+          scenario: "bitwarden",
+          file: bitwardenCsvFile,
+          metadataTypesSettings: defaultMetadataTypesSettingsV50FreshDto(),
+          resourceType: RESOURCE_TYPE_V5_DEFAULT_TOTP_SLUG
+        },
       ]).describe("Should parse keypass with description, folder and totp", test => {
         beforeEach(() => {
           jest.spyOn(GetOrFindMetadataSettingsService.prototype, "getOrFindTypesSettings")
@@ -588,13 +588,13 @@ describe("ImportResourcesFileController", () => {
           const expectedResourceType = collection.find(resourceType =>  resourceType.slug === test.resourceType);
           const secret1 = await decryptSecret(result.importResources.items[0].secrets.items[0].data, pgpKeys.ada.private, pgpKeys.ada.passphrase);
 
-          expect(secret1).toEqual("{\"password\":\"Secret 1\",\"description\":\"Description 1\",\"totp\":{\"secret_key\":\"THISISASECRET\",\"period\":30,\"digits\":6,\"algorithm\":\"SHA1\"}}");
+          expect(secret1).toEqual("{\"password\":\"Password 1\",\"description\":\"Description 1\",\"totp\":{\"secret_key\":\"THISISASECRET\",\"period\":30,\"digits\":6,\"algorithm\":\"SHA1\"}}");
 
           const externalEntity1 = new ExternalResourceEntity(defaultExternalResourceImportMinimalDto({
             id: importedResources[0].id,
             name: 'Password 1',
             username: 'Username 1',
-            uri: 'https://url1.com',
+            uris: ['https://url1.com'],
             resource_type_id: expectedResourceType.id,
             folder_parent_path: importedResources[0].folderParentPath,
             folder_parent_path_expected: "/Folder 1"

package/src/all/background_page/controller/metadata/enableEncryptedMetadataForExistingInstanceController.js

@@ -0,0 +1,54 @@
+/**
+ * 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 ConfigureMetadataSettingsService from "../../service/metadata/configureMetadataSettingsService";
+import GetPassphraseService from "../../service/passphrase/getPassphraseService";
+
+export default class EnableEncryptedMetadataForExistingInstanceController {
+  /**
+   * @constructor
+   * @param {Worker} worker
+   * @param {string} requestId
+   * @param {ApiClientOptions} apiClientOptions the api client options
+   * @param {AccountEntity} account the account associated to the worker
+   */
+  constructor(worker, requestId, apiClientOptions, account) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.configureMetadataSettingsService = new ConfigureMetadataSettingsService(account, apiClientOptions);
+    this.getPassphraseService = new GetPassphraseService(account);
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<void>}
+   */
+  async _exec() {
+    try {
+      const result = await this.exec();
+      this.worker.port.emit(this.requestId, 'SUCCESS', result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Run the process to enable metadata encryption
+   * @returns {Promise<void>}
+   */
+  async exec() {
+    const passphrase = await this.getPassphraseService.getPassphrase(this.worker);
+    return await this.configureMetadataSettingsService.enableEncryptedMetadataForExistingInstance(passphrase);
+  }
+}

package/src/all/background_page/controller/metadata/enableEncryptedMetadataForExistingInstanceController.test.js

@@ -0,0 +1,54 @@
+/**
+ * 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 AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import BuildApiClientOptionsService from "../../service/account/buildApiClientOptionsService";
+import PassphraseStorageService from "../../service/session_storage/passphraseStorageService";
+import EnableEncryptedMetadataForExistingInstanceController from "./enableEncryptedMetadataForExistingInstanceController";
+
+describe("EnableEncryptedMetadataForExistingInstanceController", () => {
+  describe("::exec", () => {
+    it("should call for the orchestrator to enable metadata", async() => {
+      expect.assertions(3);
+
+      const passphrase = "ada@passbolt.com";
+      await PassphraseStorageService.set(passphrase);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+      const controller = new EnableEncryptedMetadataForExistingInstanceController(null, null, apiClientOptions, account);
+      jest.spyOn(controller.getPassphraseService, "getPassphrase");
+      jest.spyOn(controller.configureMetadataSettingsService, "enableEncryptedMetadataForExistingInstance").mockImplementation(() => {});
+
+      await controller.exec();
+
+      expect(controller.getPassphraseService.getPassphrase).toHaveBeenCalledTimes(1);
+      expect(controller.configureMetadataSettingsService.enableEncryptedMetadataForExistingInstance).toHaveBeenCalledTimes(1);
+      expect(controller.configureMetadataSettingsService.enableEncryptedMetadataForExistingInstance).toHaveBeenCalledWith(passphrase);
+    });
+
+    it("should not intercept unexpected error if something goes wrong when enabling the metadata encryption", async() => {
+      expect.assertions(1);
+
+      const passphrase = "ada@passbolt.com";
+      await PassphraseStorageService.set(passphrase);
+      const account = new AccountEntity(defaultAccountDto());
+      const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+      const controller = new EnableEncryptedMetadataForExistingInstanceController(null, null, apiClientOptions, account);
+      jest.spyOn(controller.configureMetadataSettingsService, "enableEncryptedMetadataForExistingInstance").mockImplementation(() => { throw new Error("Something went wrong!"); });
+
+      await expect(() => controller.exec()).rejects.toThrowError("Something went wrong!");
+    });
+  });
+});

package/src/all/background_page/controller/metadata/enableMetadataSetupSettingsController.js

@@ -0,0 +1,54 @@
+/**
+ * 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 ConfigureMetadataSettingsService from "../../service/metadata/configureMetadataSettingsService";
+import GetPassphraseService from "../../service/passphrase/getPassphraseService";
+
+export default class EnableMetadataSetupSettingsController {
+  /**
+   * @constructor
+   * @param {Worker} worker
+   * @param {string} requestId
+   * @param {ApiClientOptions} apiClientOptions the api client options
+   * @param {AccountEntity} account the account associated to the worker
+   */
+  constructor(worker, requestId, apiClientOptions, account) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.configureMetadataSettingsService = new ConfigureMetadataSettingsService(account, apiClientOptions);
+    this.getPassphraseService = new GetPassphraseService(account);
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<void>}
+   */
+  async _exec() {
+    try {
+      const result = await this.exec();
+      this.worker.port.emit(this.requestId, 'SUCCESS', result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Run the process to enable metadata encryption
+   * @returns {Promise<void>}
+   */
+  async exec() {
+    const passphrase = await this.getPassphraseService.getFromStorageOrFail();
+    return await this.configureMetadataSettingsService.enableEncryptedMetadataForNewInstance(passphrase);
+  }
+}

package/src/all/background_page/controller/metadata/enableMetadataSetupSettingsController.test.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.4.0
+ */
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import BuildApiClientOptionsService from "../../service/account/buildApiClientOptionsService";
+import PassphraseStorageService from "../../service/session_storage/passphraseStorageService";
+import EnableMetadataSetupSettingsController from "./enableMetadataSetupSettingsController";
+
+describe("EnableMetadataSetupSettingsController", () => {
+  describe("::exec", () => {
+    it("should call for the orchestrator to enable metadata", async() => {
+      expect.assertions(3);
+
+      const passphrase = "ada@passbolt.com";
+      await PassphraseStorageService.set(passphrase);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+      const controller = new EnableMetadataSetupSettingsController(null, null, apiClientOptions, account);
+      jest.spyOn(controller.getPassphraseService, "getFromStorageOrFail");
+      jest.spyOn(controller.configureMetadataSettingsService, "enableEncryptedMetadataForNewInstance").mockImplementation(() => {});
+
+      await controller.exec();
+
+      expect(controller.getPassphraseService.getFromStorageOrFail).toHaveBeenCalledTimes(1);
+      expect(controller.configureMetadataSettingsService.enableEncryptedMetadataForNewInstance).toHaveBeenCalledTimes(1);
+      expect(controller.configureMetadataSettingsService.enableEncryptedMetadataForNewInstance).toHaveBeenCalledWith(passphrase);
+    });
+
+    it("should throw an error if the passphrase is not available in the session storage", async() => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+      const controller = new EnableMetadataSetupSettingsController(null, null, apiClientOptions, account);
+
+      await expect(() => controller.exec()).rejects.toThrowError("No passphrase found in the session storage.");
+    });
+
+    it("should not intercept unexpected error if something goes wrong when enabling the metadata encryption", async() => {
+      expect.assertions(1);
+
+      const passphrase = "ada@passbolt.com";
+      await PassphraseStorageService.set(passphrase);
+      const account = new AccountEntity(defaultAccountDto());
+      const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+      const controller = new EnableMetadataSetupSettingsController(null, null, apiClientOptions, account);
+      jest.spyOn(controller.configureMetadataSettingsService, "enableEncryptedMetadataForNewInstance").mockImplementation(() => { throw new Error("Something went wrong!"); });
+
+      await expect(() => controller.exec()).rejects.toThrowError("Something went wrong!");
+    });
+  });
+});

package/src/all/background_page/controller/metadata/findAllNonDeletedMetadataKeysController.js

@@ -20,12 +20,11 @@ class FindAllNonDeletedMetadataKeysController {
    * @param {Worker} worker
    * @param {string} requestId
    * @param {ApiClientOptions} apiClientOptions the api client options
-   * @param {AccountEntity} account the user account
    */
-  constructor(worker, requestId, apiClientOptions, account) {
+  constructor(worker, requestId, apiClientOptions) {
     this.worker = worker;
     this.requestId = requestId;
-    this.findMetadataKeysService = new FindMetadataKeysService(apiClientOptions, account);
+    this.findMetadataKeysService = new FindMetadataKeysService(apiClientOptions);
   }
 
   /**

package/src/all/background_page/controller/metadata/findMetadataGettingStartedSettingsController.js

@@ -0,0 +1,50 @@
+/**
+ * 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 FindMetadataGettingStartedSettingsService from "passbolt-styleguide/src/shared/services/metadata/findMetadataGettingStartedSettingsService";
+
+export default class FindMetadataGettingStartedSettingsController {
+  /**
+   * @constructor
+   * @param {Worker} worker
+   * @param {string} requestId
+   * @param {ApiClientOptions} apiClientOptions the api client options
+   */
+  constructor(worker, requestId, apiClientOptions) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.findMetadataGettingStartedSettingsService = new FindMetadataGettingStartedSettingsService(apiClientOptions);
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<void>}
+   */
+  async _exec() {
+    try {
+      const result = await this.exec();
+      this.worker.port.emit(this.requestId, 'SUCCESS', result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Find the metadata getting started settings.
+   * @returns {Promise<MetadataGettingStartedSettingsEntity>}
+   */
+  async exec() {
+    return await this.findMetadataGettingStartedSettingsService.findGettingStartedSettings();
+  }
+}

package/src/all/background_page/controller/metadata/findMetadataGettingStartedSettingsController.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.4.0
+ */
+import FindMetadataGettingStartedSettingsController from "./findMetadataGettingStartedSettingsController";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import MetadataGettingStartedSettingsEntity from "passbolt-styleguide/src/shared/models/entity/metadata/metadataGettingStartedSettingsEntity";
+import {enableMetadataGettingStartedSettingsDto} from "passbolt-styleguide/src/shared/models/entity/metadata/metadataGettingStartedSettingsEntity.test.data";
+
+describe("FindMetadataGettingStartedSettingsController", () => {
+  describe("::exec", () => {
+    it("find metadata keys settings and update session storage.", async() => {
+      expect.assertions(1);
+
+      const expectedResult = new MetadataGettingStartedSettingsEntity(enableMetadataGettingStartedSettingsDto());
+      const controller = new FindMetadataGettingStartedSettingsController(null, null, defaultApiClientOptions());
+      jest.spyOn(controller.findMetadataGettingStartedSettingsService, "findGettingStartedSettings").mockImplementation(() => expectedResult);
+
+      const result = await controller.exec();
+
+      expect(result).toStrictEqual(expectedResult);
+    });
+  });
+});

package/src/all/background_page/controller/metadata/findMetadataSetupSettingsController.js

@@ -0,0 +1,50 @@
+/**
+ * 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 FindMetadataSetupSettingsService from "../../service/metadata/findMetadataSetupSettingsService";
+
+export default class FindMetadataSetupSettingsController {
+  /**
+   * @constructor
+   * @param {Worker} worker
+   * @param {string} requestId
+   * @param {ApiClientOptions} apiClientOptions the api client options
+   */
+  constructor(worker, requestId, apiClientOptions) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.findMetadataSetupSettingsService = new FindMetadataSetupSettingsService(apiClientOptions);
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<void>}
+   */
+  async _exec() {
+    try {
+      const result = await this.exec();
+      this.worker.port.emit(this.requestId, 'SUCCESS', result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Find the metadata keys settings entity and update the session storage.
+   * @returns {Promise<MetadataSetupSettingsEntity>}
+   */
+  async exec() {
+    return await this.findMetadataSetupSettingsService.findSetupSettings();
+  }
+}

package/src/all/background_page/controller/metadata/findMetadataSetupSettingsController.test.js

@@ -0,0 +1,42 @@
+/**
+ * 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 FindMetadataSetupSettingsController from "./findMetadataSetupSettingsController";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import MetadataSetupSettingsEntity from "passbolt-styleguide/src/shared/models/entity/metadata/metadataSetupSettingsEntity";
+import {enableMetadataSetupSettingsDto} from "passbolt-styleguide/src/shared/models/entity/metadata/metadataSetupSettingsEntity.test.data";
+
+describe("FindMetadataSetupSettingsController", () => {
+  describe("::exec", () => {
+    it("find metadata keys settings and update session storage.", async() => {
+      expect.assertions(1);
+
+      const expectedResult = new MetadataSetupSettingsEntity(enableMetadataSetupSettingsDto());
+      const controller = new FindMetadataSetupSettingsController(null, null, defaultApiClientOptions());
+      jest.spyOn(controller.findMetadataSetupSettingsService, "findSetupSettings").mockImplementation(() => expectedResult);
+
+      const result = await controller.exec();
+
+      expect(result).toStrictEqual(expectedResult);
+    });
+
+    it("should not intercept unexpected error.", async() => {
+      expect.assertions(1);
+
+      const controller = new FindMetadataSetupSettingsController(null, null, defaultApiClientOptions());
+      jest.spyOn(controller.findMetadataSetupSettingsService, "findSetupSettings").mockImplementation(() => { throw new Error("Something went wrong!"); });
+
+      await expect(() => controller.exec()).rejects.toThrowError();
+    });
+  });
+});

package/src/all/background_page/controller/metadata/keepCleartextMetadataForExistingInstanceController.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.4.0
+ */
+import ConfigureMetadataSettingsService from "../../service/metadata/configureMetadataSettingsService";
+
+export default class KeepCleartextMetadataForExistingInstanceController {
+  /**
+   * @constructor
+   * @param {Worker} worker
+   * @param {string} requestId
+   * @param {ApiClientOptions} apiClientOptions the api client options
+   * @param {AccountEntity} account the account associated to the worker
+   */
+  constructor(worker, requestId, apiClientOptions, account) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.configureMetadataSettingsService = new ConfigureMetadataSettingsService(account, apiClientOptions);
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<void>}
+   */
+  async _exec() {
+    try {
+      const result = await this.exec();
+      this.worker.port.emit(this.requestId, 'SUCCESS', result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Run the process to keep legacy metadata in cleartext
+   * @returns {Promise<void>}
+   */
+  async exec() {
+    return await this.configureMetadataSettingsService.keepCleartextMetadataForExistingInstance();
+  }
+}

package/src/all/background_page/controller/metadata/keepCleartextMetadataForExistingInstanceController.test.js

@@ -0,0 +1,47 @@
+/**
+ * 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 AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import BuildApiClientOptionsService from "../../service/account/buildApiClientOptionsService";
+import KeepCleartextMetadataForExistingInstanceController from "./keepCleartextMetadataForExistingInstanceController";
+
+describe("KeepCleartextMetadataForExistingInstanceController", () => {
+  describe("::exec", () => {
+    it("should call for the orchestrator not to enable metadata encryption", async() => {
+      expect.assertions(2);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+      const controller = new KeepCleartextMetadataForExistingInstanceController(null, null, apiClientOptions, account);
+
+      jest.spyOn(controller.configureMetadataSettingsService, "keepCleartextMetadataForExistingInstance").mockImplementation(() => {});
+
+      await controller.exec();
+
+      expect(controller.configureMetadataSettingsService.keepCleartextMetadataForExistingInstance).toHaveBeenCalledTimes(1);
+      expect(controller.configureMetadataSettingsService.keepCleartextMetadataForExistingInstance).toHaveBeenCalledWith();
+    });
+
+    it("should not intercept unexpected error if something goes wrong when enabling the metadata encryption", async() => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+      const controller = new KeepCleartextMetadataForExistingInstanceController(null, null, apiClientOptions, account);
+      jest.spyOn(controller.configureMetadataSettingsService, "keepCleartextMetadataForExistingInstance").mockImplementation(() => { throw new Error("Something went wrong!"); });
+
+      await expect(() => controller.exec()).rejects.toThrowError("Something went wrong!");
+    });
+  });
+});