passbolt-browser-extension 3.0.6 → 4.6.2

package/test/jest-webextension-force-runtime-id-setup-files.js

@@ -0,0 +1,5 @@
+/*
+ * Fix jest-webextension-mock after upgrading webextension-polyfill to 0.9.0
+ * @see https://github.com/clarkbw/jest-webextension-mock/issues/149#issuecomment-1116558554
+ */
+browser.runtime.id = "test id";

package/{.jest.custom-kdbx-environment.js → test/jest.custom-kdbx-environment.js}

@@ -1,4 +1,4 @@
-const NodeEnvironment = require('jest-environment-node')
+import NodeEnvironment from "jest-environment-node";
 
 class JestCustomKdbxEnvironment extends NodeEnvironment {
   constructor(config) {
@@ -9,20 +9,8 @@ class JestCustomKdbxEnvironment extends NodeEnvironment {
         Uint8Array: Uint8Array, // Node overrides this primitive making impossible to test the kdbx parsers
         ArrayBuffer: ArrayBuffer
       }
-    })
-  }
-
-  async setup() {
-    await super.setup()
-  }
-
-  async teardown() {
-    await super.teardown()
-  }
-
-  runScript(script) {
-    return super.runScript(script)
+    });
   }
 }
 
-module.exports = JestCustomKdbxEnvironment
+export default JestCustomKdbxEnvironment;

package/test/jest.setup.js

@@ -0,0 +1,60 @@
+/**
+ * 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         3.6.0
+ */
+
+import "./mocks/mockWebExtensionPolyfill";
+import browser from "../src/all/common/polyfill/browserPolyfill";
+import "./mocks/mockTextEncoder";
+import "./matchers/extendExpect";
+import MockNavigatorLocks from './mocks/mockNavigatorLocks';
+import OrganizationSettingsModel from "../src/all/background_page/model/organizationSettings/organizationSettingsModel";
+import {Config} from "../src/all/background_page/model/config";
+import Keyring from "../src/all/background_page/model/keyring";
+
+global.console = {
+  ...console,
+  debug: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn()
+};
+global.fetch = require('node-fetch');
+if (!global.navigator) {
+  global.navigator = {};
+}
+if (!global.navigator.locks) {
+  global.navigator.locks = new MockNavigatorLocks();
+}
+
+/*
+ * quick polyfill for jest to have stucturedClone function defined
+ * if it's not defined, it is set to a function that returns the given object itself
+ */
+if (!global.structuredClone) {
+  global.structuredClone = object => object;
+}
+
+beforeEach(async() => {
+  // Before each test, ensure a new copy of the browser API is made available in the global scope.
+  global.browser = browser;
+  global.chrome = browser;
+  // Flush the local storage
+  await browser.storage.local.clear();
+  // Flush the session storage
+  await browser.storage.session.clear();
+  // Flush caches
+  OrganizationSettingsModel.flushCache();
+  Config.flush();
+  const keyring = new Keyring();
+  keyring.flush(Keyring.PUBLIC);
+  keyring.flush(Keyring.PRIVATE);
+});

package/test/matchers/extendExpect.js

@@ -0,0 +1,31 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+
+import {toThrowEntityValidationErrorOnProperties} from "./toThrowEntityValidationErrorOnProperties";
+import {toBeOpenpgpKeySignedBy} from "./toBeOpenpgpKeySignedBy";
+import {toBeOpenpgpPublicKey} from "./toBeOpenpgpPublicKey";
+import {toBeOpenpgpRevokedKey} from "./toBeOpenpgpRevokedKey";
+import {toBeEqualToOpenpgpKey} from "./toBeEqualToOpenpgpKey";
+import {toBeOpenpgpPrivateKey} from "./toBeOpenpgpPrivateKey";
+
+const extensions = {
+  toBeEqualToOpenpgpKey,
+  toBeOpenpgpKeySignedBy,
+  toBeOpenpgpPrivateKey,
+  toBeOpenpgpPublicKey,
+  toBeOpenpgpRevokedKey,
+  toThrowEntityValidationErrorOnProperties
+};
+
+expect.extend(extensions);

package/test/matchers/toBeEqualToOpenpgpKey.js

