passbolt-browser-extension 5.2.0 → 5.3.2

package/src/all/background_page/controller/user/deleteUserController.test.js

@@ -0,0 +1,141 @@
+/**
+ * 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 {enableFetchMocks} from "jest-fetch-mock";
+import {mockApiResponse, mockApiResponseError} from "../../../../../test/mocks/mockApiResponse";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import RoleEntity from "passbolt-styleguide/src/shared/models/entity/role/roleEntity";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import {defaultSharedResourcesWithEncryptedMetadataDtos, defaultResourcesDtos} from "passbolt-styleguide/src/shared/models/entity/resource/resourcesCollection.test.data";
+import {defaultDecryptedSharedMetadataKeysDtos} from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection.test.data";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import {v4 as uuidv4} from "uuid";
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import {pgpKeys} from 'passbolt-styleguide/test/fixture/pgpKeys/keys';
+import MetadataKeysCollection from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection";
+import {defaultUserDto} from "passbolt-styleguide/src/shared/models/entity/user/userEntity.test.data";
+import DeleteUserController from "./deleteUserController";
+import UserLocalStorage from "../../service/local_storage/userLocalStorage";
+import UsersCollection from "../../model/entity/user/usersCollection";
+
+beforeEach(() => {
+  enableFetchMocks();
+});
+
+describe("DeleteUserController", () => {
+  describe("::exec", () => {
+    const accountDto = defaultAccountDto();
+    accountDto.role_name = RoleEntity.ROLE_ADMIN;
+    const account = new AccountEntity(accountDto);
+
+    it("Should delete the user without transfer", async() => {
+      expect.assertions(2);
+
+      const userDto = defaultUserDto();
+      await UserLocalStorage.set(new UsersCollection([userDto]));
+
+      fetch.doMockOnceIf(new RegExp(`/users/${userDto.id}.json`), () => mockApiResponse({}));
+
+      const controller = new DeleteUserController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.deleteUserService, "delete");
+      jest.spyOn(UserLocalStorage, "delete");
+
+      await controller.exec(userDto.id);
+
+      expect(controller.deleteUserService.delete).toHaveBeenCalledWith(userDto.id, null);
+      expect(UserLocalStorage.delete).toHaveBeenCalledWith(userDto.id);
+    });
+
+    it("Should throw an error if the user has transfer and decrypt", async() => {
+      expect.assertions(3);
+
+      const userDto = defaultUserDto();
+      await UserLocalStorage.set(new UsersCollection([userDto]));
+      const metadataKeysDtos = defaultDecryptedSharedMetadataKeysDtos();
+      const metadataKeys = new MetadataKeysCollection(metadataKeysDtos);
+      const collectionDto = defaultSharedResourcesWithEncryptedMetadataDtos(10, {
+        metadata_key_id: metadataKeysDtos[0].id
+      });
+      const body = {
+        errors: {
+          resources: {
+            sole_owner: collectionDto
+          }
+        }
+      };
+
+      fetch.doMockOnceIf(new RegExp(`/users/${userDto.id}.json`), () => mockApiResponseError(400, "Need transfer", body));
+
+      const controller = new DeleteUserController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.decryptMetadataService.getOrFindMetadataKeysService, "getOrFindAll").mockImplementation(() => metadataKeys);
+      jest.spyOn(controller.getPassphraseService, "getPassphrase").mockImplementationOnce(() => pgpKeys.ada.passphrase);
+      jest.spyOn(UserLocalStorage, "delete");
+
+      try {
+        await controller.exec(userDto.id);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+        expect(error.errors.resources.sole_owner.items.every(resourceEntity => resourceEntity.isMetadataDecrypted())).toBeTruthy();
+        expect(UserLocalStorage.delete).not.toHaveBeenCalledWith(userDto.id);
+      }
+    });
+
+    it("Should throw an error if the user has transfer without decryption", async() => {
+      expect.assertions(5);
+
+      const userDto = defaultUserDto();
+      await UserLocalStorage.set(new UsersCollection([userDto]));
+      const collectionDto = defaultResourcesDtos();
+      const body = {
+        errors: {
+          resources: {
+            sole_owner: collectionDto
+          }
+        }
+      };
+
+      fetch.doMockOnceIf(new RegExp(`/users/${userDto.id}.json`), () => mockApiResponseError(400, "Need transfer", body));
+
+      const controller = new DeleteUserController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.decryptMetadataService.getOrFindMetadataKeysService, "getOrFindAll");
+      jest.spyOn(controller.getPassphraseService, "getPassphrase");
+      jest.spyOn(UserLocalStorage, "delete");
+
+      try {
+        await controller.exec(userDto.id);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+        expect(error.errors.resources.sole_owner.items.every(resourceEntity => resourceEntity.isMetadataDecrypted())).toBeTruthy();
+        expect(controller.decryptMetadataService.getOrFindMetadataKeysService.getOrFindAll).not.toHaveBeenCalled();
+        expect(controller.getPassphraseService.getPassphrase).not.toHaveBeenCalled();
+        expect(UserLocalStorage.delete).not.toHaveBeenCalledWith(userDto.id);
+      }
+    });
+
+    it("Should throw an error if something wrong happens on the API", async() => {
+      expect.assertions(1);
+
+      const userId = uuidv4();
+      fetch.doMockOnceIf(new RegExp(`/users/${userId}.json`), async() => mockApiResponseError(500, "Something went wrong"));
+
+      const controller = new DeleteUserController(null, null, defaultApiClientOptions(), account);
+      try {
+        await controller.exec(userId);
+      } catch (e) {
+        expect(e).toBeInstanceOf(PassboltApiFetchError);
+      }
+    });
+  });
+});

package/src/all/background_page/event/actionLogEvents.js

@@ -10,14 +10,14 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-import ActionLogModel from "../model/actionLog/actionLogModel";
+import FindAllForActionLogController from "./findAllForActionLogController";
 
 /**
  * Listens to the action logs events
  * @param {Worker} worker The worker
  * @param {ApiClientOptions} apiClientOptions The api client options
  */
