passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/model/entity/permission/permissionsCollection.js

@@ -11,11 +11,10 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         2.13.0
  */
-const {EntitySchema} = require('../abstract/entitySchema');
-const {EntityValidationError} = require('../abstract/entityValidationError');
-const {EntityCollection} = require('../abstract/entityCollection');
-const {EntityCollectionError} = require('../abstract/entityCollectionError');
-const {PermissionEntity} = require('./permissionEntity');
+import PermissionEntity from "./permissionEntity";
+import EntityCollection from "passbolt-styleguide/src/shared/models/entity/abstract/entityCollection";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import EntityCollectionError from "passbolt-styleguide/src/shared/models/entity/abstract/entityCollectionError";
 
 const ENTITY_NAME = 'Permissions';
 
@@ -26,35 +25,39 @@ const RULE_ONE_OWNER = 'owner';
 
 class PermissionsCollection extends EntityCollection {
   /**
-   * Permissions Collection constructor
+   * @inheritDoc
    * Some validation rules are to be expected:
    * - All items should be a valid PermissionEntity
    * - All items should be about the same folder or resource
    * - There can be only one permission per user or group
-   *
-   * Optional validation
-   * - There should be at least one owner
-   *
-   * @param {array} permissionsDto
-   * @param {boolean} [ownerValidation] true by default
-   * @throws EntityValidationError if the dto cannot be converted into an entity
+   * @param {boolean} [options.assertAtLeastOneOwner=true] Assert the collection contains at least one owner.
+   * @throws {EntityCollectionError} Build Rule: Ensure all items in the collection are unique by ID.
+   * @throws {EntityCollectionError} Build Rule: Ensure all items in the collection are unique by aco & aro.
+   * @throws {EntityCollectionError} Build Rule: Ensure all items in the collection target the same aco.
+   * @todo The collection options.clone, doesn't work completely as expected here as the internal push function is creating the PermissionEntity.
    */
-  constructor(permissionsDto, ownerValidation) {
+  constructor(permissionsDto, options = {}) {
+    const assertAtLeastOneOwner = typeof options?.assertAtLeastOneOwner === 'undefined' || options.assertAtLeastOneOwner;
+
     super(EntitySchema.validate(
       PermissionsCollection.ENTITY_NAME,
       permissionsDto,
       PermissionsCollection.getSchema()
-    ));
+    ), options);
 
-    // Note: there is no "multi-item" validation
-    // Collection validation will fail at the first item that doesn't validate
+    /*
+     * Note: there is no "multi-item" validation
+     * Collection validation will fail at the first item that doesn't validate
+     */
     this._props.forEach(permission => {
       this.push(permission);
     });
 
-    // Logical validation rules
-    // A permission list must contain at least one owner
-    if (typeof ownerValidation === 'undefined' || ownerValidation) {
+    /*
+     * Logical validation rules
+     * A permission list must contain at least one owner
+     */
+    if (assertAtLeastOneOwner) {
       this.assertAtLeastOneOwner();
     }
 
@@ -62,9 +65,11 @@ class PermissionsCollection extends EntityCollection {
     this._props = null;
   }
 
-  // ==================================================
-  // Serialization
-  // ==================================================
+  /*
+   * ==================================================
+   * Serialization
+   * ==================================================
+   */
   /**
    * Return a DTO ready to be sent to API
    *
@@ -76,8 +81,8 @@ class PermissionsCollection extends EntityCollection {
     if (!contain) {
       contain = PermissionEntity.ALL_CONTAIN_OPTIONS;
     }
-    for(let permission of this) {
-      result.push(permission.toDto(contain))
+    for (const permission of this) {
+      result.push(permission.toDto(contain));
     }
     return result;
   }
@@ -90,9 +95,11 @@ class PermissionsCollection extends EntityCollection {
     return this.toDto(PermissionEntity.ALL_CONTAIN_OPTIONS);
   }
 
-  // ==================================================
-  // Dynamic getters
-  // ==================================================
+  /*
+   * ==================================================
+   * Dynamic getters
+   * ==================================================
+   */
   /**
    * Get permissions entity schema
    *
@@ -102,7 +109,7 @@ class PermissionsCollection extends EntityCollection {
     return {
       "type": "array",
       "items": PermissionEntity.getSchema(),
-    }
+    };
   }
 
   /**
@@ -113,9 +120,11 @@ class PermissionsCollection extends EntityCollection {
     return this._items;
   }
 
-  // ==================================================
-  // Finders
-  // ==================================================
+  /*
+   * ==================================================
+   * Finders
+   * ==================================================
+   */
   /**
    * Return true if a given permission can be found already in the collection
    *
@@ -137,9 +146,11 @@ class PermissionsCollection extends EntityCollection {
     return this._items.find(permission => permission.aro === aro && permission.aroForeignKey === aroForeignKey);
   }
 
-  // ==================================================
-  // Push items in the collection
-  // ==================================================
+  /*
+   * ==================================================
+   * Push items in the collection
+   * ==================================================
+   */
   /**
    * Push a copy of the permission to the list
    * @param {PermissionEntity} permission DTO or PermissionEntity
@@ -153,12 +164,14 @@ class PermissionsCollection extends EntityCollection {
       permission = permission.toDto(PermissionEntity.ALL_CONTAIN_OPTIONS); // deep clone
     }
 
-    let newPermission = new PermissionEntity(permission); // validate
+    const newPermission = new PermissionEntity(permission); // validate
 
-    // Build rules
-    // Assert there is not already a permission with the same id
-    // Assert there is not already a permission with the same ACO/ARO
-    // Assert we're dealing with same resource / folder
+    /*
+     * Build rules
+     * Assert there is not already a permission with the same id
+     * Assert there is not already a permission with the same ACO/ARO
+     * Assert we're dealing with same resource / folder
+     */
     this.assertSameAco(newPermission);
     this.assertUniqueId(newPermission);
     this.assertUniqueAro(newPermission);
@@ -175,12 +188,12 @@ class PermissionsCollection extends EntityCollection {
   addOrReplace(permission) {
     try {
       this.push(permission);
-    } catch(error) {
-      const recover = [PermissionsCollection.RULE_UNIQUE_ID, PermissionsCollection.RULE_UNIQUE_ARO]
+    } catch (error) {
+      const recover = [PermissionsCollection.RULE_UNIQUE_ID, PermissionsCollection.RULE_UNIQUE_ARO];
       if (!recover.includes(error.rule)) {
         throw error;
       }
-      let existingPermission = this.permissions[error.position];
+      const existingPermission = this.permissions[error.position];
       if (PermissionEntity.isAcoAndAroMatching(existingPermission, permission)) {
         // if the match, keep the one with highest permission
         this.permissions[error.position] = PermissionEntity.getHighestPermission(existingPermission, permission);
@@ -191,9 +204,11 @@ class PermissionsCollection extends EntityCollection {
     }
   }
 
-  // ==================================================
-  // Permissions assertions
-  // ==================================================
+  /*
+   * ==================================================
+   * Permissions assertions
+   * ==================================================
+   */
   /**
    * Assert there the collection is always about the same ACO (resource/folder)
    *
@@ -222,8 +237,8 @@ class PermissionsCollection extends EntityCollection {
     }
     const length = this.permissions.length;
     let i = 0;
-    for(; i < length; i++) {
-      let existingPermission = this.permissions[i];
+    for (; i < length; i++) {
+      const existingPermission = this.permissions[i];
       if (existingPermission.id && existingPermission.id === permission.id) {
         throw new EntityCollectionError(i, PermissionsCollection.RULE_UNIQUE_ID, `Permission id ${permission.id} already exists.`);
       }
@@ -239,8 +254,8 @@ class PermissionsCollection extends EntityCollection {
   assertUniqueAro(permission) {
     const length = this.permissions.length;
     let i = 0;
-    for(; i < length; i++) {
-      let existingPermission = this.permissions[i];
+    for (; i < length; i++) {
+      const existingPermission = this.permissions[i];
       if (PermissionEntity.isAroMatching(permission, existingPermission)) {
         const msg = `${permission.aro} id ${permission.aroForeignKey} already exists in the permission list.`;
         throw new EntityCollectionError(i, PermissionsCollection.RULE_UNIQUE_ARO, msg);
@@ -255,18 +270,20 @@ class PermissionsCollection extends EntityCollection {
    * @throws {EntityValidationError} if not owner is found in the collection
    */
   assertAtLeastOneOwner() {
-    for (let permission of this) {
+    for (const permission of this) {
       if (permission.isOwner()) {
         return;
       }
     }
-    const msg = 'Permission collection should contain at least one owner.'
+    const msg = 'Permission collection should contain at least one owner.';
     throw new EntityCollectionError(0, PermissionsCollection.RULE_ONE_OWNER, msg);
   }
 
-  // ==================================================
-  // Permissions "arithmetics"
-  // ==================================================
+  /*
+   * ==================================================
+   * Permissions "arithmetics"
+   * ==================================================
+   */
   /**
    * Create a new set based on set1 + set2
    * Keep the highest permission if there is an overlap
@@ -277,8 +294,8 @@ class PermissionsCollection extends EntityCollection {
    * @return {PermissionsCollection} set3
    */
   static sum(set1, set2, ownerValidation) {
-    const set3 = new PermissionsCollection(set1.toDto(), false);
-    for (let set2Permission of set2) {
+    const set3 = new PermissionsCollection(set1.toDto(), {assertAtLeastOneOwner: false});
+    for (const set2Permission of set2) {
       set3.addOrReplace(set2Permission);
     }
     if (typeof ownerValidation === 'undefined' || ownerValidation) {
@@ -297,8 +314,8 @@ class PermissionsCollection extends EntityCollection {
    * @return {PermissionsCollection} set3
    */
   static diff(set1, set2, ownerValidation) {
-    const set3 = new PermissionsCollection([], false);
-    for (let permission of set1) {
+    const set3 = new PermissionsCollection([], {assertAtLeastOneOwner: false});
+    for (const permission of set1) {
       if (!set2.containAtLeastPermission(permission.aro, permission.aroForeignKey, permission.type)) {
         set3.push(permission);
       }
@@ -317,8 +334,8 @@ class PermissionsCollection extends EntityCollection {
    * @param {number} type see permission entity types
    * @returns {boolean}
    */
-  containAtLeastPermission( aro, aroForeignKey, type) {
-    for (let permission of this.items) {
+  containAtLeastPermission(aro, aroForeignKey, type) {
+    for (const permission of this.items) {
       if (permission.aro === aro && permission.aroForeignKey === aroForeignKey && permission.type >= type) {
         return true;
       }
@@ -334,8 +351,8 @@ class PermissionsCollection extends EntityCollection {
    * @param {number} type see permission entity types
    * @returns {boolean}
    */
-  containAtMostPermission( aro, aroForeignKey, type) {
-    for (let permission of this.items) {
+  containAtMostPermission(aro, aroForeignKey, type) {
+    for (const permission of this.items) {
       if (permission.aro === aro && permission.aroForeignKey === aroForeignKey && permission.type <= type) {
         return true;
       }
@@ -352,9 +369,9 @@ class PermissionsCollection extends EntityCollection {
    * @return {PermissionsCollection}
    */
   cloneForAco(aco, acoId, ownerValidation) {
-    const permissions = new PermissionsCollection([], false);
-    for (let parentPermission of this.permissions) {
-      let clone = parentPermission.copyForAnotherAco(aco, acoId);
+    const permissions = new PermissionsCollection([], {assertAtLeastOneOwner: false});
+    for (const parentPermission of this.permissions) {
+      const clone = parentPermission.copyForAnotherAco(aco, acoId);
       permissions.addOrReplace(clone);
     }
     if (typeof ownerValidation === 'undefined' || ownerValidation) {
@@ -363,9 +380,11 @@ class PermissionsCollection extends EntityCollection {
     return permissions;
   }
 
-  // ==================================================
-  // Static getters
-  // ==================================================
+  /*
+   * ==================================================
+   * Static getters
+   * ==================================================
+   */
   /**
    * PermissionsCollection.ENTITY_NAME
    * @returns {string}
@@ -407,4 +426,4 @@ class PermissionsCollection extends EntityCollection {
   }
 }
 
-exports.PermissionsCollection = PermissionsCollection;
+export default PermissionsCollection;

package/src/all/background_page/model/entity/permission/permissionsCollection.test.js

@@ -11,16 +11,10 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         2.13.0
  */
-import {PermissionEntity} from "./permissionEntity";
-import {EntitySchema} from "../abstract/entitySchema";
-import Validator from 'validator';
-import {PermissionsCollection} from "./permissionsCollection";
-import {EntityCollectionError} from "../abstract/entityCollectionError";
-
-beforeEach(() => {
-  window.Validator = Validator;
-  jest.resetModules();
-});
+import PermissionEntity from "./permissionEntity";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import PermissionsCollection from "./permissionsCollection";
+import EntityCollectionError from "passbolt-styleguide/src/shared/models/entity/abstract/entityCollectionError";
 
 describe("Permission Collection", () => {
   it("schema must validate", () => {
@@ -28,7 +22,7 @@ describe("Permission Collection", () => {
   });
 
   it("constructor must work with empty data", () => {
-    const c = new PermissionsCollection([], false);
+    const c = new PermissionsCollection([], {assertAtLeastOneOwner: false});
     c.push(new PermissionEntity({
       aco: PermissionEntity.ACO_FOLDER,
       aco_foreign_key: "c2c7f658-c7ac-4d73-9020-9d2c296d91ff",
@@ -202,9 +196,11 @@ describe("Permission Collection", () => {
     expect(c.permissions[2].type).toBe(1);
   });
 
-  //============================================================
-  // Union
-  //============================================================
+  /*
+   * ============================================================
+   *  Union
+   * ============================================================
+   */
 
   it("union returns set1 + set2 - no overlap", () => {
     const dto1 = {
@@ -221,8 +217,8 @@ describe("Permission Collection", () => {
       aro_foreign_key: "54c6278e-f824-5fda-91ff-3e946b18d991",
       type: PermissionEntity.PERMISSION_READ
     };
-    const set1 = new PermissionsCollection([dto1], false);
-    const set2 = new PermissionsCollection([dto2], false);
+    const set1 = new PermissionsCollection([dto1], {assertAtLeastOneOwner: false});
+    const set2 = new PermissionsCollection([dto2], {assertAtLeastOneOwner: false});
 
     const set3 = PermissionsCollection.sum(set1, set2);
     expect(set3.toDto()).toEqual([dto1, dto2]);
@@ -252,9 +248,9 @@ describe("Permission Collection", () => {
       aro: PermissionEntity.ARO_USER,
       aro_foreign_key: "54c6278e-f824-5fda-91ff-3e946b18d992",
       type: PermissionEntity.PERMISSION_UPDATE
-    }
-    const set1 = new PermissionsCollection([dto3, dto1, dto2], false);
-    const set2 = new PermissionsCollection([dto1, dto3, dto2], false);
+    };
+    const set1 = new PermissionsCollection([dto3, dto1, dto2], {assertAtLeastOneOwner: false});
+    const set2 = new PermissionsCollection([dto1, dto3, dto2], {assertAtLeastOneOwner: false});
 
     const set3 = PermissionsCollection.sum(set1, set2);
     const set4 = PermissionsCollection.sum(set2, set1);
@@ -269,14 +265,14 @@ describe("Permission Collection", () => {
       aro: PermissionEntity.ARO_USER,
       aro_foreign_key: "54c6278e-f824-5fda-91ff-3e946b18d990",
       type: PermissionEntity.PERMISSION_OWNER
-    }], false);
+    }], {assertAtLeastOneOwner: false});
     const set2 = new PermissionsCollection([{
       aco: PermissionEntity.ACO_FOLDER,
       aco_foreign_key: "c2c7f658-c7ac-4d73-9020-9d2c296d91ff",
       aro: PermissionEntity.ARO_USER,
       aro_foreign_key: "54c6278e-f824-5fda-91ff-3e946b18d990",
       type: PermissionEntity.PERMISSION_READ
-    }], false);
+    }], {assertAtLeastOneOwner: false});
 
     const set3 = PermissionsCollection.sum(set1, set2);
     const set4 = PermissionsCollection.sum(set2, set1);
@@ -306,8 +302,8 @@ describe("Permission Collection", () => {
       aro_foreign_key: "54c6278e-f824-5fda-91ff-3e946b18d991",
       type: PermissionEntity.PERMISSION_READ
     };
-    const set1 = new PermissionsCollection([dto1, dto2], false);
-    const set2 = new PermissionsCollection([], false);
+    const set1 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
+    const set2 = new PermissionsCollection([], {assertAtLeastOneOwner: false});
 
     const set3 = PermissionsCollection.sum(set1, set2);
     expect(set3.toDto()).toEqual([dto1, dto2]);
@@ -331,8 +327,8 @@ describe("Permission Collection", () => {
       aro_foreign_key: "54c6278e-f824-5fda-91ff-3e946b18d991",
       type: PermissionEntity.PERMISSION_READ
     };
-    const set1 = new PermissionsCollection([dto1, dto2], false);
-    const set2 = new PermissionsCollection([dto2], false);
+    const set1 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
+    const set2 = new PermissionsCollection([dto2], {assertAtLeastOneOwner: false});
 
     try {
       PermissionsCollection.sum(set1, set2);
@@ -359,8 +355,8 @@ describe("Permission Collection", () => {
       aro_foreign_key: "54c6278e-f824-5fda-91ff-3e946b18d991",
       type: PermissionEntity.PERMISSION_OWNER
     };
-    const set1 = new PermissionsCollection([dto1], false);
-    const set2 = new PermissionsCollection([dto2], false);
+    const set1 = new PermissionsCollection([dto1], {assertAtLeastOneOwner: false});
+    const set2 = new PermissionsCollection([dto2], {assertAtLeastOneOwner: false});
 
     try {
       PermissionsCollection.sum(set1, set2);
@@ -442,8 +438,8 @@ describe("Permission Collection", () => {
       }
     ];
 
-    let permissionCollection = new PermissionsCollection(dto);
-    let permissions = JSON.parse(JSON.stringify(permissionCollection));
+    const permissionCollection = new PermissionsCollection(dto);
+    const permissions = JSON.parse(JSON.stringify(permissionCollection));
     expect(permissions[0].user.profile.first_name).toBe('Ada');
     expect(permissions[0].user.profile.avatar.id).toBe('5426cb53-d909-40eb-9202-38f2c1f94084');
     expect(permissions[1].group.name).toBe('Leadership team');
@@ -470,62 +466,62 @@ describe("Permission Collection", () => {
       aro: PermissionEntity.ARO_USER,
       aro_foreign_key: "54c6278e-f824-5fda-91ff-3e946b18d992",
       type: PermissionEntity.PERMISSION_UPDATE
-    }
-    let set1;
-    let set2;
-    let set3;
+    };
+    let set1,
+      set2,
+      set3;
 
     // nothing to remove
-    set1 = new PermissionsCollection([dto3], false);
-    set2 = new PermissionsCollection([dto1, dto2], false);
+    set1 = new PermissionsCollection([dto3], {assertAtLeastOneOwner: false});
+    set2 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
     set3 = PermissionsCollection.diff(set1, set2, false);
     expect(set3.toDto()).toEqual([dto3]);
 
     // nothing to remove 2
-    set1 = new PermissionsCollection([dto1, dto2], false);
-    set2 = new PermissionsCollection([dto3], false);
+    set1 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
+    set2 = new PermissionsCollection([dto3], {assertAtLeastOneOwner: false});
     set3 = PermissionsCollection.diff(set1, set2, false);
     expect(set3.toDto()).toEqual([dto1, dto2]);
 
     // nothing to change
-    set1 = new PermissionsCollection([dto1, dto2], false);
-    set2 = new PermissionsCollection([dto1, dto2], false);
+    set1 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
+    set2 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
     set3 = PermissionsCollection.diff(set1, set2, false);
     expect(set3.toDto()).toEqual([]);
 
     // nothing left
-    set1 = new PermissionsCollection([], false);
-    set2 = new PermissionsCollection([dto1, dto2], false);
+    set1 = new PermissionsCollection([], {assertAtLeastOneOwner: false});
+    set2 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
     set3 = PermissionsCollection.diff(set1, set2, false);
     expect(set3.toDto()).toEqual([]);
 
     // nothing right
-    set1 = new PermissionsCollection([dto1, dto2], false);
-    set2 = new PermissionsCollection([], false);
+    set1 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
+    set2 = new PermissionsCollection([], {assertAtLeastOneOwner: false});
     set3 = PermissionsCollection.diff(set1, set2, false);
     expect(set3.toDto()).toEqual([dto1, dto2]);
 
     // nothing at all
-    set1 = new PermissionsCollection([], false);
-    set2 = new PermissionsCollection([], false);
+    set1 = new PermissionsCollection([], {assertAtLeastOneOwner: false});
+    set2 = new PermissionsCollection([], {assertAtLeastOneOwner: false});
     set3 = PermissionsCollection.diff(set1, set2, false);
     expect(set3.toDto()).toEqual([]);
 
     // nothing left 2
-    set1 = new PermissionsCollection([dto1, dto2], false);
-    set2 = new PermissionsCollection([dto1, dto2, dto3], false);
+    set1 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
+    set2 = new PermissionsCollection([dto1, dto2, dto3], {assertAtLeastOneOwner: false});
     set3 = PermissionsCollection.diff(set1, set2, false);
     expect(set3.toDto()).toEqual([]);
 
     // something left
-    set1 = new PermissionsCollection([dto1, dto2], false);
-    set2 = new PermissionsCollection([dto1, dto3], false);
+    set1 = new PermissionsCollection([dto1, dto2], {assertAtLeastOneOwner: false});
+    set2 = new PermissionsCollection([dto1, dto3], {assertAtLeastOneOwner: false});
     set3 = PermissionsCollection.diff(set1, set2, false);
     expect(set3.toDto()).toEqual([dto2]);
 
     // something left 2
-    set1 = new PermissionsCollection([dto1, dto2, dto3], false);
-    set2 = new PermissionsCollection([dto3], false);
+    set1 = new PermissionsCollection([dto1, dto2, dto3], {assertAtLeastOneOwner: false});
+    set2 = new PermissionsCollection([dto3], {assertAtLeastOneOwner: false});
     set3 = PermissionsCollection.diff(set1, set2, false);
     expect(set3.toDto()).toEqual([dto1, dto2]);
   });
@@ -545,13 +541,11 @@ describe("Permission Collection", () => {
       aro_foreign_key: "54c6278e-f824-5fda-91ff-3e946b18d990",
       type: PermissionEntity.PERMISSION_READ
     };
-    let ownerSet;
-    let readSet;
     let resultSet;
 
     // check remove equal or lower
-    ownerSet = new PermissionsCollection([owner], false);
-    readSet = new PermissionsCollection([read], false);
+    const ownerSet = new PermissionsCollection([owner], {assertAtLeastOneOwner: false});
+    const readSet = new PermissionsCollection([read], {assertAtLeastOneOwner: false});
     resultSet = PermissionsCollection.diff(ownerSet, readSet, false);
     expect(resultSet.toDto()).toEqual([owner]);
     resultSet = PermissionsCollection.diff(readSet, ownerSet, false);

package/src/all/background_page/model/entity/permission/transfer/permissionTransfer.test.js

@@ -11,16 +11,9 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         3.0.0
  */
-import {PermissionTransferEntity} from "./permissionTransferEntity";
-import {EntitySchema} from "../../abstract/entitySchema";
-import {EntityValidationError} from "../../abstract/entityValidationError";
-import Validator from 'validator';
-
-// Reset the modules before each test.
-beforeEach(() => {
-  window.Validator = Validator;
-  jest.resetModules();
-});
+import PermissionTransferEntity from "./permissionTransferEntity";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
 
 describe("Permission transfer entity", () => {
   it("schema must validate", () => {
@@ -39,11 +32,11 @@ describe("Permission transfer entity", () => {
   });
 
   it("constructor fails if dto is empty", () => {
-    const dto = {}
+    const dto = {};
     try {
       new PermissionTransferEntity(dto);
       expect(true).toBe(false);
-    } catch(error) {
+    } catch (error) {
       expect((error instanceof EntityValidationError)).toBe(true);
       expect(error.hasError('aco_foreign_key')).toBe(true);
       expect(error.hasError('id')).toBe(true);
@@ -54,11 +47,11 @@ describe("Permission transfer entity", () => {
     const dto = {
       id: 'not uuid',
       aco_foreign_key: 'not uuid',
-    }
+    };
     try {
       new PermissionTransferEntity(dto);
       expect(true).toBe(false);
-    } catch(error) {
+    } catch (error) {
       expect((error instanceof EntityValidationError)).toBe(true);
       expect(error.hasError('aco_foreign_key')).toBe(true);
       expect(error.hasError('id')).toBe(true);
@@ -72,7 +65,7 @@ describe("Permission transfer entity", () => {
     try {
       new PermissionTransferEntity(dto);
       expect(true).toBe(false);
-    } catch(error) {
+    } catch (error) {
       expect((error instanceof EntityValidationError)).toBe(true);
       expect(error.hasError('id')).toBe(true);
     }
@@ -85,7 +78,7 @@ describe("Permission transfer entity", () => {
     try {
       new PermissionTransferEntity(dto);
       expect(true).toBe(false);
-    } catch(error) {
+    } catch (error) {
       expect((error instanceof EntityValidationError)).toBe(true);
       expect(error.hasError('aco_foreign_key')).toBe(true);
     }