@@ -0,0 +1,46 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+import GetGpgKeyInfoService from "../../src/all/background_page/service/crypto/getGpgKeyInfoService";
+import {OpenpgpAssertion} from "../../src/all/background_page/utils/openpgp/openpgpAssertions";
+
+export const contains = (equals, list, value) => list.findIndex(item => equals(item, value)) > -1;
+
+exports.toBeEqualToOpenpgpKey = async function(armoredKeyA, armoredKeyB) {
+  const {printExpected, printReceived, matcherHint} = this.utils;
+  const keyA = await OpenpgpAssertion.readKeyOrFail(armoredKeyA);
+  const keyB = await OpenpgpAssertion.readKeyOrFail(armoredKeyB);
+  const keyAInfo = await GetGpgKeyInfoService.getKeyInfo(keyA);
+  const keyBInfo = await GetGpgKeyInfoService.getKeyInfo(keyB);
+
+  const passMessage =
+    `${matcherHint('.not.toBeEqualToOpenpgpKey')
+    }\n\n` +
+    `Expected validation to not fail on key:\n` +
+    `  ${printExpected(keyBInfo)}\n` +
+    `Received:\n` +
+    `  ${printReceived(keyAInfo)}`;
+
+  const failMessage =
+    `${matcherHint('.toBeEqualToOpenpgpKey')
+    }\n\n` +
+    `Expected validation to fail on key:\n` +
+    `  ${printExpected(keyBInfo)}\n` +
+    `Received:\n` +
+    `  ${printReceived(keyAInfo)}`;
+
+  const pass = keyAInfo.keyId === keyBInfo.keyId
+    && keyAInfo.fingerprint === keyBInfo.fingerprint;
+
+  return {pass: pass, message: () => (pass ? passMessage : failMessage)};
+};

package/test/matchers/toBeOpenpgpKeySignedBy.js

@@ -0,0 +1,42 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+
+import VerifyGpgKeyService from "../../src/all/background_page/service/crypto/verifyGpgKeyService";
+import {OpenpgpAssertion} from "../../src/all/background_page/utils/openpgp/openpgpAssertions";
+
+exports.toBeOpenpgpKeySignedBy = async function(armoredKey, armoredVerifyingKeys) {
+  const {printExpected, matcherHint} = this.utils;
+
+  const passMessage =
+    `${matcherHint('.not.toBeOpenpgpKeySignedBy')
+    }\n\n` +
+    `Expected validation not to verify signature(s):\n` +
+    `  ${printExpected(verifyingKeys)}\n`;
+
+  const failMessage =
+    `${matcherHint('.toBeOpenpgpKeySignedBy')
+    }\n\n` +
+    `Expected validation to verify signature(s):\n` +
+    `  ${printExpected(verifyingKeys)}\n`;
+
+  const key = await OpenpgpAssertion.readKeyOrFail(armoredKey);
+
+  if (!Array.isArray(armoredVerifyingKeys)) {
+    armoredVerifyingKeys = [armoredVerifyingKeys];
+  }
+  const verifyingKeys = await OpenpgpAssertion.readAllKeysOrFail(armoredVerifyingKeys);
+  const pass = await VerifyGpgKeyService.verify(key, verifyingKeys);
+
+  return {pass: pass, message: () => (pass ? passMessage : failMessage)};
+};

package/test/matchers/toBeOpenpgpPrivateKey.js

@@ -0,0 +1,34 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+
+import {OpenpgpAssertion} from "../../src/all/background_page/utils/openpgp/openpgpAssertions";
+
+exports.toBeOpenpgpPrivateKey = async function(armoredKey) {
+  const {matcherHint} = this.utils;
+
+  const passMessage =
+    `${matcherHint('.not.toBeOpenpgpPrivateKey')
+    }\n\n` +
+    `Expected key not to be private`;
+
+  const failMessage =
+    `${matcherHint('.toBeOpenpgpPrivateKey')
+    }\n\n` +
+    `Expected key to be private`;
+
+  const key = await OpenpgpAssertion.readKeyOrFail(armoredKey);
+  const pass = key.isPrivate();
+
+  return {pass: pass, message: () => (pass ? passMessage : failMessage)};
+};

package/test/matchers/toBeOpenpgpPublicKey.js

@@ -0,0 +1,34 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+
+import {OpenpgpAssertion} from "../../src/all/background_page/utils/openpgp/openpgpAssertions";
+
+exports.toBeOpenpgpPublicKey = async function(armoredKey) {
+  const {matcherHint} = this.utils;
+
+  const passMessage =
+    `${matcherHint('.not.toBeOpenpgpPublicKey')
+    }\n\n` +
+    `Expected key not to be public`;
+
+  const failMessage =
+    `${matcherHint('.toBeOpenpgpPublicKey')
+    }\n\n` +
+    `Expected key to be public`;
+
+  const key = await OpenpgpAssertion.readKeyOrFail(armoredKey);
+  const pass = !key.isPrivate();
+
+  return {pass: pass, message: () => (pass ? passMessage : failMessage)};
+};

package/test/matchers/toBeOpenpgpRevokedKey.js