-const listen = function(worker, apiClientOptions) {
+const listen = function(worker, apiClientOptions, account) {
   /*
    * Find all action logs for a given instance
    *
@@ -25,16 +25,9 @@ const listen = function(worker, apiClientOptions) {
    * @param requestId {uuid} The request identifier
    * @param options {object} The options to apply to the find
    */
-  worker.port.on('passbolt.actionlogs.find-all-for', async(requestId, foreignModel, foreignId, options) => {
-    try {
-      const actionLogModel = new ActionLogModel(apiClientOptions);
-      const {limit, page} = options;
-      const actionLogs = await actionLogModel.findAllFor(foreignModel, foreignId, page, limit);
-      worker.port.emit(requestId, 'SUCCESS', actionLogs);
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.actionlogs.find-all-for', async(requestId, foreignModel, foreignId, {page, limit}) => {
+    const controller = new FindAllForActionLogController(worker, requestId, apiClientOptions, account);
+    await controller._exec(foreignModel, foreignId, {page, limit});
   });
 };
 

package/src/all/background_page/event/appEvents.js

@@ -67,6 +67,8 @@ import FindMetadataMigrateResourcesController from "../controller/migrateMetadat
 import MigrateMetadataResourcesController from "../controller/migrateMetadata/migrateMetadataResourcesController";
 import DownloadOrganizationGeneratedKey from "../controller/accountRecovery/downloadOrganizationGenerateKeyController";
 import ShareMetadataKeyPrivateController from "../controller/metadata/shareMetadataKeyPrivateController";
+import CopyToClipboardController from "../controller/clipboard/copyToClipboardController";
+import CopyTemporarilyToClipboardController from "../controller/clipboard/copyTemporarilyToClipboardController";
 
 const listen = function(worker, apiClientOptions, account) {
   /*
@@ -433,5 +435,36 @@ const listen = function(worker, apiClientOptions, account) {
     const controller = new ShareMetadataKeyPrivateController(worker, requestId, apiClientOptions, account);
     await controller._exec(userId);
   });
+
+
+  /*
+   * ==================================================================================
+   *  Clipboard events.
+   * ==================================================================================
+   */
+
+  /**
+   * Copies the given content into the clipboard and clear any clipboard flush alarms.
+   *
+   * @listens assbolt.clipboard.copy
+   * @param {string} requestId The request identifier
+   * @param {string} text the content to copy
+   */
+  worker.port.on('passbolt.clipboard.copy', async(requestId, text) => {
+    const clipboardController = new CopyToClipboardController(worker, requestId);
+    await clipboardController._exec(text);
+  });
+
+  /**
+   * Copies temporarily the given content into the clipboard and set a clipboard flush alarm.
+   *
+   * @listens assbolt.clipboard.copy-temporarily
+   * @param {string} requestId The request identifier
+   * @param {string} text the content to copy
+   */
+  worker.port.on('passbolt.clipboard.copy-temporarily', async(requestId, text) => {
+    const clipboardController = new CopyTemporarilyToClipboardController(worker, requestId);
+    await clipboardController._exec(text);
+  });
 };
 export const AppEvents = {listen};

package/src/all/background_page/event/findAllForActionLogController.js

@@ -0,0 +1,58 @@
+/**
+ * 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 FindActionLogService from "../model/actionLog/findActionLogService";
+
+class FindAllForActionLogController {
+  /**
+   * @constructor
+   * @param {Worker} worker The worker
+   * @param {string} requestId uuid
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   * @param {AccountEntity} account the user account
+   */
+  constructor(worker, requestId, apiClientOptions, account) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.findAllForActionLogService = new FindActionLogService(apiClientOptions, account);
+  }
+
+  /**
+   * Controller executor.
+   * @param {string} foreignModel The foreign model
+   * @param {string} foreignId The foreign ID
+   * @param {object} options Options
+   * @param {number} options.page The page number
+   * @param {number} options.limit The limit of activities per page
+   * @returns {Promise<void>}
+   */
+  async _exec(foreignModel, foreignId, {page, limit}) {
+    try {
+      const result = await this.exec(foreignModel, foreignId, {page, limit});
+      this.worker.port.emit(this.requestId, 'SUCCESS', result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Find all action logs
+   * @returns {Promise<*>}
+   */
+  async exec(foreignModel, foreignId, {page, limit}) {
+    return this.findAllForActionLogService.findAllFor(foreignModel, foreignId, page, limit);
+  }
+}
+
+export default FindAllForActionLogController;

package/src/all/background_page/event/findAllForActionLogController.test.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.4.0
+ */
+import AccountEntity from "../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../model/entity/account/accountEntity.test.data";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import FindAllForActionLogController from "./findAllForActionLogController";
+import {defaultActionLogsCollection} from "../model/entity/actionLog/actionLogsCollection.test.data";
+import ActionLogsCollection from "../model/entity/actionLog/actionLogsCollection";
+import {v4 as uuid} from "uuid";
+
+describe("FindAllForActionLogController", () => {
+  let controller, account, apiClientOptions;
+
+  beforeEach(async() => {
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = defaultApiClientOptions();
+    controller = new FindAllForActionLogController(null, null, apiClientOptions, account);
+  });
+
+  describe("FindAllForActionLogController::exec", () => {
+    it("Find all action logs for the resource", async() => {
+      expect.assertions(2);
+
+      const actionLogsDto = defaultActionLogsCollection;
+      jest.spyOn(controller.findAllForActionLogService, "findAllFor").mockImplementationOnce(() => new ActionLogsCollection(actionLogsDto));
+
+      const actionLogsCollection = await controller.exec("Resource", uuid(), {page: 1, limit: 5});
+      expect(actionLogsCollection).toBeInstanceOf(ActionLogsCollection);
+      expect(actionLogsCollection.toDto()).toEqual(actionLogsDto);
+    });
+  });
+});

package/src/all/background_page/event/quickAccessEvents.js

@@ -13,6 +13,8 @@ import GetOrFindPasswordPoliciesController from "../controller/passwordPolicies/
 import AutofillController from "../controller/autofill/AutofillController";
 import GetOrFindPasswordExpirySettingsController from "../controller/passwordExpiry/getOrFindPasswordExpirySettingsController";
 import GetOrFindMetadataTypesController from "../controller/metadata/getMetadataTypesSettingsController";
+import CopyToClipboardController from "../controller/clipboard/copyToClipboardController";
+import CopyTemporarilyToClipboardController from "../controller/clipboard/copyTemporarilyToClipboardController";
 
 /**
  * Listens to the quickaccess application events
@@ -158,6 +160,36 @@ const listen = function(worker, apiClientOptions, account) {
     const controller = new GetOrFindMetadataTypesController(worker, requestId, apiClientOptions, account);
     await controller._exec();
   });
+
+  /*
+   * ==================================================================================
+   *  Clipboard events.
+   * ==================================================================================
+   */
+
+  /**
+   * Copies the given content into the clipboard and clear any clipboard flush alarms.
+   *
+   * @listens assbolt.clipboard.copy
+   * @param {string} requestId The request identifier
+   * @param {string} text the content to copy
+   */
+  worker.port.on('passbolt.clipboard.copy', async(requestId, text) => {
+    const clipboardController = new CopyToClipboardController(worker, requestId);
+    await clipboardController._exec(text);
+  });
+
+  /**
+   * Copies temporarily the given content into the clipboard and set a clipboard flush alarm.
+   *
+   * @listens assbolt.clipboard.copy-temporarily
+   * @param {string} requestId The request identifier
+   * @param {string} text the content to copy
+   */
+  worker.port.on('passbolt.clipboard.copy-temporarily', async(requestId, text) => {
+    const clipboardController = new CopyTemporarilyToClipboardController(worker, requestId);
+    await clipboardController._exec(text);
+  });
 };
 
 export const QuickAccessEvents = {listen};

package/src/all/background_page/event/resourceEvents.js

@@ -22,6 +22,7 @@ import FindAllByIdsForDisplayPermissionsController
 import MoveResourcesController from "../controller/move/moveResourcesController";
 import ResetResourceGridUserSettingController
   from "../controller/resourceGridSetting/resetResourceGridUserSettingController";
+import UpdateResourceLocalStorageByFolderParentIdController from "../controller/resource/updateResourceLocalStorageByFolderParentIdController";
 
 const listen = function(worker, apiClientOptions, account) {
   /*
@@ -173,6 +174,16 @@ const listen = function(worker, apiClientOptions, account) {
     const controller = new MoveResourcesController(worker, requestId, apiClientOptions, account);
     await controller._exec(resourcesIds, destinationFolderId);
   });
+
+  /*
+   * Update the local storage for resources in the specified parent folder.
+   * @listens passbolt.resources.update-local-storage-by-folder-parent-id
+   * @param {string} parentFolderId The id of the parent folder.
+   */
+  worker.port.on('passbolt.resources.update-local-storage-by-folder-parent-id', async(requestId, parentFolderId) => {
+    const controller = new UpdateResourceLocalStorageByFolderParentIdController(worker, requestId, apiClientOptions, account);
+    await controller._exec(parentFolderId);
+  });
 };
 
 export const ResourceEvents = {listen};

package/src/all/background_page/event/userEvents.js

@@ -9,13 +9,14 @@
 import UserModel from "../model/user/userModel";
 import AccountModel from "../model/account/accountModel";
 import UpdatePrivateKeyController from "../controller/account/updatePrivateKeyController";
-import UserDeleteTransferEntity from "../model/entity/user/transfer/userDeleteTransferEntity";
 import UserEntity from "../model/entity/user/userEntity";
 import SecurityTokenEntity from "../model/entity/securityToken/securityTokenEntity";
 import AvatarUpdateEntity from "../model/entity/avatar/update/avatarUpdateEntity";
 import UpdateUserLocalStorageController from "../controller/user/updateUserLocalStorageController";
 import GetOrFindLoggedInUserController from "../controller/user/getOrFindLoggedInUserController";
 import UpdateUserController from "../controller/user/updateUserController";
+import DeleteDryRunUserController from "../controller/user/deleteDryRunUserController";
+import DeleteUserController from "../controller/user/deleteUserController";
 
 /**
  * Listens the user events
@@ -154,16 +155,9 @@ const listen = function(worker, apiClientOptions, account) {
    * @param {string} requestId The request identifier uuid
    * @param {string} userId The user uuid
    */
-  worker.port.on('passbolt.users.delete-dry-run', async(requestId, userId, transferDto) => {
-    try {
-      const userModel = new UserModel(apiClientOptions, account);
-      const transferEntity = transferDto ? new UserDeleteTransferEntity(transferDto) : null;
-      await userModel.deleteDryRun(userId, transferEntity);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.users.delete-dry-run', async(requestId, userId) => {
+    const controller = new DeleteDryRunUserController(worker, requestId, apiClientOptions, account);
+    await controller._exec(userId);
   });
 
   /*
@@ -174,15 +168,8 @@ const listen = function(worker, apiClientOptions, account) {
    * @param {object} [transferDto] optional data ownership transfer
    */
   worker.port.on('passbolt.users.delete', async(requestId, userId, transferDto) => {
-    try {
-      const userModel = new UserModel(apiClientOptions, account);
-      const transferEntity = transferDto ? new UserDeleteTransferEntity(transferDto) : null;
-      await userModel.delete(userId, transferEntity);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+    const controller = new DeleteUserController(worker, requestId, apiClientOptions, account);
+    await controller._exec(userId, transferDto);
   });
 
   /*

package/src/all/background_page/event/webIntegrationEvents.js

@@ -12,6 +12,7 @@
  */
 import WebIntegrationController from "../controller/webIntegration/webIntegrationController";
 import RemovePortController from "../controller/port/removePortController";
+import CancelClipboardContentFlushController from "../controller/clipboard/cancelClipboardContentFlushController";
 
 /**
  * Listens the web integration events
@@ -33,6 +34,16 @@ const listen = function(worker) {
     const removePortController = new RemovePortController(worker);
     await removePortController._exec(applicationName);
   });
+
+  /*
+   * Whenever a cut or a copy event happens on a web page to ensure the clipboard flush alarm is not triggered
+   * @listens passbolt.clipboard.cancel-content-flush
+   * @param requestId {uuid} The request identifier
+   */
+  worker.port.on('passbolt.clipboard.cancel-content-flush', async requestId => {
+    const clipboardController = new CancelClipboardContentFlushController(worker, requestId);
+    await clipboardController._exec();
+  });
 };
 
 export const WebIntegrationEvents = {listen};

package/src/all/background_page/model/actionLog/{actionLogModel.js → findActionLogService.js}

@@ -11,9 +11,11 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  */
 import ActionLogsCollection from "../entity/actionLog/actionLogsCollection";
-import ActionLogService from "../../service/api/actionLog/actionLogService";
+import {assertUuid, assertNonEmptyString, assertNumber} from "../../utils/assertions";
+import AbstractActionLogEntity from "../entity/actionLog/abstractActionLogEntity";
+import ActionLogApiService from "../../service/api/actionLog/actionLogApiService";
 
-class ActionLogModel {
+class FindActionLogService {
   /**
    * Constructor
    *
@@ -21,7 +23,7 @@ class ActionLogModel {
    * @public
    */
   constructor(apiClientOptions) {
-    this.actionLogService = new ActionLogService(apiClientOptions);
+    this.actionLogApiService = new ActionLogApiService(apiClientOptions);
   }
 
   /*
@@ -42,9 +44,27 @@ class ActionLogModel {
    * @public
    */
   async findAllFor(foreignModel, foreignId, page, limit) {
-    const actionLogsDto = await this.actionLogService.findAllFor(foreignModel, foreignId, page, limit);
+    this.assertValidForeignModel(foreignModel);
+    assertUuid(foreignId);
+    assertNumber(page);
+    assertNumber(limit);
+    const actionLogsDto = await this.actionLogApiService.findAllFor(foreignModel, foreignId, page, limit);
     return new ActionLogsCollection(actionLogsDto);
   }
+
+  /**
+   * Assert a foreign model name is supported by the API
+   *
+   * @param {string} foreignModel for example 'Resource'
+   * @throw {TypeError} if the name is not a valid string or is not supported
+   * @public
+   */
+  assertValidForeignModel(foreignModel) {
+    assertNonEmptyString(foreignModel, 'ActionLog foreign model should be a valid string.');
+    if (!AbstractActionLogEntity.ALLOWED_FOREIGN_MODELS.includes(foreignModel)) {
+      throw new TypeError(`ActionLog foreign model ${foreignModel} is not in the list of supported models.`);
+    }
+  }
 }
 
-export default ActionLogModel;
+export default FindActionLogService;

package/src/all/background_page/model/actionLog/findActionLogService.test.js

@@ -0,0 +1,61 @@
+/**
+ * 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 BuildApiClientOptionsService from "../../service/account/buildApiClientOptionsService";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import {v4 as uuidv4} from "uuid";
+import {enableFetchMocks} from "jest-fetch-mock";
+import ActionLogApiService from "../../service/api/actionLog/actionLogApiService";
+import FindActionLogService from "./findActionLogService";
+import {defaultActionLogsCollection} from "../../model/entity/actionLog/actionLogsCollection.test.data";
+
+describe("FindActionLogService", () => {
+  let apiClientOptions, account,
+    service;
+
+  beforeEach(async() => {
+    enableFetchMocks();
+    jest.clearAllMocks();
+    fetch.resetMocks();
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+    service = new FindActionLogService(apiClientOptions, account);
+  });
+
+  describe('::findAllFor', () => {
+    it("Should call the actionLog service API to get the acitonlog collection", async() => {
+      expect.assertions(1);
+      const foreignId = uuidv4();
+      const actionLogsDto = defaultActionLogsCollection;
+
+      jest.spyOn(ActionLogApiService.prototype, "findAllFor").mockImplementation(() => actionLogsDto);
+
+      const actionLogs = await service.findAllFor("Resource", foreignId, 1, 5);
+      expect(actionLogs).toHaveLength(actionLogsDto.length);
+    });
+
+    it("should throw an error if id is not defined", async() => {
+      expect.assertions(1);
+      const promise = service.findAllFor({unknown: true});
+      await expect(promise).rejects.toThrowError("ActionLog foreign model should be a valid string.");
+    });
+
+    it("should throw an error if foreign model is unsupported", async() => {
+      expect.assertions(1);
+      const foreignId = uuidv4();
+      const promise = service.findAllFor("ChangeTheme", foreignId, 1, 5);
+      await expect(promise).rejects.toThrowError("ActionLog foreign model ChangeTheme is not in the list of supported models.");
+    });
+  });
+});

package/src/all/background_page/model/comment/commentModel.js

@@ -13,7 +13,7 @@
  */
 import CommentEntity from "../entity/comment/commentEntity";
 import CommentsCollection from "../entity/comment/commentsCollection";
-import CommentService from "../../service/api/comment/commentService";
+import CommentApiService from "../../service/api/comment/commentApiService";
 
 class CommentModel {
   /**
@@ -23,7 +23,7 @@ class CommentModel {
    * @public
    */
   constructor(apiClientOptions) {
-    this.commentService = new CommentService(apiClientOptions);
+    this.commentApiService = new CommentApiService(apiClientOptions);
   }
 
   /**
@@ -35,7 +35,7 @@ class CommentModel {
    */
   async findAllByResourceId(resourceId) {
     const foreignKey = 'Resource';
-    const commentsDtos = await this.commentService.findAll(foreignKey, resourceId, {creator: true, modifier: false});
+    const commentsDtos = await this.commentApiService.findAll(foreignKey, resourceId, {creator: true, modifier: false});
     return new CommentsCollection(commentsDtos);
   }
 
@@ -46,7 +46,7 @@ class CommentModel {
    * @returns {Promise<CommentEntity>}
    */
   async create(commentEntity) {
-    const commentDto = await this.commentService.create(commentEntity.toDto({creator: false, modifier: false}));
+    const commentDto = await this.commentApiService.create(commentEntity.toDto({creator: false, modifier: false}));
     return new CommentEntity(commentDto);
   }
 
@@ -57,7 +57,7 @@ class CommentModel {
    * @returns {Promise<void>}
    */
   async delete(commentId) {
-    await this.commentService.delete(commentId);
+    await this.commentApiService.delete(commentId);
   }
 }
 

package/src/all/background_page/model/entity/actionLog/actionLogsCollection.test.data.js

@@ -0,0 +1,18 @@
+/**
+ * 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 {defaultData} from "./defaultActionLogEntity.test.data";
+
+export const defaultActionLogsCollection = [
+  defaultData
+];