passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/model/entity/favorite/favoriteEntity.test.js

@@ -11,72 +11,126 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         2.13.0
  */
-import {FavoriteEntity} from "./favoriteEntity";
-import {EntitySchema} from "../abstract/entitySchema";
-import Validator from 'validator';
-import {EntityValidationError} from "../abstract/entityValidationError";
+import FavoriteEntity from "./favoriteEntity";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
+import {defaultFavoriteDto} from "passbolt-styleguide/src/shared/models/entity/favorite/favoriteEntity.test.data";
+import each from "jest-each";
 
-// Reset the modules before each test.
-beforeEach(() => {
-  window.Validator = Validator;
-  jest.resetModules();
-});
+describe("FavoriteEntity", () => {
+  describe("FavoriteEntity:constructor", () => {
+    it("schema must validate", () => {
+      EntitySchema.validateSchema(FavoriteEntity.ENTITY_NAME, FavoriteEntity.getSchema());
+    });
 
-describe("Favorite entity", () => {
-  it("schema must validate", () => {
-    EntitySchema.validateSchema(FavoriteEntity.ENTITY_NAME, FavoriteEntity.getSchema());
-  });
+    it("constructor works if valid minimal DTO is provided", () => {
+      const dto = defaultFavoriteDto();
+      const entity = new FavoriteEntity(dto);
+      expect(entity.id).toEqual(dto.id);
+      expect(entity.userId).toEqual(dto.user_id);
+      expect(entity.foreignKey).toEqual(dto.foreign_key);
+      expect(entity.created).toEqual("2020-08-27T08:35:21+00:00");
+    });
 
-  it("constructor works if valid minimal DTO is provided", () => {
-    const dto = {
-      "id": "45ce85c9-e301-4de2-8b41-298507002861",
-      "user_id": "d57c10f5-633d-5160-9c81-8a0c6c4ec856",
-      "foreign_key": "10801423-4121-42a4-99d1-86e66145a08c",
-      //"foreign_model": "Resource",
-      "created": "2020-05-06T21:59:24+00:00",
-      // "modified": "2020-05-06T21:59:24+00:00"
-    };
-    const entity = new FavoriteEntity(dto);
-    expect(entity.toDto()).toEqual(dto);
-  });
-
-  it("constructor returns validation error if dto required fields are missing", () => {
-    try {
-      new FavoriteEntity({
-        "created": "2020-05-06T21:59:24+00:00",
-        "modified": "2020-05-06T21:59:24+00:00"
+    // Validate id
+    each([
+      {scenario: 'required', rule: 'type'},
+      {scenario: 'not null', rule: 'type', value: null},
+      {scenario: 'valid uuid', rule: 'format', value: 'invalid-id'},
+      {scenario: 'valid format', rule: 'type', value: 42},
+    ]).describe("Should validate the id", test => {
+      it(`Should not accept: ${test.scenario}`, async() => {
+        expect.assertions(2);
+        const dto = defaultFavoriteDto({
+          id: test.value
+        });
+        try {
+          new FavoriteEntity(dto);
+        } catch (error) {
+          expect(error).toBeInstanceOf(EntityValidationError);
+          expect(error.hasError('id', test.rule)).toBeTruthy();
+        }
       });
-    } catch(error) {
-      expect(error instanceof EntityValidationError).toBe(true);
-      expect(error.details).toEqual( {
-        id: { required: 'The id is required.' },
-        user_id: { required: 'The user_id is required.' },
-        foreign_key: { required: 'The foreign_key is required.' },
-        //foreign_model: { required: 'The foreign_model is required.' }
+    });
+
+    // Validate user_id
+    each([
+      {scenario: 'required', rule: 'type'},
+      {scenario: 'not null', rule: 'type', value: null},
+      {scenario: 'valid uuid', rule: 'format', value: 'invalid-id'},
+      {scenario: 'valid format', rule: 'type', value: 42},
+    ]).describe("Should validate the user_id", test => {
+      it(`Should not accept: ${test.scenario}`, async() => {
+        expect.assertions(2);
+        const dto = defaultFavoriteDto({
+          user_id: test.value
+        });
+        try {
+          new FavoriteEntity(dto);
+        } catch (error) {
+          expect(error).toBeInstanceOf(EntityValidationError);
+          expect(error.hasError('user_id', test.rule)).toBeTruthy();
+        }
       });
-    }
-  });
+    });
 
-  it("constructor returns validation error if dto required fields are missing", () => {
-    try {
-      new FavoriteEntity({
-        "id": "🌪️",
-        "user_id": "🌪️",
-        "foreign_key": "🌪️",
-        "foreign_model": "🌈️",
-        "created": "🔮",
-        "modified": "👠👠"
+    // Validate foreign_key
+    each([
+      {scenario: 'required', rule: 'type'},
+      {scenario: 'not null', rule: 'type', value: null},
+      {scenario: 'valid uuid', rule: 'format', value: 'invalid-id'},
+      {scenario: 'valid format', rule: 'type', value: 42},
+    ]).describe("Should validate the foreign_key", test => {
+      it(`Should not accept: ${test.scenario}`, async() => {
+        expect.assertions(2);
+        const dto = defaultFavoriteDto({
+          foreign_key: test.value
+        });
+        try {
+          new FavoriteEntity(dto);
+        } catch (error) {
+          expect(error).toBeInstanceOf(EntityValidationError);
+          expect(error.hasError('foreign_key', test.rule)).toBeTruthy();
+        }
       });
-    } catch(error) {
-      expect(error instanceof EntityValidationError).toBe(true);
-      expect(error.details).toEqual({
-        id: { format: 'The id is not a valid uuid.' },
-        user_id: { format: 'The user_id is not a valid uuid.' },
-        foreign_key: { format: 'The foreign_key is not a valid uuid.' },
-        //foreign_model: { enum: 'The foreign_model value is not included in the supported list.'},
-        created: { format: 'The created is not a valid date-time.' },
-        //modified: { format: 'The modified is not a valid date-time.' }
+    });
+
+    each([
+      {scenario: 'required', rule: 'type'},
+      {scenario: 'is not required but cannot be null', rule: null},
+      {scenario: 'valid url object', rule: 'type', value: 42},
+    ]).describe("Should validate the created", test => {
+      it(`Should not accept: ${test.scenario}`, async() => {
+        expect.assertions(2);
+        const dto = defaultFavoriteDto({
+          created: test.value
+        });
+        try {
+          new FavoriteEntity(dto);
+        } catch (error) {
+          expect(error).toBeInstanceOf(EntityValidationError);
+          expect(error.hasError('created', test.rule)).toBeTruthy();
+        }
       });
-    }
+    });
+  });
+
+  describe("FavoriteEntity:toDto", () => {
+    it("should return the expected properties.", () => {
+      expect.assertions(2);
+      const expectedKeys = [
+        "id",
+        "user_id",
+        "foreign_key",
+        "created",
+      ];
+
+      const dto = defaultFavoriteDto();
+      const entity = new FavoriteEntity(dto);
+      const resultDto = entity.toDto();
+      const keys = Object.keys(resultDto);
+      expect(keys).toEqual(expectedKeys);
+      expect(Object.keys(resultDto).length).toBe(expectedKeys.length);
+    });
   });
 });

package/src/all/background_page/model/entity/folder/external/externalFolderEntity.js

@@ -10,21 +10,20 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {FolderEntity} = require("../folderEntity");
-const {Entity} = require('../../abstract/entity');
-const {EntitySchema} = require('../../abstract/entitySchema');
-const {EntityValidationError} = require('../../abstract/entityValidationError');
+import FolderEntity from "../folderEntity";
+import Entity from "passbolt-styleguide/src/shared/models/entity/abstract/entity";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
 
 const ENTITY_NAME = 'ExternalFolder';
 
 class ExternalFolderEntity extends Entity {
   /**
-   * External folder entity constructor
-   *
-   * @param {Object} externalFolderDto external folder DTO
-   * @throws EntityValidationError if the dto cannot be converted into an entity
+   * @inheritDoc
+   * Sanitize:
+   * - Override default data using the data provided in the DTO.
+   * - Normalize the folder parent path, see ExternalFolderEntity::sanitizePath
    */
-  constructor(externalFolderDto) {
+  constructor(externalFolderDto, options = {}) {
     // Default properties values
     const props = Object.assign(ExternalFolderEntity.getDefault(), externalFolderDto);
 
@@ -38,7 +37,7 @@ class ExternalFolderEntity extends Entity {
       ExternalFolderEntity.ENTITY_NAME,
       props,
       ExternalFolderEntity.getSchema()
-    ));
+    ), options);
   }
 
   /**
@@ -48,7 +47,7 @@ class ExternalFolderEntity extends Entity {
   static getDefault() {
     return {
       "folder_parent_path": ""
-    }
+    };
   }
 
   /**
@@ -64,16 +63,13 @@ class ExternalFolderEntity extends Entity {
       ],
       "properties": {
         "id": folderEntitySchema.properties.id,
-        "name": {
-          ...folderEntitySchema.properties.name,
-          "pattern": /^[^\/]*$/
-        },
+        "name": folderEntitySchema.properties.name,
         "folder_parent_id": folderEntitySchema.properties.folder_parent_id,
         "folder_parent_path": {
           "type": "string"
         }
       }
-    }
+    };
   }
 
   /**
@@ -83,7 +79,7 @@ class ExternalFolderEntity extends Entity {
    */
   static createFromPath(path) {
     path = ExternalFolderEntity.sanitizePath(path);
-    const chunks = path.split('/');
+    const chunks = ExternalFolderEntity.splitFolderPath(path);
     const externalFolderDto = {
       name: chunks.pop(),
       folder_parent_path: chunks.join('/')
@@ -91,9 +87,11 @@ class ExternalFolderEntity extends Entity {
     return new ExternalFolderEntity(externalFolderDto);
   }
 
-  // ==================================================
-  // Format / normalize
-  // ==================================================
+  /*
+   * ==================================================
+   * Format / normalize
+   * ==================================================
+   */
 
   /**
    * Normalize format path.
@@ -103,15 +101,55 @@ class ExternalFolderEntity extends Entity {
    */
   static sanitizePath(path) {
     path = path || "";
-    path = path.replace(/[ \/]*\/[ \/]*/g, '/') // Replace any combinations of space and / by one unique /
-      .replace(/^\/*|\/*$/g, '') // Remove first and last /
-      .trim() // Remove first and last spaces;
-    return path;
+    return path
+      .replace(/^(\/{2,})|(\/{2,})$/g, '/') //replace any group of starting or ending slash by a single slash
+      .replace(/^(\/(?! ))|((?<! )\/)$/g, '') //remove starting '/' not followed by a space or an ending '/' not preceded by a space
+      .replace(/(?<! )(\/{2,})(?! )/g, '/'); //replace any group of multiple / that are not prefixed or suffixed by a space
+  }
+
+  /**
+   * Split folder path while considering a non separator regex.
+   * The non separator is ' / ' expecting that this is the one used while importing or exporting resources.
+   * ie: root/path/un / splittedPath => ['root', 'path', 'un/splittedPath']
+   * @param {string} path The path to split
+   * @return {array<string>}
+   */
+  static splitFolderPath(path) {
+    return path.split(/(?<! )\/(?! )/g);
+  }
+
+  /**
+   * Escape a folder name by adding spaces around slashes to escape them and not confuse them with a directory separator.
+   * A trim is applied to avoid issues with folder export/import when they by ' /'.
+   * @param {string} name
+   */
+  static escapeName(name) {
+    name = name || "";
+    return name
+      .trim()
+      .replace(/^\//, '/ ') // replace a starting '/' by '/ '
+      .replace(/\/$/, ' /') // replace an ending '/' by ' /'
+      .replace(/(.)\/(.)/g, '$1 / $2'); //replace all "middle" '/' by ' / '
+  }
+
+  /**
+   * Removes the extra spaces in a folder name that are added to differentiate slashes between directory seperator from the ones part of the name.
+   * ie: '/ folder' => '/folder'
+   * ie: 'folder /' => 'folder/'
+   * ie: 'fol / der' => 'fol/der'
+   * @param {string} name The name from where to remove extra spaces
+   * @return {string}
+   */
+  static resolveEscapedName(name) {
+    name = name || "";
+    return name.replace(/ \/ | \/|\/ /g, '/'); //replace any ' / ', ' /', '/ ' (slash with spaces) by a single '/'
   }
 
-  // ==================================================
-  // Serialization
-  // ==================================================
+  /*
+   * ==================================================
+   * Serialization
+   * ==================================================
+   */
 
   /**
    * Return a DTO ready to be sent to API
@@ -130,9 +168,11 @@ class ExternalFolderEntity extends Entity {
     return this.toDto();
   }
 
-  // ==================================================
-  // Dynamic properties getters / setters
-  // ==================================================
+  /*
+   * ==================================================
+   * Dynamic properties getters / setters
+   * ==================================================
+   */
 
   /**
    * Get folder id
@@ -190,9 +230,11 @@ class ExternalFolderEntity extends Entity {
     this._props.folder_parent_path = folderParentPath;
   }
 
-  // ==================================================
-  // Calculated properties getters
-  // ==================================================
+  /*
+   * ==================================================
+   * Calculated properties getters
+   * ==================================================
+   */
 
   /**
    * Get folder path
@@ -207,12 +249,14 @@ class ExternalFolderEntity extends Entity {
    * @returns {int} the depth
    */
   get depth() {
-    return this.folderParentPath ? this.folderParentPath.split('/').length : 0;
+    return this.folderParentPath ? ExternalFolderEntity.splitFolderPath(this.folderParentPath).length : 0;
   }
 
-  // ==================================================
-  // Setters
-  // ==================================================
+  /*
+   * ==================================================
+   * Setters
+   * ==================================================
+   */
 
   /**
    * Move folder at a new root
@@ -226,9 +270,11 @@ class ExternalFolderEntity extends Entity {
     }
   }
 
-  // ==================================================
-  // Static properties getters
-  // ==================================================
+  /*
+   * ==================================================
+   * Static properties getters
+   * ==================================================
+   */
 
   /**
    * ExternalFolderEntity.ENTITY_NAME
@@ -239,4 +285,4 @@ class ExternalFolderEntity extends Entity {
   }
 }
 
-exports.ExternalFolderEntity = ExternalFolderEntity;
+export default ExternalFolderEntity;

package/src/all/background_page/model/entity/folder/external/externalFolderEntity.test.js

@@ -10,16 +10,9 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-import Validator from "validator";
-import {EntityValidationError} from "../../abstract/entityValidationError";
-import {EntitySchema} from "../../abstract/entitySchema";
-import {ExternalFolderEntity} from "./externalFolderEntity";
-
-// Reset the modules before each test.
-beforeEach(() => {
-  window.Validator = Validator;
-  jest.resetModules();
-});
+import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import ExternalFolderEntity from "./externalFolderEntity";
 
 describe("ExternalFolderEntity", () => {
   it("schema must validate", () => {
@@ -33,7 +26,7 @@ describe("ExternalFolderEntity", () => {
     const result = {
       "name": "folder",
       "folder_parent_path": ""
-    }
+    };
     const entity = new ExternalFolderEntity(dto);
     expect(entity.toDto()).toEqual(result);
     expect(entity.name).toEqual("folder");
@@ -56,10 +49,10 @@ describe("ExternalFolderEntity", () => {
   it("constructor sanitize folder_parent_path", () => {
     const dto = {
       "name": "folder",
-      "folder_parent_path": "// at/ the///root /"
+      "folder_parent_path": "// at/ the///root //"
     };
     const entity = new ExternalFolderEntity(dto);
-    expect(entity.folderParentPath).toEqual("at/the/root");
+    expect(entity.folderParentPath).toEqual("/ at/ the/root /");
   });
 
   it("constructor returns validation error if dto fields are invalid", () => {
@@ -79,8 +72,8 @@ describe("ExternalFolderEntity", () => {
   it("createFromPath constructs a folder from a path", () => {
     const path = "// at/ the///root /";
     const entity = ExternalFolderEntity.createFromPath(path);
-    expect(entity.name).toEqual("root");
-    expect(entity.folderParentPath).toEqual("at/the");
+    expect(entity.name).toEqual("root /");
+    expect(entity.folderParentPath).toEqual("/ at/ the");
   });
 
   it("sanitize sanitizes a path", () => {
@@ -88,16 +81,88 @@ describe("ExternalFolderEntity", () => {
     expect(ExternalFolderEntity.sanitizePath(path)).toEqual("");
     path = "/root/";
     expect(ExternalFolderEntity.sanitizePath(path)).toEqual("root");
-    path = "/  root  / / ////  folder1 /folder2   /// /";
-    expect(ExternalFolderEntity.sanitizePath(path)).toEqual("root/folder1/folder2");
+    path = "///  root  / / ////  folder1 /folder2   /// ///";
+    expect(ExternalFolderEntity.sanitizePath(path)).toEqual("/  root  / / ///  folder1 /folder2   /// /");
   });
 
   it("changeRootPath change the folder root path", () => {
-    const rootFolder = new ExternalFolderEntity({"name": "root"})
+    const rootFolder = new ExternalFolderEntity({"name": "root"});
     const folder = new ExternalFolderEntity({"name": "Folder 1"});
-    folder.changeRootPath(rootFolder)
+    folder.changeRootPath(rootFolder);
     expect(folder.folderParentPath).toEqual("root");
-    folder.changeRootPath(rootFolder)
+    folder.changeRootPath(rootFolder);
     expect(folder.folderParentPath).toEqual("root/root");
   });
+
+  it("should split folder path considering '/' in folder name", () => {
+    const pathToTestAndResult = {
+      "Root/DatabaseCC/Domaine / Windows": ["Root", "DatabaseCC", "Domaine / Windows"],
+      "Root/DatabaseCC/Réseau avocat / Vidéo": ["Root", "DatabaseCC", "Réseau avocat / Vidéo"],
+
+      "/ Root/DatabaseCC/Réseau avocat /": ["/ Root", "DatabaseCC", "Réseau avocat /"],
+      " // Root //DatabaseCC/ / //Réseau avocat / Vidéo // /": [" // Root /", "DatabaseCC/ / /", "Réseau avocat / Vidéo // /"],
+      "/  / Root / /// / DatabaseCC / /": ["/  / Root / /", "/ / DatabaseCC / /"],
+    };
+
+    for (const rawPath in pathToTestAndResult) {
+      const sanitizedPath = ExternalFolderEntity.splitFolderPath(rawPath);
+      const expectedResult = pathToTestAndResult[rawPath];
+      expect(sanitizedPath).toEqual(expectedResult);
+    }
+  });
+
+  it("should escape folder name by adding spaces around '/'", () => {
+    const nameToTestAndResult = {
+      "Root": "Root",
+      " Root ": "Root",
+      "Réseau avocat/Vidéo": "Réseau avocat / Vidéo",
+      "Réseau avocat / Vidéo": "Réseau avocat  /  Vidéo",
+      "///": "/  /  /",
+      "/test/test/": "/ test / test /",
+    };
+
+    for (const rawName in nameToTestAndResult) {
+      const sanitizedPath = ExternalFolderEntity.escapeName(rawName);
+      const expectedResult = nameToTestAndResult[rawName];
+      expect(sanitizedPath).toEqual(expectedResult);
+    }
+  });
+
+  it("should resolve escaped name by removing the extra 'spaces' around '/'", () => {
+    const nameToTestAndResult = {
+      "Root": "Root",
+      " Root ": " Root ",
+      "Réseau avocat/Vidéo": "Réseau avocat/Vidéo",
+      "Réseau avocat / Vidéo": "Réseau avocat/Vidéo",
+      "/  /  /": "///",
+      "/ test / test /": "/test/test/",
+      "  / te / st /  ": " /te/st/ ",
+    };
+
+    for (const rawName in nameToTestAndResult) {
+      const sanitizedPath = ExternalFolderEntity.resolveEscapedName(rawName);
+      const expectedResult = nameToTestAndResult[rawName];
+      expect(sanitizedPath).toEqual(expectedResult);
+    }
+  });
+
+  it("should give the right depth when paths have '/' in folder name", () => {
+    const pathToTestAndResult = {
+      "Root": 1,
+      "Root /": 1,
+      "Root //DatabaseCC": 2,
+      "Root/DatabaseCC/Domaine / Windows": 3,
+      "Root/DatabaseCC/Réseau avocat / Vidéo": 3,
+
+      "/ Root/DatabaseCC/Réseau avocat /": 3,
+      " // Root //DatabaseCC/ / //Réseau avocat / Vidéo // /": 3,
+      "/  / Root / /// / DatabaseCC / /": 2,
+    };
+
+    for (const rawPath in pathToTestAndResult) {
+      const externalFolder = new ExternalFolderEntity({name: "test", folder_parent_path: rawPath});
+      const expectedResult = pathToTestAndResult[rawPath];
+      expect(externalFolder.depth).toEqual(expectedResult);
+    }
+  });
 });