@webiny/app-aco 0.0.0-unstable.496cf268ac → 0.0.0-unstable.5387e5f7c8

package/components/AdvancedSearch/AdvancedSearchPresenter.test.js

@@ -0,0 +1,666 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AdvancedSearchPresenter } from "./AdvancedSearchPresenter.js";
+import { FilterRepository, Operation } from "./domain/index.js";
+const mockGateway = {
+    list: vi.fn(),
+    get: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn()
+};
+const createMockGateway = ({ list, get, create, update, delete: deleteFn })=>({
+        ...mockGateway,
+        ...list && {
+            list
+        },
+        ...get && {
+            get
+        },
+        ...create && {
+            create
+        },
+        ...update && {
+            update
+        },
+        ...deleteFn && {
+            delete: deleteFn
+        }
+    });
+describe("AdvancedSearchPresenter", ()=>{
+    const namespace = "namespace";
+    const demoFilter = {
+        field: "any-field",
+        value: "any-value",
+        condition: "any-condition"
+    };
+    const demoGroup = {
+        operation: Operation.AND,
+        filters: [
+            demoFilter
+        ]
+    };
+    const filter1 = {
+        id: "filter-1",
+        name: "Filter 1",
+        description: "Filter description",
+        operation: Operation.AND,
+        groups: [
+            demoGroup
+        ],
+        createdOn: new Date().toString()
+    };
+    const filter2 = {
+        id: "filter-2",
+        name: "Filter 2",
+        operation: Operation.AND,
+        groups: [
+            demoGroup
+        ],
+        createdOn: new Date().toString()
+    };
+    const gateway = createMockGateway({
+        list: vi.fn().mockImplementation(()=>Promise.resolve([
+                filter1,
+                filter2
+            ])),
+        get: vi.fn().mockImplementation(()=>Promise.resolve(filter1)),
+        create: vi.fn().mockImplementation(()=>Promise.resolve(filter1)),
+        update: vi.fn().mockImplementation(()=>Promise.resolve({
+                ...filter1,
+                name: "Filter 1 - Edit"
+            })),
+        delete: vi.fn().mockImplementation(()=>Promise.resolve(true))
+    });
+    let presenter;
+    beforeEach(()=>{
+        vi.clearAllMocks();
+        const repository = new FilterRepository(gateway, namespace);
+        presenter = new AdvancedSearchPresenter(repository);
+    });
+    it("should create a presenter and list filters from the gateway", async ()=>{
+        await presenter.load();
+        expect(gateway.list).toBeCalledTimes(1);
+        expect(presenter.vm).toEqual({
+            appliedFilter: null,
+            currentFilter: null,
+            feedbackVm: {
+                isOpen: false,
+                message: ""
+            },
+            managerVm: {
+                isOpen: false,
+                view: "LIST",
+                isLoading: false,
+                loadingLabel: "",
+                filters: [
+                    {
+                        id: filter1.id,
+                        name: filter1.name,
+                        description: filter1.description,
+                        createdOn: filter1.createdOn
+                    },
+                    {
+                        id: filter2.id,
+                        name: filter2.name,
+                        description: "",
+                        createdOn: filter2.createdOn
+                    }
+                ]
+            },
+            builderVm: {
+                isOpen: false
+            },
+            saverVm: {
+                isOpen: false,
+                isLoading: false,
+                loadingLabel: ""
+            }
+        });
+    });
+    it("should transition to loading state and then to list state", async ()=>{
+        const loadPromise = presenter.load();
+        expect(presenter.vm.managerVm).toMatchObject({
+            isOpen: false,
+            isLoading: true,
+            loadingLabel: "Listing filters",
+            view: "EMPTY",
+            filters: []
+        });
+        await loadPromise;
+        expect(presenter.vm.managerVm).toMatchObject({
+            isOpen: false,
+            isLoading: false,
+            loadingLabel: "",
+            view: "LIST"
+        });
+    });
+    it("should be able to apply a filter via filterId", async ()=>{
+        await presenter.load();
+        await presenter.applyFilter("filter-1");
+        expect(presenter.vm).toMatchObject({
+            appliedFilter: filter1,
+            currentFilter: null,
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: false
+            },
+            saverVm: {
+                isOpen: false
+            }
+        });
+    });
+    it("should be able to apply directly a filter", async ()=>{
+        await presenter.load();
+        presenter.applyFilter(filter2);
+        expect(presenter.vm).toMatchObject({
+            appliedFilter: filter2,
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: false
+            },
+            saverVm: {
+                isOpen: false
+            }
+        });
+    });
+    it("should be able to unset a filter", async ()=>{
+        await presenter.load();
+        await presenter.applyFilter("filter-1");
+        presenter.unsetFilter();
+        expect(presenter.vm).toMatchObject({
+            appliedFilter: null,
+            currentFilter: null
+        });
+    });
+    it("should be able to edit an already applied filter", async ()=>{
+        await presenter.load();
+        await presenter.applyFilter("filter-1");
+        presenter.editAppliedFilter();
+        expect(presenter.vm).toMatchObject({
+            appliedFilter: filter1,
+            currentFilter: filter1,
+            builderVm: {
+                isOpen: true
+            }
+        });
+    });
+    it("should be create a new filter", async ()=>{
+        await presenter.load();
+        presenter.openManager();
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: true
+            }
+        });
+        presenter.createFilter();
+        expect(presenter.vm).toMatchObject({
+            currentFilter: {
+                id: "",
+                name: "Draft filter",
+                description: "",
+                operation: Operation.AND,
+                groups: [
+                    {
+                        operation: Operation.AND,
+                        filters: [
+                            {
+                                field: "",
+                                condition: "",
+                                value: ""
+                            }
+                        ]
+                    }
+                ]
+            },
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: true
+            },
+            saverVm: {
+                isOpen: false
+            }
+        });
+        const filter = {
+            id: "",
+            name: "Draft filter",
+            description: "",
+            operation: Operation.AND,
+            groups: [
+                {
+                    operation: Operation.OR,
+                    filters: [
+                        {
+                            field: "Field value",
+                            condition: "field_condition",
+                            value: "Any value"
+                        }
+                    ]
+                }
+            ]
+        };
+        presenter.saveFilter(filter);
+        expect(presenter.vm).toMatchObject({
+            currentFilter: filter,
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: true
+            },
+            saverVm: {
+                isOpen: true
+            }
+        });
+        const persistPromise = presenter.persistFilter(filter);
+        expect(presenter.vm.saverVm).toMatchObject({
+            isOpen: true,
+            isLoading: true,
+            loadingLabel: "Creating filter..."
+        });
+        await persistPromise;
+        expect(gateway.create).toBeCalledTimes(1);
+        expect(gateway.create).toHaveBeenCalledWith({
+            id: expect.any(String),
+            name: "Draft filter",
+            description: "",
+            namespace,
+            operation: Operation.AND,
+            groups: [
+                filter.groups[0]
+            ]
+        });
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: false
+            },
+            saverVm: {
+                isOpen: false
+            },
+            feedbackVm: {
+                isOpen: true,
+                message: 'Filter "Draft filter" was successfully created.'
+            }
+        });
+        presenter.openManager();
+        expect(presenter.vm.managerVm.filters.length).toBe(3);
+        expect(presenter.vm.managerVm.filters[0]).toEqual({
+            id: filter1.id,
+            name: filter1.name,
+            description: filter1.description,
+            createdOn: filter1.createdOn
+        });
+    });
+    it("should be able to update an existing filter", async ()=>{
+        await presenter.load();
+        presenter.openManager();
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: true
+            }
+        });
+        await presenter.editFilter("filter-1");
+        expect(presenter.vm).toMatchObject({
+            currentFilter: filter1,
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: true
+            },
+            saverVm: {
+                isOpen: false
+            }
+        });
+        const filter = {
+            ...filter1,
+            groups: [
+                {
+                    operation: Operation.OR,
+                    filters: [
+                        {
+                            field: "Field value",
+                            condition: "field_condition",
+                            value: "Any value"
+                        }
+                    ]
+                }
+            ]
+        };
+        presenter.saveFilter(filter);
+        expect(presenter.vm).toMatchObject({
+            currentFilter: filter,
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: true
+            },
+            saverVm: {
+                isOpen: true
+            }
+        });
+        const persistPromise = presenter.persistFilter(filter);
+        expect(presenter.vm.saverVm).toMatchObject({
+            isOpen: true,
+            isLoading: true,
+            loadingLabel: "Updating filter..."
+        });
+        await persistPromise;
+        expect(gateway.update).toBeCalledTimes(1);
+        expect(gateway.update).toHaveBeenCalledWith({
+            id: "filter-1",
+            name: "Filter 1",
+            description: "Filter description",
+            operation: Operation.AND,
+            groups: [
+                filter.groups[0]
+            ]
+        });
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: false
+            },
+            saverVm: {
+                isOpen: false
+            },
+            feedbackVm: {
+                isOpen: true,
+                message: 'Filter "Filter 1" was successfully updated.'
+            }
+        });
+        presenter.openManager();
+        expect(presenter.vm.managerVm.filters.length).toBe(2);
+        expect(presenter.vm.managerVm.filters[0]).toEqual({
+            id: filter1.id,
+            name: "Filter 1 - Edit",
+            description: filter1.description,
+            createdOn: filter1.createdOn
+        });
+    });
+    it("should be able to rename a filter", async ()=>{
+        await presenter.load();
+        presenter.openManager();
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: true
+            }
+        });
+        await presenter.renameFilter("filter-1");
+        expect(presenter.vm).toMatchObject({
+            currentFilter: filter1,
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: false
+            },
+            saverVm: {
+                isOpen: true
+            }
+        });
+        const persistPromise = presenter.persistFilter({
+            ...filter1,
+            name: `${filter1.name} - Edit`
+        });
+        expect(presenter.vm.saverVm).toMatchObject({
+            isOpen: true,
+            isLoading: true,
+            loadingLabel: "Updating filter..."
+        });
+        await persistPromise;
+        expect(gateway.update).toBeCalledTimes(1);
+        expect(gateway.update).toHaveBeenCalledWith({
+            id: "filter-1",
+            name: `${filter1.name} - Edit`,
+            description: "Filter description",
+            operation: Operation.AND,
+            groups: [
+                filter1.groups[0]
+            ]
+        });
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: false
+            },
+            saverVm: {
+                isOpen: false
+            },
+            feedbackVm: {
+                isOpen: true,
+                message: `Filter "${filter1.name} - Edit" was successfully updated.`
+            }
+        });
+        presenter.openManager();
+        expect(presenter.vm.managerVm.filters.length).toBe(2);
+        expect(presenter.vm.managerVm.filters[0]).toEqual({
+            id: filter1.id,
+            name: `${filter1.name} - Edit`,
+            description: filter1.description,
+            createdOn: filter1.createdOn
+        });
+    });
+    it("should be able to clone a filter", async ()=>{
+        await presenter.load();
+        presenter.openManager();
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: true
+            }
+        });
+        await presenter.cloneFilter("filter-1");
+        const clonedFilter = {
+            ...filter1,
+            id: "",
+            name: `Clone of ${filter1.name}`
+        };
+        expect(presenter.vm).toMatchObject({
+            currentFilter: clonedFilter,
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: true
+            },
+            saverVm: {
+                isOpen: false
+            }
+        });
+        presenter.saveFilter(clonedFilter);
+        expect(presenter.vm).toMatchObject({
+            currentFilter: clonedFilter,
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: true
+            },
+            saverVm: {
+                isOpen: true
+            }
+        });
+        const persistPromise = presenter.persistFilter(clonedFilter);
+        expect(presenter.vm.saverVm).toMatchObject({
+            isOpen: true,
+            isLoading: true,
+            loadingLabel: "Creating filter..."
+        });
+        await persistPromise;
+        expect(gateway.create).toBeCalledTimes(1);
+        expect(gateway.create).toHaveBeenCalledWith({
+            id: expect.any(String),
+            name: `Clone of ${filter1.name}`,
+            description: "Filter description",
+            namespace,
+            operation: Operation.AND,
+            groups: [
+                filter1.groups[0]
+            ]
+        });
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: false
+            },
+            builderVm: {
+                isOpen: false
+            },
+            saverVm: {
+                isOpen: false
+            },
+            feedbackVm: {
+                isOpen: true,
+                message: `Filter "Clone of ${filter1.name}" was successfully created.`
+            }
+        });
+        presenter.openManager();
+        expect(presenter.vm.managerVm.filters.length).toBe(3);
+    });
+    it("should be able to delete a filter", async ()=>{
+        await presenter.load();
+        presenter.openManager();
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: true
+            }
+        });
+        await presenter.deleteFilter("filter-1");
+        expect(gateway.delete).toBeCalledTimes(1);
+        expect(gateway.delete).toHaveBeenCalledWith("filter-1");
+        expect(presenter.vm).toMatchObject({
+            currentFilter: null,
+            feedbackVm: {
+                isOpen: true,
+                message: 'Filter "Filter 1" was successfully deleted.'
+            }
+        });
+        presenter.openManager();
+        expect(presenter.vm.managerVm.filters.length).toBe(1);
+        expect(presenter.vm.managerVm.filters[0]).toEqual({
+            id: filter2.id,
+            name: filter2.name,
+            description: "",
+            createdOn: filter2.createdOn
+        });
+    });
+    it("should be able to handle an empty list - error from the gateway", async ()=>{
+        const message = "Gateway error while listing filters";
+        const gateway = createMockGateway({
+            list: vi.fn().mockRejectedValue(new Error(message))
+        });
+        const repository = new FilterRepository(gateway, namespace);
+        const presenter = new AdvancedSearchPresenter(repository);
+        await presenter.load();
+        expect(presenter.vm).toMatchObject({
+            managerVm: {
+                isOpen: false,
+                view: "EMPTY",
+                loadingLabel: "",
+                filters: []
+            },
+            feedbackVm: {
+                isOpen: true,
+                message
+            }
+        });
+    });
+    it("should be able to handle error while creating the filter", async ()=>{
+        const message = "Gateway error while creating filter";
+        const createGateway = createMockGateway({
+            ...gateway,
+            create: vi.fn().mockRejectedValue(new Error(message))
+        });
+        const repository = new FilterRepository(createGateway, namespace);
+        const presenter = new AdvancedSearchPresenter(repository);
+        await presenter.load();
+        const filter = {
+            id: "",
+            name: "Draft filter",
+            description: "",
+            operation: Operation.AND,
+            groups: [
+                {
+                    operation: Operation.OR,
+                    filters: [
+                        {
+                            field: "Field value",
+                            condition: "field_condition",
+                            value: "Any value"
+                        }
+                    ]
+                }
+            ]
+        };
+        await presenter.persistFilter(filter);
+        expect(presenter.vm).toMatchObject({
+            feedbackVm: {
+                isOpen: true,
+                message
+            }
+        });
+    });
+    it("should be able to handle error while updating a filter", async ()=>{
+        const message = "Gateway error while updating filter";
+        const updateGateway = createMockGateway({
+            ...gateway,
+            update: vi.fn().mockRejectedValue(new Error(message))
+        });
+        const repository = new FilterRepository(updateGateway, namespace);
+        const presenter = new AdvancedSearchPresenter(repository);
+        await presenter.load();
+        const filter = {
+            ...filter1,
+            name: filter1 + " - Edit"
+        };
+        await presenter.persistFilter(filter);
+        expect(presenter.vm).toMatchObject({
+            feedbackVm: {
+                isOpen: true,
+                message
+            }
+        });
+    });
+    it("should be able to handle error while deleting a filter", async ()=>{
+        const message = "Gateway error while deleting filter";
+        const updateGateway = createMockGateway({
+            ...gateway,
+            delete: vi.fn().mockRejectedValue(new Error(message))
+        });
+        const repository = new FilterRepository(updateGateway, namespace);
+        const presenter = new AdvancedSearchPresenter(repository);
+        await presenter.load();
+        await presenter.deleteFilter(filter1.id);
+        expect(presenter.vm).toMatchObject({
+            feedbackVm: {
+                isOpen: true,
+                message
+            }
+        });
+    });
+    it("should be able to show a feedback message", async ()=>{
+        await presenter.load();
+        presenter.showFeedback("Any message");
+        expect(presenter.vm).toMatchObject({
+            currentFilter: null,
+            feedbackVm: {
+                isOpen: true,
+                message: "Any message"
+            }
+        });
+    });
+});
+
+//# sourceMappingURL=AdvancedSearchPresenter.test.js.map