@webiny/app-aco 5.43.2-beta.0 → 6.0.0-alpha.0

package/features/folders/updateFolder/UpdateFolder.test.js

@@ -1,43 +1,36 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-var _UpdateFolder = require("./UpdateFolder");
-var _FoldersCacheFactory = require("../cache/FoldersCacheFactory");
-var _Folder = require("../Folder");
-var _constants = require("../../../constants");
-describe("UpdateFolder", function () {
-  var type = "abc";
-  var foldersCache = _FoldersCacheFactory.folderCacheFactory.getCache(type);
-  beforeEach(function () {
+import { UpdateFolder } from "./UpdateFolder";
+import { folderCacheFactory } from "../cache/FoldersCacheFactory";
+import { Folder } from "../Folder";
+import { ROOT_FOLDER } from "../../../constants";
+describe("UpdateFolder", () => {
+  const type = "abc";
+  const foldersCache = folderCacheFactory.getCache(type);
+  beforeEach(() => {
     jest.clearAllMocks();
     foldersCache.clear();
-    foldersCache.addItems([_Folder.Folder.create({
+    foldersCache.addItems([Folder.create({
       id: "any-folder-id",
       title: "Any Folder",
       slug: "any-folder",
       parentId: null,
       permissions: [],
-      type: type
+      type
     })]);
   });
-  it("should be able to update a folder", async function () {
-    var gateway = {
+  it("should be able to update a folder", async () => {
+    const gateway = {
       execute: jest.fn().mockResolvedValue({
         id: "any-folder-id",
         title: "Updated Folder",
         slug: "updated-folder",
         parentId: "another-id",
         permissions: [],
-        type: type
+        type
       })
     };
-    var updateFolder = _UpdateFolder.UpdateFolder.getInstance(type, gateway);
+    const updateFolder = UpdateFolder.getInstance(type, gateway);
     expect(foldersCache.hasItems()).toBeTrue();
-    var item = foldersCache.getItem(function (folder) {
-      return folder.id === "any-folder-id";
-    });
+    const item = foldersCache.getItem(folder => folder.id === "any-folder-id");
     expect(item?.id).toEqual("any-folder-id");
     expect(item?.title).toEqual("Any Folder");
     await updateFolder.execute({
@@ -46,12 +39,10 @@ describe("UpdateFolder", function () {
       slug: "updated-folder",
       parentId: "another-id",
       permissions: [],
-      type: type
+      type
     });
     expect(gateway.execute).toHaveBeenCalledTimes(1);
-    var updatedItem = foldersCache.getItem(function (folder) {
-      return folder.id === "any-folder-id";
-    });
+    const updatedItem = foldersCache.getItem(folder => folder.id === "any-folder-id");
     expect(updatedItem).toBeDefined();
     expect(updatedItem?.id).toEqual("any-folder-id");
     expect(updatedItem?.type).toEqual(type);
@@ -59,23 +50,21 @@ describe("UpdateFolder", function () {
     expect(updatedItem?.slug).toEqual("updated-folder");
     expect(updatedItem?.parentId).toEqual("another-id");
   });
-  it("should not update a folder if id is missing", async function () {
-    var gateway = {
+  it("should not update a folder if id is missing", async () => {
+    const gateway = {
       execute: jest.fn().mockResolvedValue(null)
     };
-    var updateFolder = _UpdateFolder.UpdateFolder.getInstance(type, gateway);
+    const updateFolder = UpdateFolder.getInstance(type, gateway);
     await updateFolder.execute({
       id: "",
       title: "Updated Folder",
       slug: "updated-folder",
       parentId: "another-id",
       permissions: [],
-      type: type
+      type
     });
     expect(gateway.execute).toHaveBeenCalledTimes(1);
-    var updatedItem = foldersCache.getItem(function (folder) {
-      return folder.id === "any-folder-id";
-    });
+    const updatedItem = foldersCache.getItem(folder => folder.id === "any-folder-id");
     expect(updatedItem).toBeDefined();
     expect(updatedItem?.id).toEqual("any-folder-id");
     expect(updatedItem?.type).toEqual(type);
@@ -83,44 +72,44 @@ describe("UpdateFolder", function () {
     expect(updatedItem?.slug).toEqual("any-folder");
     expect(updatedItem?.parentId).toEqual(null);
   });
-  it("should propagate `permissions` changes to child folders", async function () {
-    var parentFolder = _Folder.Folder.create({
+  it("should propagate `permissions` changes to child folders", async () => {
+    const parentFolder = Folder.create({
       id: "parent-folder-id",
       title: "Parent Folder",
       slug: "parent-folder",
       parentId: null,
       permissions: [],
-      type: type
+      type
     });
-    var childFolder1 = _Folder.Folder.create({
+    const childFolder1 = Folder.create({
       id: "child-folder-id-1",
       title: "Child Folder 1",
       slug: "child-folder-1",
       parentId: parentFolder.id,
       permissions: [],
-      type: type
+      type
     });
-    var childFolder2 = _Folder.Folder.create({
+    const childFolder2 = Folder.create({
       id: "child-folder-id-2",
       title: "Child Folder 2",
       slug: "child-folder-2",
       parentId: childFolder1.id,
       permissions: [],
-      type: type
+      type
     });
-    var childFolder3 = _Folder.Folder.create({
+    const childFolder3 = Folder.create({
       id: "child-folder-id-3",
       title: "Child Folder 3",
       slug: "child-folder-3",
       parentId: parentFolder.id,
       // <-- This folder is a sibling of childFolder1, not a child
       permissions: [],
-      type: type
+      type
     });
     foldersCache.addItems([parentFolder, childFolder1, childFolder2, childFolder3]);
 
     // Let's update parentFolder, the change should be propagated to all it's children (childFolder1, childFolder2 and childFolder3).
-    var parentNewPermissions = [{
+    const parentNewPermissions = [{
       level: "viewer",
       target: "admin:123"
     }, {
@@ -128,195 +117,171 @@ describe("UpdateFolder", function () {
       target: "admin:456"
     }];
     {
-      var gateway = {
+      const gateway = {
         execute: jest.fn().mockResolvedValue({
           id: parentFolder.id,
           title: parentFolder.title,
           slug: parentFolder.slug,
           parentId: parentFolder.parentId,
           permissions: parentNewPermissions,
-          type: type
+          type
         })
       };
-      var updateFolder = _UpdateFolder.UpdateFolder.getInstance(type, gateway);
+      const updateFolder = UpdateFolder.getInstance(type, gateway);
       await updateFolder.execute({
         id: parentFolder.id,
         title: parentFolder.title,
         slug: parentFolder.slug,
         parentId: parentFolder.parentId,
         permissions: parentNewPermissions,
-        type: type
-      });
-      var childFolderCache1 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder1.id;
-      });
-      expect(childFolderCache1?.permissions).toEqual(parentNewPermissions.map(function (permission) {
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, permission), {}, {
-          inheritedFrom: "parent:".concat(parentFolder?.id)
-        });
-      }));
-      var childFolderCache2 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder2.id;
+        type
       });
-      expect(childFolderCache2?.permissions).toEqual(parentNewPermissions.map(function (permission) {
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, permission), {}, {
-          inheritedFrom: "parent:".concat(childFolderCache1?.id)
-        });
-      }));
-      var childFolderCache3 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder3.id;
-      });
-      expect(childFolderCache3?.permissions).toEqual(parentNewPermissions.map(function (permission) {
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, permission), {}, {
-          inheritedFrom: "parent:".concat(parentFolder?.id)
-        });
-      }));
+      const childFolderCache1 = foldersCache.getItem(folder => folder.id === childFolder1.id);
+      expect(childFolderCache1?.permissions).toEqual(parentNewPermissions.map(permission => ({
+        ...permission,
+        inheritedFrom: `parent:${parentFolder?.id}`
+      })));
+      const childFolderCache2 = foldersCache.getItem(folder => folder.id === childFolder2.id);
+      expect(childFolderCache2?.permissions).toEqual(parentNewPermissions.map(permission => ({
+        ...permission,
+        inheritedFrom: `parent:${childFolderCache1?.id}`
+      })));
+      const childFolderCache3 = foldersCache.getItem(folder => folder.id === childFolder3.id);
+      expect(childFolderCache3?.permissions).toEqual(parentNewPermissions.map(permission => ({
+        ...permission,
+        inheritedFrom: `parent:${parentFolder?.id}`
+      })));
     }
 
     // Let's update childFolder1, the change should be propagated to childFolder2, but not to childFolder3
-    var child1NewPermissions = [{
+    const child1NewPermissions = [{
       level: "owner",
       target: "admin:123"
     }];
     {
-      var _gateway = {
+      const gateway = {
         execute: jest.fn().mockResolvedValue({
           id: childFolder1.id,
           title: childFolder1.title,
           slug: childFolder1.slug,
           parentId: childFolder1.parentId,
           permissions: child1NewPermissions,
-          type: type
+          type
         })
       };
-      var _updateFolder = _UpdateFolder.UpdateFolder.getInstance(type, _gateway);
-      await _updateFolder.execute({
+      const updateFolder = UpdateFolder.getInstance(type, gateway);
+      await updateFolder.execute({
         id: childFolder1.id,
         title: childFolder1.title,
         slug: childFolder1.slug,
         parentId: childFolder1.parentId,
         permissions: child1NewPermissions,
-        type: type
-      });
-      var _childFolderCache = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder1.id;
-      });
-      expect(_childFolderCache?.permissions).toEqual([].concat(child1NewPermissions, [(0, _objectSpread2.default)((0, _objectSpread2.default)({}, parentNewPermissions[1]), {}, {
-        inheritedFrom: "parent:".concat(parentFolder?.id)
-      })]));
-      var _childFolderCache2 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder2.id;
-      });
-      expect(_childFolderCache2?.permissions).toEqual([].concat((0, _toConsumableArray2.default)(child1NewPermissions.map(function (permission) {
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, permission), {}, {
-          inheritedFrom: "parent:".concat(_childFolderCache?.id)
-        });
-      })), [(0, _objectSpread2.default)((0, _objectSpread2.default)({}, parentNewPermissions[1]), {}, {
-        inheritedFrom: "parent:".concat(_childFolderCache?.id)
-      })]));
-      var _childFolderCache3 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder3.id;
+        type
       });
-      expect(_childFolderCache3?.permissions).toEqual(parentNewPermissions.map(function (permission) {
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, permission), {}, {
-          inheritedFrom: "parent:".concat(parentFolder?.id)
-        });
-      }));
+      const childFolderCache1 = foldersCache.getItem(folder => folder.id === childFolder1.id);
+      expect(childFolderCache1?.permissions).toEqual([...child1NewPermissions, {
+        ...parentNewPermissions[1],
+        inheritedFrom: `parent:${parentFolder?.id}`
+      }]);
+      const childFolderCache2 = foldersCache.getItem(folder => folder.id === childFolder2.id);
+      expect(childFolderCache2?.permissions).toEqual([...child1NewPermissions.map(permission => ({
+        ...permission,
+        inheritedFrom: `parent:${childFolderCache1?.id}`
+      })), {
+        ...parentNewPermissions[1],
+        inheritedFrom: `parent:${childFolderCache1?.id}`
+      }]);
+      const childFolderCache3 = foldersCache.getItem(folder => folder.id === childFolder3.id);
+      expect(childFolderCache3?.permissions).toEqual(parentNewPermissions.map(permission => ({
+        ...permission,
+        inheritedFrom: `parent:${parentFolder?.id}`
+      })));
     }
     {
       // Let's remove childFolder1 permissions:
       // childFolder1 should inherit back permissions from parentFolder,
       // the change should be propagated to childFolder2, but not to childFolder3
-      var newPermissions = [];
-      var _gateway2 = {
+      const newPermissions = [];
+      const gateway = {
         execute: jest.fn().mockResolvedValue({
           id: childFolder1.id,
           title: childFolder1.title,
           slug: childFolder1.slug,
           parentId: childFolder1.parentId,
           permissions: newPermissions,
-          type: type
+          type
         })
       };
-      var _updateFolder2 = _UpdateFolder.UpdateFolder.getInstance(type, _gateway2);
-      await _updateFolder2.execute({
+      const updateFolder = UpdateFolder.getInstance(type, gateway);
+      await updateFolder.execute({
         id: childFolder1.id,
         title: childFolder1.title,
         slug: childFolder1.slug,
         parentId: childFolder1.parentId,
         permissions: newPermissions,
-        type: type
-      });
-      var _childFolderCache4 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder1.id;
-      });
-      expect(_childFolderCache4?.permissions).toEqual(parentNewPermissions.map(function (permission) {
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, permission), {}, {
-          inheritedFrom: "parent:".concat(parentFolder?.id)
-        });
-      }));
-      var _childFolderCache5 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder2.id;
+        type
       });
-      expect(_childFolderCache5?.permissions).toEqual(parentNewPermissions.map(function (permission) {
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, permission), {}, {
-          inheritedFrom: "parent:".concat(_childFolderCache4?.id)
-        });
-      }));
-      var _childFolderCache6 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder3.id;
-      });
-      expect(_childFolderCache6?.permissions).toEqual(parentNewPermissions.map(function (permission) {
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, permission), {}, {
-          inheritedFrom: "parent:".concat(parentFolder?.id)
-        });
-      }));
+      const childFolderCache1 = foldersCache.getItem(folder => folder.id === childFolder1.id);
+      expect(childFolderCache1?.permissions).toEqual(parentNewPermissions.map(permission => ({
+        ...permission,
+        inheritedFrom: `parent:${parentFolder?.id}`
+      })));
+      const childFolderCache2 = foldersCache.getItem(folder => folder.id === childFolder2.id);
+      expect(childFolderCache2?.permissions).toEqual(parentNewPermissions.map(permission => ({
+        ...permission,
+        inheritedFrom: `parent:${childFolderCache1?.id}`
+      })));
+      const childFolderCache3 = foldersCache.getItem(folder => folder.id === childFolder3.id);
+      expect(childFolderCache3?.permissions).toEqual(parentNewPermissions.map(permission => ({
+        ...permission,
+        inheritedFrom: `parent:${parentFolder?.id}`
+      })));
     }
   });
-  it("should propagate `path` changes to child folders", async function () {
-    var parentFolder = _Folder.Folder.create({
+  it("should propagate `path` changes to child folders", async () => {
+    const parentFolder = Folder.create({
       id: "parent-folder-id",
       title: "Parent Folder",
       slug: "parent-folder",
       parentId: null,
       permissions: [],
-      path: "".concat(_constants.ROOT_FOLDER, "/parent-folder"),
-      type: type
+      path: `${ROOT_FOLDER}/parent-folder`,
+      type
     });
-    var childFolder1 = _Folder.Folder.create({
+    const childFolder1 = Folder.create({
       id: "child-folder-id-1",
       title: "Child Folder 1",
       slug: "child-folder-1",
       parentId: parentFolder.id,
       permissions: [],
-      path: "".concat(_constants.ROOT_FOLDER, "/parent-folder/child-folder-1"),
-      type: type
+      path: `${ROOT_FOLDER}/parent-folder/child-folder-1`,
+      type
     });
-    var childFolder2 = _Folder.Folder.create({
+    const childFolder2 = Folder.create({
       id: "child-folder-id-2",
       title: "Child Folder 2",
       slug: "child-folder-2",
       parentId: childFolder1.id,
       permissions: [],
-      path: "".concat(_constants.ROOT_FOLDER, "/parent-folder/child-folder-1/child-folder-2"),
-      type: type
+      path: `${ROOT_FOLDER}/parent-folder/child-folder-1/child-folder-2`,
+      type
     });
-    var childFolder3 = _Folder.Folder.create({
+    const childFolder3 = Folder.create({
       id: "child-folder-id-3",
       title: "Child Folder 3",
       slug: "child-folder-3",
       parentId: parentFolder.id,
       // <-- This folder is a sibling of childFolder1, not a child
       permissions: [],
-      path: "".concat(_constants.ROOT_FOLDER, "/parent-folder/child-folder-3"),
-      type: type
+      path: `${ROOT_FOLDER}/parent-folder/child-folder-3`,
+      type
     });
     foldersCache.addItems([parentFolder, childFolder1, childFolder2, childFolder3]);
 
     // Let's update parentFolder, the change should be propagated to all it's children (childFolder1, childFolder2 and childFolder3).
-    var newParentPath = "".concat(_constants.ROOT_FOLDER, "/parent-folder-edit");
+    const newParentPath = `${ROOT_FOLDER}/parent-folder-edit`;
     {
-      var gateway = {
+      const gateway = {
         execute: jest.fn().mockResolvedValue({
           id: parentFolder.id,
           title: parentFolder.title,
@@ -324,36 +289,30 @@ describe("UpdateFolder", function () {
           parentId: parentFolder.parentId,
           permissions: parentFolder.permissions,
           path: newParentPath,
-          type: type
+          type
         })
       };
-      var updateFolder = _UpdateFolder.UpdateFolder.getInstance(type, gateway);
+      const updateFolder = UpdateFolder.getInstance(type, gateway);
       await updateFolder.execute({
         id: parentFolder.id,
         title: parentFolder.title,
         slug: parentFolder.slug + "-edit",
         parentId: parentFolder.parentId,
         permissions: parentFolder.permissions,
-        type: type
-      });
-      var childFolderCache1 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder1.id;
-      });
-      expect(childFolderCache1?.path).toEqual("".concat(newParentPath, "/child-folder-1"));
-      var childFolderCache2 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder2.id;
+        type
       });
-      expect(childFolderCache2?.path).toEqual("".concat(newParentPath, "/child-folder-1/child-folder-2"));
-      var childFolderCache3 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder3.id;
-      });
-      expect(childFolderCache3?.path).toEqual("".concat(newParentPath, "/child-folder-3"));
+      const childFolderCache1 = foldersCache.getItem(folder => folder.id === childFolder1.id);
+      expect(childFolderCache1?.path).toEqual(`${newParentPath}/child-folder-1`);
+      const childFolderCache2 = foldersCache.getItem(folder => folder.id === childFolder2.id);
+      expect(childFolderCache2?.path).toEqual(`${newParentPath}/child-folder-1/child-folder-2`);
+      const childFolderCache3 = foldersCache.getItem(folder => folder.id === childFolder3.id);
+      expect(childFolderCache3?.path).toEqual(`${newParentPath}/child-folder-3`);
     }
 
     // Let's update childFolder1, the change should be propagated to childFolder2, but not to childFolder3
-    var newChildFolder1Path = "".concat(newParentPath, "/child-folder-1-edit");
+    const newChildFolder1Path = `${newParentPath}/child-folder-1-edit`;
     {
-      var _gateway3 = {
+      const gateway = {
         execute: jest.fn().mockResolvedValue({
           id: childFolder1.id,
           title: childFolder1.title,
@@ -361,44 +320,38 @@ describe("UpdateFolder", function () {
           parentId: childFolder1.parentId,
           permissions: childFolder1.permissions,
           path: newChildFolder1Path,
-          type: type
+          type
         })
       };
-      var _updateFolder3 = _UpdateFolder.UpdateFolder.getInstance(type, _gateway3);
-      await _updateFolder3.execute({
+      const updateFolder = UpdateFolder.getInstance(type, gateway);
+      await updateFolder.execute({
         id: childFolder1.id,
         title: childFolder1.title,
         slug: childFolder1.slug + "-edit",
         parentId: childFolder1.parentId,
         permissions: childFolder1.permissions,
-        type: type
-      });
-      var _childFolderCache7 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder1.id;
-      });
-      expect(_childFolderCache7?.path).toEqual(newChildFolder1Path);
-      var _childFolderCache8 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder2.id;
-      });
-      expect(_childFolderCache8?.path).toEqual("".concat(newChildFolder1Path, "/child-folder-2"));
-      var _childFolderCache9 = foldersCache.getItem(function (folder) {
-        return folder.id === childFolder3.id;
+        type
       });
-      expect(_childFolderCache9?.path).toEqual("".concat(newParentPath, "/child-folder-3"));
+      const childFolderCache1 = foldersCache.getItem(folder => folder.id === childFolder1.id);
+      expect(childFolderCache1?.path).toEqual(newChildFolder1Path);
+      const childFolderCache2 = foldersCache.getItem(folder => folder.id === childFolder2.id);
+      expect(childFolderCache2?.path).toEqual(`${newChildFolder1Path}/child-folder-2`);
+      const childFolderCache3 = foldersCache.getItem(folder => folder.id === childFolder3.id);
+      expect(childFolderCache3?.path).toEqual(`${newParentPath}/child-folder-3`);
     }
   });
-  it("should handle gateway errors gracefully", async function () {
-    var gateway = {
+  it("should handle gateway errors gracefully", async () => {
+    const gateway = {
       execute: jest.fn().mockRejectedValue(new Error("Gateway error"))
     };
-    var updateFolder = _UpdateFolder.UpdateFolder.getInstance(type, gateway);
+    const updateFolder = UpdateFolder.getInstance(type, gateway);
     await expect(updateFolder.execute({
       id: "any-folder-id",
       title: "Updated Folder",
       slug: "updated-folder",
       parentId: "another-id",
       permissions: [],
-      type: type
+      type
     })).rejects.toThrow("Gateway error");
     expect(gateway.execute).toHaveBeenCalledTimes(1);
   });