@webiny/app-trash-bin 6.3.0-beta.4 → 6.4.0-beta.0

package/Presentation/TrashBin/TrashBin.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { TrashBinPresenter } from "./TrashBinPresenter.js";
 import { LoadingRepository, MetaRepository, SortingRepository } from "@webiny/app-utils";
 import { LoadingActions } from "../../types.js";
@@ -8,787 +8,813 @@ import { SelectedItemsRepository } from "../../Domain/Repositories/SelectedItems
 import { SortingRepositoryWithDefaults } from "../../Domain/Repositories/Sorting/index.js";
 import { TrashBinItemsRepository, TrashBinItemsRepositoryWithLoading } from "../../Domain/Repositories/TrashBinItems/index.js";
 const identity1 = {
-  id: "1234",
-  displayName: "John Doe",
-  type: "admin"
+    id: "1234",
+    displayName: "John Doe",
+    type: "admin"
 };
 const identity2 = {
-  id: "5678",
-  displayName: "Jane Doe",
-  type: "admin"
+    id: "5678",
+    displayName: "Jane Doe",
+    type: "admin"
 };
-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
-    };
-  }
-}
-const defaultSorting = [{
-  field: "deletedOn",
-  order: "desc"
-}];
-describe("TrashBin", () => {
-  const item1 = {
-    id: "item-1",
-    title: "Item 1",
-    location: {
-      folderId: "folder-a"
-    },
-    createdBy: identity1,
-    deletedBy: identity2,
-    deletedOn: new Date().toString(),
-    custom: "any custom data"
-  };
-  const item2 = {
-    id: "item-2",
-    title: "Item 2",
-    location: {
-      folderId: "folder-a"
-    },
-    createdBy: identity1,
-    deletedBy: identity1,
-    deletedOn: new Date().toString(),
-    custom: "any custom data"
-  };
-  const item3 = {
-    id: "item-3",
-    title: "Item 3",
-    location: {
-      folderId: "folder-b"
-    },
-    createdBy: identity2,
-    deletedBy: identity2,
-    deletedOn: new Date().toString(),
-    custom: "any custom data"
-  };
-  const item4 = {
-    id: "item-4",
-    title: "Item 4",
-    location: {
-      folderId: "folder-b"
-    },
-    createdBy: identity1,
-    deletedBy: identity1,
-    deletedOn: new Date().toString(),
-    custom: "any custom data"
-  };
-  const listGateway = createBinListGateway({
-    execute: vi.fn().mockImplementation(() => {
-      return Promise.resolve([[item1, item2, item3], {
-        totalCount: 3,
-        cursor: null,
-        hasMoreItems: false
-      }]);
-    })
-  });
-  const deleteItemGateway = createBinDeleteItemGateway({
-    execute: vi.fn().mockImplementation(() => {
-      return Promise.resolve(true);
-    })
-  });
-  const restoreItemGateway = createBinRestoreItemGateway({
-    execute: vi.fn().mockImplementation(() => {
-      return Promise.resolve(item1);
-    })
-  });
-  const bulkActionGateway = createBinBulkActionsGateway({
-    execute: vi.fn().mockImplementation(() => {
-      return Promise.resolve({
-        id: "123456789"
-      });
-    })
-  });
-  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(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo, retentionPeriod),
-      controllers: new TrashBinControllers(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo, BulkActionDeleteItems, BulkActionRestoreItems).getControllers()
-    };
-  };
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-  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: {
-        [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",
-        title: "Item 1",
-        createdBy: identity1,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-2",
-        title: "Item 2",
-        createdBy: identity1,
-        deletedBy: identity1,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-3",
-        title: "Item 3",
-        createdBy: identity2,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }],
-      loading: {
-        [LoadingActions.list]: false
-      }
-    });
-  });
-  it("should list more items from the gateway", async () => {
-    const listGateway = createBinListGateway({
-      execute: vi.fn().mockImplementationOnce(() => {
-        return Promise.resolve([[item1, item2, item3], {
-          totalCount: 4,
-          cursor: "IjMi",
-          hasMoreItems: true
-        }]);
-      }).mockImplementationOnce(() => {
-        return Promise.resolve([[item4], {
-          totalCount: 4,
-          cursor: null,
-          hasMoreItems: false
-        }]);
-      })
-    });
-    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
-    const listMorePromise = controllers.listMoreItems.execute();
-    expect(presenter.vm).toMatchObject({
-      loading: {
-        [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",
-        title: "Item 1",
-        createdBy: identity1,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-2",
-        title: "Item 2",
-        createdBy: identity1,
-        deletedBy: identity1,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-3",
-        title: "Item 3",
-        createdBy: identity2,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-4",
-        title: "Item 4",
-        createdBy: identity1,
-        deletedBy: identity1,
-        deletedOn: expect.any(String)
-      }],
-      loading: {
-        [LoadingActions.listMore]: false
-      }
-    });
-  });
-  it("should be able to sort items", async () => {
-    const sortListGateway = createBinListGateway({
-      execute: vi.fn().mockImplementationOnce(() => {
-        return Promise.resolve([[item1, item2, item3], {
-          totalCount: 3,
-          cursor: null,
-          hasMoreItems: false
-        }]);
-      }).mockImplementation(() => {
-        return Promise.resolve([[item3, item2, item1], {
-          totalCount: 3,
-          cursor: null,
-          hasMoreItems: false
-        }]);
-      })
+const createBinListGateway = ({ execute })=>({
+        execute
     });
-    const {
-      presenter,
-      controllers
-    } = init(sortListGateway, deleteItemGateway, restoreItemGateway);
-
-    // 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(() => [{
-      id: "deletedOn",
-      desc: false
-    }]);
-    expect(sortListGateway.execute).toHaveBeenNthCalledWith(2, {
-      sort: ["deletedOn_ASC"]
-    });
-    expect(presenter.vm).toMatchObject({
-      items: [{
-        id: "item-3",
-        title: "Item 3",
-        createdBy: identity2,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-2",
-        title: "Item 2",
-        createdBy: identity1,
-        deletedBy: identity1,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-1",
-        title: "Item 1",
-        createdBy: identity1,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }],
-      loading: {
-        [LoadingActions.list]: false
-      },
-      sorting: [{
-        id: "deletedOn",
-        desc: false
-      }]
-    });
-  });
-  it("should be able to search items", async () => {
-    const searchItemsGateway = createBinListGateway({
-      execute: vi.fn().mockImplementationOnce(() => {
-        return Promise.resolve([[item1, item2, item3], {
-          totalCount: 3,
-          cursor: null,
-          hasMoreItems: false
-        }]);
-      }).mockImplementationOnce(() => {
-        return Promise.resolve([[item1], {
-          totalCount: 1,
-          cursor: null,
-          hasMoreItems: false
-        }]);
-      }).mockImplementationOnce(() => {
-        return Promise.resolve([[], {
-          totalCount: 0,
-          cursor: null,
-          hasMoreItems: false
-        }]);
-      })
-    });
-    const {
-      presenter,
-      controllers
-    } = init(searchItemsGateway, deleteItemGateway, restoreItemGateway);
-
-    // let's list some entries from the gateway
-    await controllers.listItems.execute();
-    expect(searchItemsGateway.execute).toHaveBeenNthCalledWith(1, {
-      sort: ["deletedOn_DESC"]
+const createBinDeleteItemGateway = ({ execute })=>({
+        execute
     });
-
-    // 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"
+const createBinRestoreItemGateway = ({ execute })=>({
+        execute
     });
-    expect(presenter.vm).toMatchObject({
-      items: [{
-        id: "item-1",
-        title: "Item 1",
-        createdBy: identity1,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }],
-      loading: {
-        [LoadingActions.list]: false
-      },
-      searchQuery: "Item 1"
+const createBinBulkActionsGateway = ({ execute })=>({
+        execute
     });
-
-    // 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: {
-        [LoadingActions.list]: false
-      },
-      searchQuery: "Not found query",
-      isEmptyView: true
-    });
-  });
-  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();
-
-    // No selected items found by default
-    expect(presenter.vm).toMatchObject({
-      selectedItems: []
-    });
-
-    // Let's select the first Item
-    await controllers.selectItems.execute([{
-      id: "item-1",
-      title: "Item 1",
-      location: {
-        folderId: "folder-a"
-      },
-      createdBy: identity1,
-      deletedBy: identity2,
-      deletedOn: new Date().toString()
-    }]);
-    expect(presenter.vm).toMatchObject({
-      selectedItems: [{
-        id: "item-1",
-        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",
-      title: "Item 1",
-      location: {
-        folderId: "folder-a"
-      },
-      createdBy: identity1,
-      deletedBy: identity2,
-      deletedOn: new Date().toString()
-    }, {
-      id: "item-2",
-      title: "Item 2",
-      location: {
-        folderId: "folder-a"
-      },
-      createdBy: identity1,
-      deletedBy: identity1,
-      deletedOn: new Date().toString()
-    }]);
-    expect(presenter.vm).toMatchObject({
-      selectedItems: [{
-        id: "item-1",
-        title: "Item 1",
-        location: {
-          folderId: "folder-a"
-        },
-        createdBy: identity1,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-2",
-        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 () => {
-    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(presenter.vm).toMatchObject({
-      items: [{
-        id: "item-1",
-        title: "Item 1",
-        location: {
-          folderId: "folder-a"
-        },
-        createdBy: identity1,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-2",
-        title: "Item 2",
-        location: {
-          folderId: "folder-a"
-        },
-        createdBy: identity1,
-        deletedBy: identity1,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-3",
-        title: "Item 3",
-        location: {
-          folderId: "folder-b"
-        },
-        createdBy: identity2,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }]
-    });
-    const deletePromise = controllers.deleteItem.execute(item1.id);
-
-    // Let's check the transition to loading state
-    expect(presenter.vm).toMatchObject({
-      loading: {
-        [LoadingActions.delete]: true
-      }
-    });
-    await deletePromise;
-    expect(deleteItemGateway.execute).toHaveBeenCalledTimes(1);
-    expect(deleteItemGateway.execute).toHaveBeenCalledWith(item1.id);
-    expect(presenter.vm).toMatchObject({
-      items: [{
-        id: "item-2",
-        title: "Item 2",
-        location: {
-          folderId: "folder-a"
-        },
-        createdBy: identity1,
-        deletedBy: identity1,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-3",
-        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 () => {
-    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(presenter.vm).toMatchObject({
-      items: [{
+class CustomItemMapper {
+    toDTO(data) {
+        return {
+            id: data.id,
+            title: data.title,
+            location: data.location,
+            createdBy: data.createdBy,
+            deletedOn: data.deletedOn,
+            deletedBy: data.deletedBy
+        };
+    }
+}
+const defaultSorting = [
+    {
+        field: "deletedOn",
+        order: "desc"
+    }
+];
+describe("TrashBin", ()=>{
+    const item1 = {
         id: "item-1",
         title: "Item 1",
         location: {
-          folderId: "folder-a"
+            folderId: "folder-a"
         },
         createdBy: identity1,
         deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }, {
+        deletedOn: new Date().toString(),
+        custom: "any custom data"
+    };
+    const item2 = {
         id: "item-2",
         title: "Item 2",
         location: {
-          folderId: "folder-a"
+            folderId: "folder-a"
         },
         createdBy: identity1,
         deletedBy: identity1,
-        deletedOn: expect.any(String)
-      }, {
+        deletedOn: new Date().toString(),
+        custom: "any custom data"
+    };
+    const item3 = {
         id: "item-3",
         title: "Item 3",
         location: {
-          folderId: "folder-b"
+            folderId: "folder-b"
         },
         createdBy: identity2,
         deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }]
-    });
-    const restorePromise = controllers.restoreItem.execute(item1.id);
-
-    // Let's check the transition to loading state
-    expect(presenter.vm).toMatchObject({
-      loading: {
-        [LoadingActions.restore]: true
-      }
-    });
-    await restorePromise;
-    expect(restoreItemGateway.execute).toHaveBeenCalledTimes(1);
-    expect(restoreItemGateway.execute).toHaveBeenCalledWith(item1.id);
-    expect(presenter.vm).toMatchObject({
-      items: [{
-        id: "item-2",
-        title: "Item 2",
+        deletedOn: new Date().toString(),
+        custom: "any custom data"
+    };
+    const item4 = {
+        id: "item-4",
+        title: "Item 4",
         location: {
-          folderId: "folder-a"
+            folderId: "folder-b"
         },
         createdBy: identity1,
         deletedBy: identity1,
-        deletedOn: expect.any(String)
-      }, {
-        id: "item-3",
-        title: "Item 3",
-        location: {
-          folderId: "folder-b"
-        },
-        createdBy: identity2,
-        deletedBy: identity2,
-        deletedOn: expect.any(String)
-      }],
-      restoredItems: [{
-        id: "item-1",
-        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
-    const restoredItem = await controllers.getRestoredItemById.execute("item-1");
-    expect(restoredItem).toMatchObject({
-      id: "item-1",
-      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`", (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 () => {
-    const {
-      controllers
-    } = init(listGateway, deleteItemGateway, restoreItemGateway);
-
-    // let's list some entries from the gateway
-    await controllers.listItems.execute();
-    expect(listGateway.execute).toHaveBeenCalledTimes(1);
-    const restoreBulkActionPromise = controllers.restoreBulkAction.execute({
-      search: "Custom search",
-      where: {
-        title: "Item title"
-      },
-      data: {
-        any: 1
-      }
-    });
-    await restoreBulkActionPromise;
-    expect(bulkActionGateway.execute).toHaveBeenCalledTimes(1);
-    expect(bulkActionGateway.execute).toHaveBeenCalledWith({
-      action: BulkActionRestoreItems,
-      search: "Custom search",
-      where: {
-        title: "Item title"
-      },
-      data: {
-        any: 1
-      }
-    });
-  });
-  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);
-    const deleteBulkActionPromise = controllers.deleteBulkAction.execute({
-      search: "Custom search",
-      where: {
-        title: "Item title"
-      },
-      data: {
-        any: 1
-      }
-    });
-    await deleteBulkActionPromise;
-    expect(bulkActionGateway.execute).toHaveBeenCalledTimes(1);
-    expect(bulkActionGateway.execute).toHaveBeenCalledWith({
-      action: BulkActionDeleteItems,
-      search: "Custom search",
-      where: {
-        title: "Item title"
-      },
-      data: {
-        any: 1
-      }
+        deletedOn: new Date().toString(),
+        custom: "any custom data"
+    };
+    const listGateway = createBinListGateway({
+        execute: vi.fn().mockImplementation(()=>Promise.resolve([
+                [
+                    item1,
+                    item2,
+                    item3
+                ],
+                {
+                    totalCount: 3,
+                    cursor: null,
+                    hasMoreItems: false
+                }
+            ]))
+    });
+    const deleteItemGateway = createBinDeleteItemGateway({
+        execute: vi.fn().mockImplementation(()=>Promise.resolve(true))
+    });
+    const restoreItemGateway = createBinRestoreItemGateway({
+        execute: vi.fn().mockImplementation(()=>Promise.resolve(item1))
+    });
+    const bulkActionGateway = createBinBulkActionsGateway({
+        execute: vi.fn().mockImplementation(()=>Promise.resolve({
+                id: "123456789"
+            }))
+    });
+    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(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo, retentionPeriod),
+            controllers: new TrashBinControllers(itemsRepo, selectedRepo, sortRepoWithDefaults, searchRepo, BulkActionDeleteItems, BulkActionRestoreItems).getControllers()
+        };
+    };
+    beforeEach(()=>{
+        vi.clearAllMocks();
+    });
+    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();
+        expect(presenter.vm).toMatchObject({
+            items: [],
+            loading: {
+                [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",
+                    title: "Item 1",
+                    createdBy: identity1,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-2",
+                    title: "Item 2",
+                    createdBy: identity1,
+                    deletedBy: identity1,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-3",
+                    title: "Item 3",
+                    createdBy: identity2,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                }
+            ],
+            loading: {
+                [LoadingActions.list]: false
+            }
+        });
+    });
+    it("should list more items from the gateway", async ()=>{
+        const listGateway = createBinListGateway({
+            execute: vi.fn().mockImplementationOnce(()=>Promise.resolve([
+                    [
+                        item1,
+                        item2,
+                        item3
+                    ],
+                    {
+                        totalCount: 4,
+                        cursor: "IjMi",
+                        hasMoreItems: true
+                    }
+                ])).mockImplementationOnce(()=>Promise.resolve([
+                    [
+                        item4
+                    ],
+                    {
+                        totalCount: 4,
+                        cursor: null,
+                        hasMoreItems: false
+                    }
+                ]))
+        });
+        const { presenter, controllers } = init(listGateway, deleteItemGateway, restoreItemGateway);
+        await controllers.listItems.execute();
+        expect(listGateway.execute).toHaveBeenCalledTimes(1);
+        const listMorePromise = controllers.listMoreItems.execute();
+        expect(presenter.vm).toMatchObject({
+            loading: {
+                [LoadingActions.listMore]: true
+            }
+        });
+        await listMorePromise;
+        expect(listGateway.execute).toHaveBeenCalledTimes(2);
+        expect(listGateway.execute).toHaveBeenCalledWith({
+            after: "IjMi",
+            search: void 0,
+            sort: [
+                "deletedOn_DESC"
+            ]
+        });
+        expect(presenter.vm).toMatchObject({
+            items: [
+                {
+                    id: "item-1",
+                    title: "Item 1",
+                    createdBy: identity1,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-2",
+                    title: "Item 2",
+                    createdBy: identity1,
+                    deletedBy: identity1,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-3",
+                    title: "Item 3",
+                    createdBy: identity2,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-4",
+                    title: "Item 4",
+                    createdBy: identity1,
+                    deletedBy: identity1,
+                    deletedOn: expect.any(String)
+                }
+            ],
+            loading: {
+                [LoadingActions.listMore]: false
+            }
+        });
+    });
+    it("should be able to sort items", async ()=>{
+        const sortListGateway = createBinListGateway({
+            execute: vi.fn().mockImplementationOnce(()=>Promise.resolve([
+                    [
+                        item1,
+                        item2,
+                        item3
+                    ],
+                    {
+                        totalCount: 3,
+                        cursor: null,
+                        hasMoreItems: false
+                    }
+                ])).mockImplementation(()=>Promise.resolve([
+                    [
+                        item3,
+                        item2,
+                        item1
+                    ],
+                    {
+                        totalCount: 3,
+                        cursor: null,
+                        hasMoreItems: false
+                    }
+                ]))
+        });
+        const { presenter, controllers } = init(sortListGateway, deleteItemGateway, restoreItemGateway);
+        await controllers.listItems.execute();
+        expect(sortListGateway.execute).toHaveBeenNthCalledWith(1, {
+            sort: [
+                "deletedOn_DESC"
+            ]
+        });
+        await controllers.sortItems.execute(()=>[
+                {
+                    id: "deletedOn",
+                    desc: false
+                }
+            ]);
+        expect(sortListGateway.execute).toHaveBeenNthCalledWith(2, {
+            sort: [
+                "deletedOn_ASC"
+            ]
+        });
+        expect(presenter.vm).toMatchObject({
+            items: [
+                {
+                    id: "item-3",
+                    title: "Item 3",
+                    createdBy: identity2,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-2",
+                    title: "Item 2",
+                    createdBy: identity1,
+                    deletedBy: identity1,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-1",
+                    title: "Item 1",
+                    createdBy: identity1,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                }
+            ],
+            loading: {
+                [LoadingActions.list]: false
+            },
+            sorting: [
+                {
+                    id: "deletedOn",
+                    desc: false
+                }
+            ]
+        });
+    });
+    it("should be able to search items", async ()=>{
+        const searchItemsGateway = createBinListGateway({
+            execute: vi.fn().mockImplementationOnce(()=>Promise.resolve([
+                    [
+                        item1,
+                        item2,
+                        item3
+                    ],
+                    {
+                        totalCount: 3,
+                        cursor: null,
+                        hasMoreItems: false
+                    }
+                ])).mockImplementationOnce(()=>Promise.resolve([
+                    [
+                        item1
+                    ],
+                    {
+                        totalCount: 1,
+                        cursor: null,
+                        hasMoreItems: false
+                    }
+                ])).mockImplementationOnce(()=>Promise.resolve([
+                    [],
+                    {
+                        totalCount: 0,
+                        cursor: null,
+                        hasMoreItems: false
+                    }
+                ]))
+        });
+        const { presenter, controllers } = init(searchItemsGateway, deleteItemGateway, restoreItemGateway);
+        await controllers.listItems.execute();
+        expect(searchItemsGateway.execute).toHaveBeenNthCalledWith(1, {
+            sort: [
+                "deletedOn_DESC"
+            ]
+        });
+        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",
+                    title: "Item 1",
+                    createdBy: identity1,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                }
+            ],
+            loading: {
+                [LoadingActions.list]: false
+            },
+            searchQuery: "Item 1"
+        });
+        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: {
+                [LoadingActions.list]: false
+            },
+            searchQuery: "Not found query",
+            isEmptyView: true
+        });
+    });
+    it("should be able to select items", async ()=>{
+        const { presenter, controllers } = init(listGateway, deleteItemGateway, restoreItemGateway);
+        await controllers.listItems.execute();
+        expect(presenter.vm).toMatchObject({
+            selectedItems: []
+        });
+        await controllers.selectItems.execute([
+            {
+                id: "item-1",
+                title: "Item 1",
+                location: {
+                    folderId: "folder-a"
+                },
+                createdBy: identity1,
+                deletedBy: identity2,
+                deletedOn: new Date().toString()
+            }
+        ]);
+        expect(presenter.vm).toMatchObject({
+            selectedItems: [
+                {
+                    id: "item-1",
+                    title: "Item 1",
+                    location: {
+                        folderId: "folder-a"
+                    },
+                    createdBy: identity1,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                }
+            ]
+        });
+        await controllers.selectItems.execute([
+            {
+                id: "item-1",
+                title: "Item 1",
+                location: {
+                    folderId: "folder-a"
+                },
+                createdBy: identity1,
+                deletedBy: identity2,
+                deletedOn: new Date().toString()
+            },
+            {
+                id: "item-2",
+                title: "Item 2",
+                location: {
+                    folderId: "folder-a"
+                },
+                createdBy: identity1,
+                deletedBy: identity1,
+                deletedOn: new Date().toString()
+            }
+        ]);
+        expect(presenter.vm).toMatchObject({
+            selectedItems: [
+                {
+                    id: "item-1",
+                    title: "Item 1",
+                    location: {
+                        folderId: "folder-a"
+                    },
+                    createdBy: identity1,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-2",
+                    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 ()=>{
+        const { presenter, controllers } = init(listGateway, deleteItemGateway, restoreItemGateway);
+        await controllers.listItems.execute();
+        expect(listGateway.execute).toHaveBeenCalledTimes(1);
+        expect(presenter.vm).toMatchObject({
+            items: [
+                {
+                    id: "item-1",
+                    title: "Item 1",
+                    location: {
+                        folderId: "folder-a"
+                    },
+                    createdBy: identity1,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-2",
+                    title: "Item 2",
+                    location: {
+                        folderId: "folder-a"
+                    },
+                    createdBy: identity1,
+                    deletedBy: identity1,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-3",
+                    title: "Item 3",
+                    location: {
+                        folderId: "folder-b"
+                    },
+                    createdBy: identity2,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                }
+            ]
+        });
+        const deletePromise = controllers.deleteItem.execute(item1.id);
+        expect(presenter.vm).toMatchObject({
+            loading: {
+                [LoadingActions["delete"]]: true
+            }
+        });
+        await deletePromise;
+        expect(deleteItemGateway.execute).toHaveBeenCalledTimes(1);
+        expect(deleteItemGateway.execute).toHaveBeenCalledWith(item1.id);
+        expect(presenter.vm).toMatchObject({
+            items: [
+                {
+                    id: "item-2",
+                    title: "Item 2",
+                    location: {
+                        folderId: "folder-a"
+                    },
+                    createdBy: identity1,
+                    deletedBy: identity1,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-3",
+                    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 ()=>{
+        const { presenter, controllers } = init(listGateway, deleteItemGateway, restoreItemGateway);
+        await controllers.listItems.execute();
+        expect(listGateway.execute).toHaveBeenCalledTimes(1);
+        expect(presenter.vm).toMatchObject({
+            items: [
+                {
+                    id: "item-1",
+                    title: "Item 1",
+                    location: {
+                        folderId: "folder-a"
+                    },
+                    createdBy: identity1,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-2",
+                    title: "Item 2",
+                    location: {
+                        folderId: "folder-a"
+                    },
+                    createdBy: identity1,
+                    deletedBy: identity1,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-3",
+                    title: "Item 3",
+                    location: {
+                        folderId: "folder-b"
+                    },
+                    createdBy: identity2,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                }
+            ]
+        });
+        const restorePromise = controllers.restoreItem.execute(item1.id);
+        expect(presenter.vm).toMatchObject({
+            loading: {
+                [LoadingActions.restore]: true
+            }
+        });
+        await restorePromise;
+        expect(restoreItemGateway.execute).toHaveBeenCalledTimes(1);
+        expect(restoreItemGateway.execute).toHaveBeenCalledWith(item1.id);
+        expect(presenter.vm).toMatchObject({
+            items: [
+                {
+                    id: "item-2",
+                    title: "Item 2",
+                    location: {
+                        folderId: "folder-a"
+                    },
+                    createdBy: identity1,
+                    deletedBy: identity1,
+                    deletedOn: expect.any(String)
+                },
+                {
+                    id: "item-3",
+                    title: "Item 3",
+                    location: {
+                        folderId: "folder-b"
+                    },
+                    createdBy: identity2,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                }
+            ],
+            restoredItems: [
+                {
+                    id: "item-1",
+                    title: "Item 1",
+                    location: {
+                        folderId: "folder-a"
+                    },
+                    createdBy: identity1,
+                    deletedBy: identity2,
+                    deletedOn: expect.any(String)
+                }
+            ]
+        });
+        const restoredItem = await controllers.getRestoredItemById.execute("item-1");
+        expect(restoredItem).toMatchObject({
+            id: "item-1",
+            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`", (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 ()=>{
+        const { controllers } = init(listGateway, deleteItemGateway, restoreItemGateway);
+        await controllers.listItems.execute();
+        expect(listGateway.execute).toHaveBeenCalledTimes(1);
+        const restoreBulkActionPromise = controllers.restoreBulkAction.execute({
+            search: "Custom search",
+            where: {
+                title: "Item title"
+            },
+            data: {
+                any: 1
+            }
+        });
+        await restoreBulkActionPromise;
+        expect(bulkActionGateway.execute).toHaveBeenCalledTimes(1);
+        expect(bulkActionGateway.execute).toHaveBeenCalledWith({
+            action: BulkActionRestoreItems,
+            search: "Custom search",
+            where: {
+                title: "Item title"
+            },
+            data: {
+                any: 1
+            }
+        });
+    });
+    it("should be able to perform bulk action - DELETE", async ()=>{
+        const { controllers } = init(listGateway, deleteItemGateway, restoreItemGateway);
+        await controllers.listItems.execute();
+        expect(listGateway.execute).toHaveBeenCalledTimes(1);
+        const deleteBulkActionPromise = controllers.deleteBulkAction.execute({
+            search: "Custom search",
+            where: {
+                title: "Item title"
+            },
+            data: {
+                any: 1
+            }
+        });
+        await deleteBulkActionPromise;
+        expect(bulkActionGateway.execute).toHaveBeenCalledTimes(1);
+        expect(bulkActionGateway.execute).toHaveBeenCalledWith({
+            action: BulkActionDeleteItems,
+            search: "Custom search",
+            where: {
+                title: "Item title"
+            },
+            data: {
+                any: 1
+            }
+        });
+    });
+    it("should be able to `selectAll` and `unselectAll` items", async ()=>{
+        {
+            const listGateway = createBinListGateway({
+                execute: vi.fn().mockImplementation(()=>Promise.resolve([
+                        [
+                            item1,
+                            item2,
+                            item3
+                        ],
+                        {
+                            totalCount: 4,
+                            cursor: "IjMi",
+                            hasMoreItems: true
+                        }
+                    ]))
+            });
+            const { presenter, controllers } = init(listGateway, deleteItemGateway, restoreItemGateway);
+            await controllers.listItems.execute();
+            expect(listGateway.execute).toHaveBeenCalledTimes(1);
+            expect(presenter.vm.items.length).toBe(3);
+            expect(presenter.vm.selectedItems.length).toBe(0);
+            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).toBeTruthy();
+            expect(presenter.vm.isSelectedAll).toBeFalsy();
+            await controllers.selectAllItems.execute();
+            expect(presenter.vm.selectedItems.length).toBe(3);
+            expect(presenter.vm.allowSelectAll).toBeTruthy();
+            expect(presenter.vm.isSelectedAll).toBeTruthy();
+            await controllers.unselectAllItems.execute();
+            expect(presenter.vm.selectedItems.length).toBe(0);
+            expect(presenter.vm.allowSelectAll).toBeFalsy();
+            expect(presenter.vm.isSelectedAll).toBeFalsy();
+            await controllers.selectItems.execute([
+                item1,
+                item2,
+                item3
+            ]);
+            expect(presenter.vm.selectedItems.length).toBe(3);
+            await controllers.selectAllItems.execute();
+            expect(presenter.vm.isSelectedAll).toBeTruthy();
+            await controllers.selectItems.execute([
+                item1,
+                item2
+            ]);
+            expect(presenter.vm.isSelectedAll).toBeFalsy();
+            expect(presenter.vm.allowSelectAll).toBeFalsy();
+        }
+        {
+            const listGateway = createBinListGateway({
+                execute: vi.fn().mockImplementation(()=>Promise.resolve([
+                        [
+                            item1,
+                            item2,
+                            item3
+                        ],
+                        {
+                            totalCount: 3,
+                            cursor: null,
+                            hasMoreItems: false
+                        }
+                    ]))
+            });
+            const { presenter, controllers } = init(listGateway, deleteItemGateway, restoreItemGateway);
+            await controllers.listItems.execute();
+            expect(listGateway.execute).toHaveBeenCalledTimes(1);
+            expect(presenter.vm.items.length).toBe(3);
+            await controllers.selectItems.execute([
+                item1,
+                item2,
+                item3
+            ]);
+            expect(presenter.vm.selectedItems.length).toBe(3);
+            expect(presenter.vm.allowSelectAll).toBeFalsy();
+            expect(presenter.vm.isSelectedAll).toBeFalsy();
+        }
     });
-  });
-  it("should be able to `selectAll` and `unselectAll` items", async () => {
-    {
-      // let's test the functionality by listing items that span multiple pages.
-      const listGateway = createBinListGateway({
-        execute: vi.fn().mockImplementation(() => {
-          return Promise.resolve([[item1, item2, item3], {
-            totalCount: 4,
-            cursor: "IjMi",
-            hasMoreItems: true
-          }]);
-        })
-      });
-      const {
-        presenter,
-        controllers
-      } = init(listGateway, deleteItemGateway, restoreItemGateway);
-
-      // let's list some entries from the gateway
-      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.selectedItems.length).toBe(0);
-      expect(presenter.vm.allowSelectAll).toBeFalsy();
-      expect(presenter.vm.isSelectedAll).toBeFalsy();
-
-      // let's check the vm state after selecting all items on the page
-      await controllers.selectItems.execute([item1, item2, item3]);
-      expect(presenter.vm.selectedItems.length).toBe(3);
-      expect(presenter.vm.allowSelectAll).toBeTruthy();
-      expect(presenter.vm.isSelectedAll).toBeFalsy();
-
-      // let's check the vm state after selecting all items
-      await controllers.selectAllItems.execute();
-      expect(presenter.vm.selectedItems.length).toBe(3);
-      expect(presenter.vm.allowSelectAll).toBeTruthy();
-      expect(presenter.vm.isSelectedAll).toBeTruthy();
-
-      // let's check the vm state after unselecting all items
-      await controllers.unselectAllItems.execute();
-      expect(presenter.vm.selectedItems.length).toBe(0);
-      expect(presenter.vm.allowSelectAll).toBeFalsy();
-      expect(presenter.vm.isSelectedAll).toBeFalsy();
-
-      // let's check the vm state after unselecting one item
-      await controllers.selectItems.execute([item1, item2, item3]);
-      expect(presenter.vm.selectedItems.length).toBe(3);
-      await controllers.selectAllItems.execute();
-      expect(presenter.vm.isSelectedAll).toBeTruthy();
-      await controllers.selectItems.execute([item1, item2]);
-      expect(presenter.vm.isSelectedAll).toBeFalsy();
-      expect(presenter.vm.allowSelectAll).toBeFalsy();
-    }
-    {
-      // let's test the functionality by listing items that span only one page.
-      const listGateway = createBinListGateway({
-        execute: vi.fn().mockImplementation(() => {
-          return Promise.resolve([[item1, item2, item3], {
-            totalCount: 3,
-            cursor: null,
-            hasMoreItems: false
-          }]);
-        })
-      });
-      const {
-        presenter,
-        controllers
-      } = init(listGateway, deleteItemGateway, restoreItemGateway);
-
-      // let's list some entries from the gateway
-      await controllers.listItems.execute();
-      expect(listGateway.execute).toHaveBeenCalledTimes(1);
-
-      // let's check the initial vm state
-      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();
-    }
-  });
 });
 
 //# sourceMappingURL=TrashBin.test.js.map