@@ -0,0 +1,34 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+
+import {OpenpgpAssertion} from "../../src/all/background_page/utils/openpgp/openpgpAssertions";
+
+exports.toBeOpenpgpRevokedKey = async function(armoredKey) {
+  const {matcherHint} = this.utils;
+
+  const passMessage =
+    `${matcherHint('.not.toBeOpenpgpRevokedKey')
+    }\n\n` +
+    `Expected key not to be revoked`;
+
+  const failMessage =
+    `${matcherHint('.toBeOpenpgpRevokedKey')
+    }\n\n` +
+    `Expected key to be revoked`;
+
+  const key = await OpenpgpAssertion.readKeyOrFail(armoredKey);
+  const pass = await key.isRevoked();
+
+  return {pass: pass, message: () => (pass ? passMessage : failMessage)};
+};

package/test/matchers/toThrowEntityValidationErrorOnProperties.js

@@ -0,0 +1,41 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+
+export const contains = (equals, list, value) => list.findIndex(item => equals(item, value)) > -1;
+
+exports.toThrowEntityValidationErrorOnProperties = function(error, expected) {
+  const {printExpected, printReceived, matcherHint} = this.utils;
+  const actual = error.details || [];
+
+  const passMessage =
+    `${matcherHint('.not.toThrowEntityValidationErrorOnProperties')
+    }\n\n` +
+    `Expected validation to not fail on properties:\n` +
+    `  ${printExpected(expected)}\n` +
+    `Received:\n` +
+    `  ${printReceived(Object.keys(actual))}`;
+
+  const failMessage =
+    `${matcherHint('.toThrowEntityValidationErrorOnProperties')
+    }\n\n` +
+    `Expected validation to fail on properties:\n` +
+    `  ${printExpected(expected)}\n` +
+    `Received:\n` +
+    `  ${printReceived(Object.keys(actual))}`;
+
+  const objectKeys = Object.keys(actual);
+  const pass = objectKeys.length === expected.length && expected.every(key => contains(this.equals, objectKeys, key));
+
+  return {pass: pass, message: () => (pass ? passMessage : failMessage)};
+};

package/test/mocks/mockAlarms.js

@@ -0,0 +1,101 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.7.3
+ */
+
+/**
+ * Mock class to be used in replacement of chrome.alarms
+ * At the moment, only triggers an alarm once.
+ */
+class MockAlarms {
+  constructor() {
+    this._registeredAlarms = {};
+    this._timeouts = {};
+    this.onAlarm = new OnAlarmEvent();
+    this.onAlarm.triggerAlarm = this.onAlarm.triggerAlarm.bind(this);
+  }
+
+  async create(alarmName, options) {
+    const alarm = {
+      name: alarmName,
+      periodInMinutes: options.periodInMinutes,
+      scheduledTime: options.when || Date.now() + options.delayInMinutes * 1000 * 60,
+    };
+
+    this._registeredAlarms[alarmName] = alarm;
+    const timeout = setTimeout(() => this.onAlarm.triggerAlarm(alarm), alarm.scheduledTime - Date.now());
+    this._timeouts[alarmName] = timeout;
+  }
+
+  async get(alarmName) {
+    return this._registeredAlarms[alarmName] || null;
+  }
+
+  async getAll() {
+    const keys = Object.keys(this._registeredAlarms);
+    if (keys.length === 0) {
+      return [];
+    }
+
+    const alarms = [];
+    for (let i = 0; i < keys.length; i++) {
+      const alarm = this._registeredAlarms[keys[i]];
+      alarms.push(alarm);
+    }
+    return alarms;
+  }
+
+  async clear(alarmName) {
+    delete this._registeredAlarms[alarmName];
+  }
+
+  async clearAll() {
+    this._registeredAlarms = {};
+  }
+}
+
+class OnAlarmEvent {
+  constructor() {
+    this._listeners = [];
+    this.addListener = this.addListener.bind(this);
+    this.removeListener = this.removeListener.bind(this);
+    this.hasListener = this.hasListener.bind(this);
+    this.triggerAlarm = this.triggerAlarm.bind(this);
+  }
+  addListener(callback) {
+    //Remove duplicate listener for desktop app to avoid infinite loop
+    this.removeListener(callback);
+    this._listeners.push(callback);
+  }
+
+  removeListener(callback) {
+    if (!this.hasListener(callback)) {
+      return;
+    }
+    const index = this._listeners.indexOf(callback);
+    this._listeners.splice(index, 1);
+  }
+
+  hasListener(callback) {
+    const index = this._listeners.indexOf(callback);
+    return index > -1;
+  }
+
+  triggerAlarm(alarm) {
+    for (let i = 0; i < this._listeners.length; i++) {
+      const callback = this._listeners[i];
+      callback(alarm);
+    }
+  }
+}
+
+export default MockAlarms;

package/test/mocks/mockApiResponse.js

