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

package/Presentation/TrashBin/TrashBin.test.js

@@ -1,75 +1,59 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _TrashBinPresenter = require("./TrashBinPresenter");
-var _appUtils = require("@webiny/app-utils");
-var _types = require("../../types");
-var _TrashBinControllers = require("./TrashBinControllers");
-var _Search = require("../../Domain/Repositories/Search");
-var _SelectedItems = require("../../Domain/Repositories/SelectedItems");
-var _Sorting = require("../../Domain/Repositories/Sorting");
-var _TrashBinItems = require("../../Domain/Repositories/TrashBinItems");
-var identity1 = {
+import { TrashBinPresenter } from "./TrashBinPresenter";
+import { LoadingRepository, MetaRepository, SortingRepository } from "@webiny/app-utils";
+import { LoadingActions } from "../../types";
+import { TrashBinControllers } from "./TrashBinControllers";
+import { SearchRepository } from "../../Domain/Repositories/Search";
+import { SelectedItemsRepository } from "../../Domain/Repositories/SelectedItems";
+import { SortingRepositoryWithDefaults } from "../../Domain/Repositories/Sorting";
+import { TrashBinItemsRepository, TrashBinItemsRepositoryWithLoading } from "../../Domain/Repositories/TrashBinItems";
+const identity1 = {
   id: "1234",
   displayName: "John Doe",
   type: "admin"
 };
-var identity2 = {
+const identity2 = {
   id: "5678",
   displayName: "Jane Doe",
   type: "admin"
 };
-var createBinListGateway = function createBinListGateway(_ref) {
-  var execute = _ref.execute;
-  return {
-    execute: execute
-  };
-};
-var createBinDeleteItemGateway = function createBinDeleteItemGateway(_ref2) {
-  var execute = _ref2.execute;
-  return {
-    execute: execute
-  };
-};
-var createBinRestoreItemGateway = function createBinRestoreItemGateway(_ref3) {
-  var execute = _ref3.execute;
-  return {
-    execute: execute
-  };
-};
-var createBinBulkActionsGateway = function createBinBulkActionsGateway(_ref4) {
-  var execute = _ref4.execute;
-  return {
-    execute: execute
-  };
-};
-var CustomItemMapper = /*#__PURE__*/function () {
-  function CustomItemMapper() {
-    (0, _classCallCheck2.default)(this, CustomItemMapper);
+const createBinListGateway = ({
+  execute
+}) => ({
+  execute
+});
+const createBinDeleteItemGateway = ({
+  execute
+}) => ({
+  execute
+});
+const createBinRestoreItemGateway = ({
+  execute
+}) => ({
+  execute
+});
+const createBinBulkActionsGateway = ({
+  execute
+}) => ({
+  execute
+});
+class CustomItemMapper {
+  toDTO(data) {
+    return {
+      id: data.id,
+      title: data.title,
+      location: data.location,
+      createdBy: data.createdBy,
+      deletedOn: data.deletedOn,
+      deletedBy: data.deletedBy
+    };
   }
-  return (0, _createClass2.default)(CustomItemMapper, [{
-    key: "toDTO",
-    value: function toDTO(data) {
-      return {
-        id: data.id,
-        title: data.title,
-        location: data.location,
-        createdBy: data.createdBy,
-        deletedOn: data.deletedOn,
-        deletedBy: data.deletedBy
-      };
-    }
-  }]);
-}();
-var defaultSorting = [{
+}
+const defaultSorting = [{
   field: "deletedOn",
   order: "desc"
 }];
-describe("TrashBin", function () {
-  var item1 = {
+describe("TrashBin", () => {
+  const item1 = {
     id: "item-1",
     title: "Item 1",
     location: {
@@ -80,7 +64,7 @@ describe("TrashBin", function () {
     deletedOn: new Date().toString(),
     custom: "any custom data"
   };
-  var item2 = {
+  const item2 = {
     id: "item-2",
     title: "Item 2",
     location: {
@@ -91,7 +75,7 @@ describe("TrashBin", function () {
     deletedOn: new Date().toString(),
     custom: "any custom data"
   };
-  var item3 = {
+  const item3 = {
     id: "item-3",
     title: "Item 3",
     location: {
@@ -102,7 +86,7 @@ describe("TrashBin", function () {
     deletedOn: new Date().toString(),
     custom: "any custom data"
   };
-  var item4 = {
+  const item4 = {
     id: "item-4",
     title: "Item 4",
     location: {
@@ -113,8 +97,8 @@ describe("TrashBin", function () {
     deletedOn: new Date().toString(),
     custom: "any custom data"
   };
-  var listGateway = createBinListGateway({
-    execute: jest.fn().mockImplementation(function () {
+  const listGateway = createBinListGateway({
+    execute: jest.fn().mockImplementation(() => {
       return Promise.resolve([[item1, item2, item3], {
         totalCount: 3,
         cursor: null,
@@ -122,54 +106,56 @@ describe("TrashBin", function () {
       }]);
     })
   });
-  var deleteItemGateway = createBinDeleteItemGateway({
-    execute: jest.fn().mockImplementation(function () {
+  const deleteItemGateway = createBinDeleteItemGateway({
+    execute: jest.fn().mockImplementation(() => {
       return Promise.resolve(true);
     })
   });
-  var restoreItemGateway = createBinRestoreItemGateway({
-    execute: jest.fn().mockImplementation(function () {
+  const restoreItemGateway = createBinRestoreItemGateway({
+    execute: jest.fn().mockImplementation(() => {
       return Promise.resolve(item1);
     })
   });
-  var bulkActionGateway = createBinBulkActionsGateway({
-    execute: jest.fn().mockImplementation(function () {
+  const bulkActionGateway = createBinBulkActionsGateway({
+    execute: jest.fn().mockImplementation(() => {
       return Promise.resolve({
         id: "123456789"
       });
     })
   });
-  var itemMapper = new CustomItemMapper();
-  var BulkActionDeleteItems = "BulkDeleteItems";
-  var BulkActionRestoreItems = "BulkRestoreItems";
-  var init = function init(listGateway, deleteItemGateway, restoreItemGateway) {
-    var retentionPeriod = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 90;
-    var selectedRepo = new _SelectedItems.SelectedItemsRepository();
-    var loadingRepo = new _appUtils.LoadingRepository();
-    var sortRepo = new _appUtils.SortingRepository();
-    var sortRepoWithDefaults = new _Sorting.SortingRepositoryWithDefaults(defaultSorting, sortRepo);
-    var metaRepo = new _appUtils.MetaRepository();
-    var searchRepo = new _Search.SearchRepository();
-    var trashBinItemsRepo = new _TrashBinItems.TrashBinItemsRepository(metaRepo, listGateway, deleteItemGateway, restoreItemGateway, bulkActionGateway, itemMapper);
-    var itemsRepo = new _TrashBinItems.TrashBinItemsRepositoryWithLoading(loadingRepo, trashBinItemsRepo);
+  const itemMapper = new CustomItemMapper();
+  const BulkActionDeleteItems = "BulkDeleteItems";
+  const BulkActionRestoreItems = "BulkRestoreItems";
+  const init = (listGateway, deleteItemGateway, restoreItemGateway, retentionPeriod = 90) => {
+    const selectedRepo = new SelectedItemsRepository();
+    const loadingRepo = new LoadingRepository();
+    const sortRepo = new SortingRepository();
+    const sortRepoWithDefaults = new SortingRepositoryWithDefaults(defaultSorting, sortRepo);
+    const metaRepo = new MetaRepository();
+    const searchRepo = new SearchRepository();
+    const trashBinItemsRepo = new TrashBinItemsRepository(metaRepo, listGateway, deleteItemGateway, restoreItemGateway, bulkActionGateway, itemMapper);
+    const itemsRepo = new TrashBinItemsRepositoryWithLoading(loadingRepo, trashBinItemsRepo);
     return {
-      presenter: new _TrashBinPresenter.TrashBinPresenter(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo, retentionPeriod),
-      controllers: new _TrashBinControllers.TrashBinControllers(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo, BulkActionDeleteItems, BulkActionRestoreItems).getControllers()
+      presenter: new TrashBinPresenter(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo, retentionPeriod),
+      controllers: new TrashBinControllers(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo, BulkActionDeleteItems, BulkActionRestoreItems).getControllers()
     };
   };
-  beforeEach(function () {
+  beforeEach(() => {
     jest.clearAllMocks();
   });
-  it("should create a presenter and list trash bin entries from the gateway", async function () {
-    var _init = init(listGateway, deleteItemGateway, restoreItemGateway),
-      presenter = _init.presenter,
-      controllers = _init.controllers;
-    var listPromise = controllers.listItems.execute();
+  it("should create a presenter and list trash bin entries from the gateway", async () => {
+    const {
+      presenter,
+      controllers
+    } = init(listGateway, deleteItemGateway, restoreItemGateway);
+    const listPromise = controllers.listItems.execute();
 
     // Let's check the transition to loading state
     expect(presenter.vm).toMatchObject({
       items: [],
-      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.list, true)
+      loading: {
+        [LoadingActions.list]: true
+      }
     });
     await listPromise;
     expect(listGateway.execute).toHaveBeenCalledTimes(1);
@@ -199,18 +185,20 @@ describe("TrashBin", function () {
         deletedBy: identity2,
         deletedOn: expect.any(String)
       }],
-      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.list, false)
+      loading: {
+        [LoadingActions.list]: false
+      }
     });
   });
-  it("should list more items from the gateway", async function () {
-    var listGateway = createBinListGateway({
-      execute: jest.fn().mockImplementationOnce(function () {
+  it("should list more items from the gateway", async () => {
+    const listGateway = createBinListGateway({
+      execute: jest.fn().mockImplementationOnce(() => {
         return Promise.resolve([[item1, item2, item3], {
           totalCount: 4,
           cursor: "IjMi",
           hasMoreItems: true
         }]);
-      }).mockImplementationOnce(function () {
+      }).mockImplementationOnce(() => {
         return Promise.resolve([[item4], {
           totalCount: 4,
           cursor: null,
@@ -218,18 +206,21 @@ describe("TrashBin", function () {
         }]);
       })
     });
-    var _init2 = init(listGateway, deleteItemGateway, restoreItemGateway),
-      presenter = _init2.presenter,
-      controllers = _init2.controllers;
+    const {
+      presenter,
+      controllers
+    } = init(listGateway, deleteItemGateway, restoreItemGateway);
 
     // Let's list some initial entries
     await controllers.listItems.execute();
     expect(listGateway.execute).toHaveBeenCalledTimes(1);
 
     // Let's list more items from the gateway
-    var listMorePromise = controllers.listMoreItems.execute();
+    const listMorePromise = controllers.listMoreItems.execute();
     expect(presenter.vm).toMatchObject({
-      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.listMore, true)
+      loading: {
+        [LoadingActions.listMore]: true
+      }
     });
     await listMorePromise;
     expect(listGateway.execute).toHaveBeenCalledTimes(2);
@@ -268,18 +259,20 @@ describe("TrashBin", function () {
         deletedBy: identity1,
         deletedOn: expect.any(String)
       }],
-      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.listMore, false)
+      loading: {
+        [LoadingActions.listMore]: false
+      }
     });
   });
-  it("should be able to sort items", async function () {
-    var sortListGateway = createBinListGateway({
-      execute: jest.fn().mockImplementationOnce(function () {
+  it("should be able to sort items", async () => {
+    const sortListGateway = createBinListGateway({
+      execute: jest.fn().mockImplementationOnce(() => {
         return Promise.resolve([[item1, item2, item3], {
           totalCount: 3,
           cursor: null,
           hasMoreItems: false
         }]);
-      }).mockImplementation(function () {
+      }).mockImplementation(() => {
         return Promise.resolve([[item3, item2, item1], {
           totalCount: 3,
           cursor: null,
@@ -287,9 +280,10 @@ describe("TrashBin", function () {
         }]);
       })
     });
-    var _init3 = init(sortListGateway, deleteItemGateway, restoreItemGateway),
-      presenter = _init3.presenter,
-      controllers = _init3.controllers;
+    const {
+      presenter,
+      controllers
+    } = init(sortListGateway, deleteItemGateway, restoreItemGateway);
 
     // let's list some entries from the gateway
     await controllers.listItems.execute();
@@ -298,12 +292,10 @@ describe("TrashBin", function () {
     });
 
     // Let's sort items, it should call back the list gateway to retrieve the items sorted
-    await controllers.sortItems.execute(function () {
-      return [{
-        id: "deletedOn",
-        desc: false
-      }];
-    });
+    await controllers.sortItems.execute(() => [{
+      id: "deletedOn",
+      desc: false
+    }]);
     expect(sortListGateway.execute).toHaveBeenNthCalledWith(2, {
       sort: ["deletedOn_ASC"]
     });
@@ -330,28 +322,30 @@ describe("TrashBin", function () {
         deletedBy: identity2,
         deletedOn: expect.any(String)
       }],
-      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.list, false),
+      loading: {
+        [LoadingActions.list]: false
+      },
       sorting: [{
         id: "deletedOn",
         desc: false
       }]
     });
   });
-  it("should be able to search items", async function () {
-    var searchItemsGateway = createBinListGateway({
-      execute: jest.fn().mockImplementationOnce(function () {
+  it("should be able to search items", async () => {
+    const searchItemsGateway = createBinListGateway({
+      execute: jest.fn().mockImplementationOnce(() => {
         return Promise.resolve([[item1, item2, item3], {
           totalCount: 3,
           cursor: null,
           hasMoreItems: false
         }]);
-      }).mockImplementationOnce(function () {
+      }).mockImplementationOnce(() => {
         return Promise.resolve([[item1], {
           totalCount: 1,
           cursor: null,
           hasMoreItems: false
         }]);
-      }).mockImplementationOnce(function () {
+      }).mockImplementationOnce(() => {
         return Promise.resolve([[], {
           totalCount: 0,
           cursor: null,
@@ -359,9 +353,10 @@ describe("TrashBin", function () {
         }]);
       })
     });
-    var _init4 = init(searchItemsGateway, deleteItemGateway, restoreItemGateway),
-      presenter = _init4.presenter,
-      controllers = _init4.controllers;
+    const {
+      presenter,
+      controllers
+    } = init(searchItemsGateway, deleteItemGateway, restoreItemGateway);
 
     // let's list some entries from the gateway
     await controllers.listItems.execute();
@@ -384,7 +379,9 @@ describe("TrashBin", function () {
         deletedBy: identity2,
         deletedOn: expect.any(String)
       }],
-      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.list, false),
+      loading: {
+        [LoadingActions.list]: false
+      },
       searchQuery: "Item 1"
     });
 
@@ -396,15 +393,18 @@ describe("TrashBin", function () {
     });
     expect(presenter.vm).toMatchObject({
       items: [],
-      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.list, false),
+      loading: {
+        [LoadingActions.list]: false
+      },
       searchQuery: "Not found query",
       isEmptyView: true
     });
   });
-  it("should be able to select items", async function () {
-    var _init5 = init(listGateway, deleteItemGateway, restoreItemGateway),
-      presenter = _init5.presenter,
-      controllers = _init5.controllers;
+  it("should be able to select items", async () => {
+    const {
+      presenter,
+      controllers
+    } = init(listGateway, deleteItemGateway, restoreItemGateway);
 
     // let's list some entries from the gateway
     await controllers.listItems.execute();
@@ -486,10 +486,11 @@ describe("TrashBin", function () {
       }]
     });
   });
-  it("should delete an item, removing it from the list", async function () {
-    var _init6 = init(listGateway, deleteItemGateway, restoreItemGateway),
-      presenter = _init6.presenter,
-      controllers = _init6.controllers;
+  it("should delete an item, removing it from the list", async () => {
+    const {
+      presenter,
+      controllers
+    } = init(listGateway, deleteItemGateway, restoreItemGateway);
 
     // let's list some entries from the gateway
     await controllers.listItems.execute();
@@ -527,11 +528,13 @@ describe("TrashBin", function () {
         deletedOn: expect.any(String)
       }]
     });
-    var deletePromise = controllers.deleteItem.execute(item1.id);
+    const deletePromise = controllers.deleteItem.execute(item1.id);
 
     // Let's check the transition to loading state
     expect(presenter.vm).toMatchObject({
-      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.delete, true)
+      loading: {
+        [LoadingActions.delete]: true
+      }
     });
     await deletePromise;
     expect(deleteItemGateway.execute).toHaveBeenCalledTimes(1);
@@ -560,10 +563,11 @@ describe("TrashBin", function () {
       }]
     });
   });
-  it("should restore an item, removing it from the list", async function () {
-    var _init7 = init(listGateway, deleteItemGateway, restoreItemGateway),
-      presenter = _init7.presenter,
-      controllers = _init7.controllers;
+  it("should restore an item, removing it from the list", async () => {
+    const {
+      presenter,
+      controllers
+    } = init(listGateway, deleteItemGateway, restoreItemGateway);
 
     // let's list some entries from the gateway
     await controllers.listItems.execute();
@@ -601,11 +605,13 @@ describe("TrashBin", function () {
         deletedOn: expect.any(String)
       }]
     });
-    var restorePromise = controllers.restoreItem.execute(item1.id);
+    const restorePromise = controllers.restoreItem.execute(item1.id);
 
     // Let's check the transition to loading state
     expect(presenter.vm).toMatchObject({
-      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.restore, true)
+      loading: {
+        [LoadingActions.restore]: true
+      }
     });
     await restorePromise;
     expect(restoreItemGateway.execute).toHaveBeenCalledTimes(1);
@@ -646,7 +652,7 @@ describe("TrashBin", function () {
     });
 
     // We should be able to get the restored item by id
-    var restoredItem = await controllers.getRestoredItemById.execute("item-1");
+    const restoredItem = await controllers.getRestoredItemById.execute("item-1");
     expect(restoredItem).toMatchObject({
       id: "item-1",
       $selectable: true,
@@ -659,21 +665,23 @@ describe("TrashBin", function () {
       deletedOn: expect.any(String)
     });
   });
-  it.each([[0, "0 days"], [1, "1 day"], [2, "2 days"]])("should set the retention period to `%s` when input is `%i`", function (input, output) {
-    var _init8 = init(listGateway, deleteItemGateway, restoreItemGateway, input),
-      presenter = _init8.presenter;
+  it.each([[0, "0 days"], [1, "1 day"], [2, "2 days"]])("should set the retention period to `%s` when input is `%i`", (input, output) => {
+    const {
+      presenter
+    } = init(listGateway, deleteItemGateway, restoreItemGateway, input);
     expect(presenter.vm).toMatchObject({
       retentionPeriod: output
     });
   });
-  it("should be able to perform bulk action - RESTORE", async function () {
-    var _init9 = init(listGateway, deleteItemGateway, restoreItemGateway),
-      controllers = _init9.controllers;
+  it("should be able to perform bulk action - RESTORE", async () => {
+    const {
+      controllers
+    } = init(listGateway, deleteItemGateway, restoreItemGateway);
 
     // let's list some entries from the gateway
     await controllers.listItems.execute();
     expect(listGateway.execute).toHaveBeenCalledTimes(1);
-    var restoreBulkActionPromise = controllers.restoreBulkAction.execute({
+    const restoreBulkActionPromise = controllers.restoreBulkAction.execute({
       search: "Custom search",
       where: {
         title: "Item title"
@@ -695,14 +703,15 @@ describe("TrashBin", function () {
       }
     });
   });
-  it("should be able to perform bulk action - DELETE", async function () {
-    var _init10 = init(listGateway, deleteItemGateway, restoreItemGateway),
-      controllers = _init10.controllers;
+  it("should be able to perform bulk action - DELETE", async () => {
+    const {
+      controllers
+    } = init(listGateway, deleteItemGateway, restoreItemGateway);
 
     // let's list some entries from the gateway
     await controllers.listItems.execute();
     expect(listGateway.execute).toHaveBeenCalledTimes(1);
-    var deleteBulkActionPromise = controllers.deleteBulkAction.execute({
+    const deleteBulkActionPromise = controllers.deleteBulkAction.execute({
       search: "Custom search",
       where: {
         title: "Item title"
@@ -724,11 +733,11 @@ describe("TrashBin", function () {
       }
     });
   });
-  it("should be able to `selectAll` and `unselectAll` items", async function () {
+  it("should be able to `selectAll` and `unselectAll` items", async () => {
     {
       // let's test the functionality by listing items that span multiple pages.
-      var _listGateway = createBinListGateway({
-        execute: jest.fn().mockImplementation(function () {
+      const listGateway = createBinListGateway({
+        execute: jest.fn().mockImplementation(() => {
           return Promise.resolve([[item1, item2, item3], {
             totalCount: 4,
             cursor: "IjMi",
@@ -736,13 +745,14 @@ describe("TrashBin", function () {
           }]);
         })
       });
-      var _init11 = init(_listGateway, deleteItemGateway, restoreItemGateway),
-        presenter = _init11.presenter,
-        controllers = _init11.controllers;
+      const {
+        presenter,
+        controllers
+      } = init(listGateway, deleteItemGateway, restoreItemGateway);
 
       // let's list some entries from the gateway
       await controllers.listItems.execute();
-      expect(_listGateway.execute).toHaveBeenCalledTimes(1);
+      expect(listGateway.execute).toHaveBeenCalledTimes(1);
 
       // let's check the initial vm state
       expect(presenter.vm.items.length).toBe(3);
@@ -779,8 +789,8 @@ describe("TrashBin", function () {
     }
     {
       // let's test the functionality by listing items that span only one page.
-      var _listGateway2 = createBinListGateway({
-        execute: jest.fn().mockImplementation(function () {
+      const listGateway = createBinListGateway({
+        execute: jest.fn().mockImplementation(() => {
           return Promise.resolve([[item1, item2, item3], {
             totalCount: 3,
             cursor: null,
@@ -788,22 +798,23 @@ describe("TrashBin", function () {
           }]);
         })
       });
-      var _init12 = init(_listGateway2, deleteItemGateway, restoreItemGateway),
-        _presenter = _init12.presenter,
-        _controllers = _init12.controllers;
+      const {
+        presenter,
+        controllers
+      } = init(listGateway, deleteItemGateway, restoreItemGateway);
 
       // let's list some entries from the gateway
-      await _controllers.listItems.execute();
-      expect(_listGateway2.execute).toHaveBeenCalledTimes(1);
+      await controllers.listItems.execute();
+      expect(listGateway.execute).toHaveBeenCalledTimes(1);
 
       // let's check the initial vm state
-      expect(_presenter.vm.items.length).toBe(3);
+      expect(presenter.vm.items.length).toBe(3);
 
       // let's check the vm state after selecting all items in the page
-      await _controllers.selectItems.execute([item1, item2, item3]);
-      expect(_presenter.vm.selectedItems.length).toBe(3);
-      expect(_presenter.vm.allowSelectAll).toBeFalsy();
-      expect(_presenter.vm.isSelectedAll).toBeFalsy();
+      await controllers.selectItems.execute([item1, item2, item3]);
+      expect(presenter.vm.selectedItems.length).toBe(3);
+      expect(presenter.vm.allowSelectAll).toBeFalsy();
+      expect(presenter.vm.isSelectedAll).toBeFalsy();
     }
   });
 });