@webiny/app-trash-bin 5.40.0-beta.3

package/Presentation/TrashBin/TrashBin.test.js

@@ -0,0 +1,656 @@
+"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 = {
+  id: "1234",
+  displayName: "John Doe",
+  type: "admin"
+};
+var 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 CustomItemMapper = /*#__PURE__*/function () {
+  function CustomItemMapper() {
+    (0, _classCallCheck2.default)(this, CustomItemMapper);
+  }
+  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 = [{
+  field: "deletedOn",
+  order: "desc"
+}];
+describe("TrashBin", function () {
+  var item1 = {
+    id: "item-1",
+    title: "Item 1",
+    location: {
+      folderId: "folder-a"
+    },
+    createdBy: identity1,
+    deletedBy: identity2,
+    deletedOn: new Date().toString(),
+    custom: "any custom data"
+  };
+  var item2 = {
+    id: "item-2",
+    title: "Item 2",
+    location: {
+      folderId: "folder-a"
+    },
+    createdBy: identity1,
+    deletedBy: identity1,
+    deletedOn: new Date().toString(),
+    custom: "any custom data"
+  };
+  var item3 = {
+    id: "item-3",
+    title: "Item 3",
+    location: {
+      folderId: "folder-b"
+    },
+    createdBy: identity2,
+    deletedBy: identity2,
+    deletedOn: new Date().toString(),
+    custom: "any custom data"
+  };
+  var item4 = {
+    id: "item-4",
+    title: "Item 4",
+    location: {
+      folderId: "folder-b"
+    },
+    createdBy: identity1,
+    deletedBy: identity1,
+    deletedOn: new Date().toString(),
+    custom: "any custom data"
+  };
+  var listGateway = createBinListGateway({
+    execute: jest.fn().mockImplementation(function () {
+      return Promise.resolve([[item1, item2, item3], {
+        totalCount: 3,
+        cursor: null,
+        hasMoreItems: false
+      }]);
+    })
+  });
+  var deleteItemGateway = createBinDeleteItemGateway({
+    execute: jest.fn().mockImplementation(function () {
+      return Promise.resolve(true);
+    })
+  });
+  var restoreItemGateway = createBinRestoreItemGateway({
+    execute: jest.fn().mockImplementation(function () {
+      return Promise.resolve(item1);
+    })
+  });
+  var itemMapper = new CustomItemMapper();
+  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, itemMapper);
+    var itemsRepo = new _TrashBinItems.TrashBinItemsRepositoryWithLoading(loadingRepo, trashBinItemsRepo);
+    return {
+      presenter: new _TrashBinPresenter.TrashBinPresenter(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo, retentionPeriod),
+      controllers: new _TrashBinControllers.TrashBinControllers(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo).getControllers()
+    };
+  };
+  beforeEach(function () {
+    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();
+
+    // Let's check the transition to loading state
+    expect(presenter.vm).toMatchObject({
+      items: [],
+      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.list, true)
+    });
+    await listPromise;
+    expect(listGateway.execute).toHaveBeenCalledTimes(1);
+    expect(listGateway.execute).toHaveBeenCalledWith({
+      sort: ["deletedOn_DESC"]
+    });
+    expect(presenter.vm).toMatchObject({
+      items: [{
+        id: "item-1",
+        $selectable: true,
+        title: "Item 1",
+        createdBy: identity1,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-2",
+        $selectable: true,
+        title: "Item 2",
+        createdBy: identity1,
+        deletedBy: identity1,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-3",
+        $selectable: true,
+        title: "Item 3",
+        createdBy: identity2,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }],
+      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.list, false)
+    });
+  });
+  it("should list more items from the gateway", async function () {
+    var listGateway = createBinListGateway({
+      execute: jest.fn().mockImplementationOnce(function () {
+        return Promise.resolve([[item1, item2, item3], {
+          totalCount: 4,
+          cursor: "IjMi",
+          hasMoreItems: true
+        }]);
+      }).mockImplementationOnce(function () {
+        return Promise.resolve([[item4], {
+          totalCount: 4,
+          cursor: null,
+          hasMoreItems: false
+        }]);
+      })
+    });
+    var _init2 = init(listGateway, deleteItemGateway, restoreItemGateway),
+      presenter = _init2.presenter,
+      controllers = _init2.controllers;
+
+    // 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();
+    expect(presenter.vm).toMatchObject({
+      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.listMore, true)
+    });
+    await listMorePromise;
+    expect(listGateway.execute).toHaveBeenCalledTimes(2);
+    expect(listGateway.execute).toHaveBeenCalledWith({
+      after: "IjMi",
+      search: undefined,
+      sort: ["deletedOn_DESC"]
+    });
+    expect(presenter.vm).toMatchObject({
+      items: [{
+        id: "item-1",
+        $selectable: true,
+        title: "Item 1",
+        createdBy: identity1,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-2",
+        $selectable: true,
+        title: "Item 2",
+        createdBy: identity1,
+        deletedBy: identity1,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-3",
+        $selectable: true,
+        title: "Item 3",
+        createdBy: identity2,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-4",
+        $selectable: true,
+        title: "Item 4",
+        createdBy: identity1,
+        deletedBy: identity1,
+        deletedOn: expect.any(String)
+      }],
+      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.listMore, false)
+    });
+  });
+  it("should be able to sort items", async function () {
+    var sortListGateway = createBinListGateway({
+      execute: jest.fn().mockImplementationOnce(function () {
+        return Promise.resolve([[item1, item2, item3], {
+          totalCount: 3,
+          cursor: null,
+          hasMoreItems: false
+        }]);
+      }).mockImplementation(function () {
+        return Promise.resolve([[item3, item2, item1], {
+          totalCount: 3,
+          cursor: null,
+          hasMoreItems: false
+        }]);
+      })
+    });
+    var _init3 = init(sortListGateway, deleteItemGateway, restoreItemGateway),
+      presenter = _init3.presenter,
+      controllers = _init3.controllers;
+
+    // let's list some entries from the gateway
+    await controllers.listItems.execute();
+    expect(sortListGateway.execute).toHaveBeenNthCalledWith(1, {
+      sort: ["deletedOn_DESC"]
+    });
+
+    // 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
+      }];
+    });
+    expect(sortListGateway.execute).toHaveBeenNthCalledWith(2, {
+      sort: ["deletedOn_ASC"]
+    });
+    expect(presenter.vm).toMatchObject({
+      items: [{
+        id: "item-3",
+        $selectable: true,
+        title: "Item 3",
+        createdBy: identity2,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-2",
+        $selectable: true,
+        title: "Item 2",
+        createdBy: identity1,
+        deletedBy: identity1,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-1",
+        $selectable: true,
+        title: "Item 1",
+        createdBy: identity1,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }],
+      loading: (0, _defineProperty2.default)({}, _types.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 () {
+        return Promise.resolve([[item1, item2, item3], {
+          totalCount: 3,
+          cursor: null,
+          hasMoreItems: false
+        }]);
+      }).mockImplementationOnce(function () {
+        return Promise.resolve([[item1], {
+          totalCount: 1,
+          cursor: null,
+          hasMoreItems: false
+        }]);
+      }).mockImplementationOnce(function () {
+        return Promise.resolve([[], {
+          totalCount: 0,
+          cursor: null,
+          hasMoreItems: false
+        }]);
+      })
+    });
+    var _init4 = init(searchItemsGateway, deleteItemGateway, restoreItemGateway),
+      presenter = _init4.presenter,
+      controllers = _init4.controllers;
+
+    // let's list some entries from the gateway
+    await controllers.listItems.execute();
+    expect(searchItemsGateway.execute).toHaveBeenNthCalledWith(1, {
+      sort: ["deletedOn_DESC"]
+    });
+
+    // Let's search for items, it should return items from the gateway
+    await controllers.searchItems.execute("Item 1");
+    expect(searchItemsGateway.execute).toHaveBeenNthCalledWith(2, {
+      sort: ["deletedOn_DESC"],
+      search: "Item 1"
+    });
+    expect(presenter.vm).toMatchObject({
+      items: [{
+        id: "item-1",
+        $selectable: true,
+        title: "Item 1",
+        createdBy: identity1,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }],
+      loading: (0, _defineProperty2.default)({}, _types.LoadingActions.list, false),
+      searchQuery: "Item 1"
+    });
+
+    // Let's search for items, it should return no items from the gateway
+    await controllers.searchItems.execute("Not found query");
+    expect(searchItemsGateway.execute).toHaveBeenNthCalledWith(3, {
+      sort: ["deletedOn_DESC"],
+      search: "Not found query"
+    });
+    expect(presenter.vm).toMatchObject({
+      items: [],
+      loading: (0, _defineProperty2.default)({}, _types.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;
+
+    // let's list some entries from the gateway
+    await controllers.listItems.execute();
+
+    // No selected items found by default
+    expect(presenter.vm).toMatchObject({
+      selectedItems: []
+    });
+
+    // Let's select the first Item
+    await controllers.selectItems.execute([{
+      id: "item-1",
+      $selectable: true,
+      title: "Item 1",
+      location: {
+        folderId: "folder-a"
+      },
+      createdBy: identity1,
+      deletedBy: identity2,
+      deletedOn: new Date().toString()
+    }]);
+    expect(presenter.vm).toMatchObject({
+      selectedItems: [{
+        id: "item-1",
+        $selectable: true,
+        title: "Item 1",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }]
+    });
+
+    // Let's select the second item
+    await controllers.selectItems.execute([{
+      id: "item-1",
+      $selectable: true,
+      title: "Item 1",
+      location: {
+        folderId: "folder-a"
+      },
+      createdBy: identity1,
+      deletedBy: identity2,
+      deletedOn: new Date().toString()
+    }, {
+      id: "item-2",
+      $selectable: true,
+      title: "Item 2",
+      location: {
+        folderId: "folder-a"
+      },
+      createdBy: identity1,
+      deletedBy: identity1,
+      deletedOn: new Date().toString()
+    }]);
+    expect(presenter.vm).toMatchObject({
+      selectedItems: [{
+        id: "item-1",
+        $selectable: true,
+        title: "Item 1",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-2",
+        $selectable: true,
+        title: "Item 2",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity1,
+        deletedOn: expect.any(String)
+      }]
+    });
+  });
+  it("should delete an item, removing it from the list", async function () {
+    var _init6 = init(listGateway, deleteItemGateway, restoreItemGateway),
+      presenter = _init6.presenter,
+      controllers = _init6.controllers;
+
+    // let's list some entries from the gateway
+    await controllers.listItems.execute();
+    expect(listGateway.execute).toHaveBeenCalledTimes(1);
+    expect(presenter.vm).toMatchObject({
+      items: [{
+        id: "item-1",
+        $selectable: true,
+        title: "Item 1",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-2",
+        $selectable: true,
+        title: "Item 2",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity1,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-3",
+        $selectable: true,
+        title: "Item 3",
+        location: {
+          folderId: "folder-b"
+        },
+        createdBy: identity2,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }]
+    });
+    var 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)
+    });
+    await deletePromise;
+    expect(deleteItemGateway.execute).toHaveBeenCalledTimes(1);
+    expect(deleteItemGateway.execute).toHaveBeenCalledWith(item1.id);
+    expect(presenter.vm).toMatchObject({
+      items: [{
+        id: "item-2",
+        $selectable: true,
+        title: "Item 2",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity1,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-3",
+        $selectable: true,
+        title: "Item 3",
+        location: {
+          folderId: "folder-b"
+        },
+        createdBy: identity2,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }]
+    });
+  });
+  it("should restore an item, removing it from the list", async function () {
+    var _init7 = init(listGateway, deleteItemGateway, restoreItemGateway),
+      presenter = _init7.presenter,
+      controllers = _init7.controllers;
+
+    // let's list some entries from the gateway
+    await controllers.listItems.execute();
+    expect(listGateway.execute).toHaveBeenCalledTimes(1);
+    expect(presenter.vm).toMatchObject({
+      items: [{
+        id: "item-1",
+        $selectable: true,
+        title: "Item 1",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-2",
+        $selectable: true,
+        title: "Item 2",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity1,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-3",
+        $selectable: true,
+        title: "Item 3",
+        location: {
+          folderId: "folder-b"
+        },
+        createdBy: identity2,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }]
+    });
+    var 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)
+    });
+    await restorePromise;
+    expect(restoreItemGateway.execute).toHaveBeenCalledTimes(1);
+    expect(restoreItemGateway.execute).toHaveBeenCalledWith(item1.id);
+    expect(presenter.vm).toMatchObject({
+      items: [{
+        id: "item-2",
+        $selectable: true,
+        title: "Item 2",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity1,
+        deletedOn: expect.any(String)
+      }, {
+        id: "item-3",
+        $selectable: true,
+        title: "Item 3",
+        location: {
+          folderId: "folder-b"
+        },
+        createdBy: identity2,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }],
+      restoredItems: [{
+        id: "item-1",
+        $selectable: true,
+        title: "Item 1",
+        location: {
+          folderId: "folder-a"
+        },
+        createdBy: identity1,
+        deletedBy: identity2,
+        deletedOn: expect.any(String)
+      }]
+    });
+
+    // We should be able to get the restored item by id
+    var restoredItem = await controllers.getRestoredItemById.execute("item-1");
+    expect(restoredItem).toMatchObject({
+      id: "item-1",
+      $selectable: true,
+      title: "Item 1",
+      location: {
+        folderId: "folder-a"
+      },
+      createdBy: identity1,
+      deletedBy: identity2,
+      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;
+    expect(presenter.vm).toMatchObject({
+      retentionPeriod: output
+    });
+  });
+});
+
+//# sourceMappingURL=TrashBin.test.js.map