@@ -0,0 +1,31 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+
+/**
+ * Mock an API response
+ * @param {Object} body The response body
+ * @returns {Promise<string>} The response serialized in JSON.
+ */
+exports.mockApiResponse = (body = {}, header = {}) => Promise.resolve(JSON.stringify({header: header, body: body}));
+
+exports.mockApiResponseError = (status, errorMessage, body = {}) => Promise.resolve({
+  status: status,
+  body: JSON.stringify({
+    header: {
+      message: errorMessage,
+      status: status
+    },
+    body: body
+  })
+});

package/test/mocks/mockCryptoKey.js

@@ -0,0 +1,62 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.9.0
+ */
+
+import {generateSsoKitServerData} from "../../src/all/background_page/model/entity/sso/ssoKitServerPart.test.data";
+
+class CryptoKey {
+  constructor(algorithm, extractable, usages) {
+    this.extractable = extractable;
+    this.algorithm = algorithm;
+    this.usages = usages;
+  }
+}
+
+global.CryptoKey = CryptoKey;
+
+class CryptoSubtle {
+  constructor() {
+    this.exportKey = jest.fn().mockImplementation(this.exportKey.bind(this));
+    this.importKey = jest.fn().mockImplementation(this.importKey.bind(this));
+    this.decrypt = jest.fn().mockImplementation(this.decrypt.bind(this));
+    this.encrypt = jest.fn().mockImplementation(this.encrypt.bind(this));
+    this.generateKey = jest.fn().mockImplementation(this.generateKey.bind(this));
+  }
+
+  async generateKey(algorithm, extractable, capabilities) {
+    return new CryptoKey(algorithm, extractable, capabilities);
+  }
+
+  async exportKey(keyFormat, keyInformation) {
+    const b64Key = generateSsoKitServerData({ext: keyInformation.extractable, key_ops: keyInformation.usages});
+    return JSON.parse(Buffer.from(b64Key, "base64").toString());
+  }
+
+  async importKey(keyFormat, keyBinData, algorithm, extractable, capabilities) {
+    const algo = {
+      name: algorithm,
+      length: keyBinData.length
+    };
+    return new CryptoKey(algo, extractable, capabilities);
+  }
+
+  async decrypt(algorithm, key, buffer) {
+    return buffer;
+  }
+
+  async encrypt(algorithm, key, buffer) {
+    return buffer;
+  }
+}
+
+global.crypto.subtle = new CryptoSubtle();

package/test/mocks/mockEventListener.js

@@ -0,0 +1,40 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.9.0
+ */
+
+class MockEventListener {
+  constructor() {
+    this.listeners = [];
+    this.addListener = jest.fn().mockImplementation(this.addListener.bind(this));
+    this.removeListener = jest.fn().mockImplementation(this.removeListener.bind(this));
+  }
+
+  addListener(callback) {
+    this.listeners.push(callback);
+  }
+
+  removeListener(callback) {
+    const index = this.listeners.find(cb => cb === callback);
+    if (index > -1) {
+      this.listeners.splice(index);
+    }
+  }
+
+  triggers(...args) {
+    this.listeners.forEach(listener => {
+      listener.apply(null, args);
+    });
+  }
+}
+
+export default MockEventListener;

package/test/mocks/mockExtension.js

@@ -0,0 +1,60 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.6.0
+ */
+
+import User from "../../src/all/background_page/model/user";
+import {defaultSecurityTokenDto} from "../../src/all/background_page/model/entity/securityToken/SecurityTokenEntity.test.data";
+import {v4 as uuidv4} from "uuid";
+import Keyring from "../../src/all/background_page/model/keyring";
+import {pgpKeys} from "../fixtures/pgpKeys/keys";
+
+class MockExtension {
+  /**
+   * Mock the extension with a configured account. Ada by default.
+   * @returns {Promise<void>}
+   */
+  static async withConfiguredAccount(keyData = pgpKeys.ada) {
+    const user = this.withMissingPrivateKeyAccount(keyData);
+
+    // Mock user private key
+    const keyring = new Keyring();
+    await keyring.importPrivate(keyData.private);
+
+    return user;
+  }
+
+  /**
+   * Mock the extension with a partially configured account. Ada by default without the private key set.
+   *
+   * @returns {Promise<User>}
+   */
+  static withMissingPrivateKeyAccount(keyData = pgpKeys.ada) {
+    const user = User.getInstance();
+    user.settings.setDomain("https://passbolt.local");
+    user.settings.setSecurityToken(defaultSecurityTokenDto());
+    const nameSplitted = keyData.user_ids[0].name.split(" ");
+    const userDto = {
+      id: uuidv4(),
+      username: keyData.user_ids[0].email,
+      firstname: nameSplitted.shift(),
+      lastname: nameSplitted.join(" "),
+    };
+    user.set(userDto);
+
+    const keyring = new Keyring();
+    keyring.flush(Keyring.PRIVATE);
+
+    return user;
+  }
+}
+export default MockExtension;