@webiny/app-aco 5.37.8 → 5.38.0-beta.0

package/components/AdvancedSearch/AdvancedSearchPresenter.test.js

@@ -0,0 +1,879 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _AdvancedSearchPresenter = require("./AdvancedSearchPresenter");
+var _domain = require("./domain");
+var mockGateway = {
+  list: jest.fn(),
+  get: jest.fn(),
+  create: jest.fn(),
+  update: jest.fn(),
+  delete: jest.fn()
+};
+var createMockGateway = function createMockGateway(_ref) {
+  var list = _ref.list,
+    get = _ref.get,
+    create = _ref.create,
+    update = _ref.update,
+    deleteFn = _ref.delete;
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, mockGateway), list && {
+    list: list
+  }), get && {
+    get: get
+  }), create && {
+    create: create
+  }), update && {
+    update: update
+  }), deleteFn && {
+    delete: deleteFn
+  });
+};
+describe("AdvancedSearchPresenter", function () {
+  var namespace = "namespace";
+  var demoFilter = {
+    field: "any-field",
+    value: "any-value",
+    condition: "any-condition"
+  };
+  var demoGroup = {
+    operation: _domain.Operation.AND,
+    filters: [demoFilter]
+  };
+  var filter1 = {
+    id: "filter-1",
+    name: "Filter 1",
+    description: "Filter description",
+    operation: _domain.Operation.AND,
+    groups: [demoGroup],
+    createdOn: new Date().toString()
+  };
+  var filter2 = {
+    id: "filter-2",
+    name: "Filter 2",
+    operation: _domain.Operation.AND,
+    groups: [demoGroup],
+    createdOn: new Date().toString()
+  };
+  var gateway = createMockGateway({
+    list: jest.fn().mockImplementation(function () {
+      return Promise.resolve([filter1, filter2]);
+    }),
+    get: jest.fn().mockImplementation(function () {
+      return Promise.resolve(filter1);
+    }),
+    create: jest.fn().mockImplementation(function () {
+      return Promise.resolve(filter1);
+    }),
+    update: jest.fn().mockImplementation(function () {
+      return Promise.resolve((0, _objectSpread2.default)((0, _objectSpread2.default)({}, filter1), {}, {
+        name: "Filter 1 - Edit"
+      }));
+    }),
+    delete: jest.fn().mockImplementation(function () {
+      return Promise.resolve(true);
+    })
+  });
+  var presenter;
+  beforeEach(function () {
+    jest.clearAllMocks();
+    var repository = new _domain.FilterRepository(gateway, namespace);
+    presenter = new _AdvancedSearchPresenter.AdvancedSearchPresenter(repository);
+  });
+  it("should create a presenter and list filters from the gateway", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee() {
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return presenter.load();
+        case 2:
+          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: ""
+            }
+          });
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it("should transition to loading state and then to list state", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee2() {
+    var loadPromise;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          loadPromise = presenter.load();
+          expect(presenter.vm.managerVm).toMatchObject({
+            isOpen: false,
+            isLoading: true,
+            loadingLabel: "Listing filters",
+            view: "EMPTY",
+            filters: []
+          });
+          _context2.next = 4;
+          return loadPromise;
+        case 4:
+          expect(presenter.vm.managerVm).toMatchObject({
+            isOpen: false,
+            isLoading: false,
+            loadingLabel: "",
+            view: "LIST"
+          });
+        case 5:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it("should be able to apply a filter via filterId", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee3() {
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 2;
+          return presenter.load();
+        case 2:
+          _context3.next = 4;
+          return presenter.applyFilter("filter-1");
+        case 4:
+          expect(presenter.vm).toMatchObject({
+            appliedFilter: filter1,
+            currentFilter: null,
+            managerVm: {
+              isOpen: false
+            },
+            builderVm: {
+              isOpen: false
+            },
+            saverVm: {
+              isOpen: false
+            }
+          });
+        case 5:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it("should be able to apply directly a filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee4() {
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.next = 2;
+          return presenter.load();
+        case 2:
+          // Let's apply a filter
+          presenter.applyFilter(filter2);
+          expect(presenter.vm).toMatchObject({
+            appliedFilter: filter2,
+            managerVm: {
+              isOpen: false
+            },
+            builderVm: {
+              isOpen: false
+            },
+            saverVm: {
+              isOpen: false
+            }
+          });
+        case 4:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it("should be able to unset a filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee5() {
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          _context5.next = 2;
+          return presenter.load();
+        case 2:
+          _context5.next = 4;
+          return presenter.applyFilter("filter-1");
+        case 4:
+          presenter.unsetFilter();
+          expect(presenter.vm).toMatchObject({
+            appliedFilter: null,
+            currentFilter: null
+          });
+        case 6:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+  it("should be able to edit an already applied filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee6() {
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          _context6.next = 2;
+          return presenter.load();
+        case 2:
+          _context6.next = 4;
+          return presenter.applyFilter("filter-1");
+        case 4:
+          presenter.editAppliedFilter();
+          expect(presenter.vm).toMatchObject({
+            appliedFilter: filter1,
+            currentFilter: filter1,
+            builderVm: {
+              isOpen: true
+            }
+          });
+        case 6:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it("should be create a new filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee7() {
+    var filter, persistPromise;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          _context7.next = 2;
+          return presenter.load();
+        case 2:
+          // Let's open the filter manager
+          presenter.openManager();
+          expect(presenter.vm).toMatchObject({
+            managerVm: {
+              isOpen: true
+            }
+          });
+
+          // Let's create a new filter via builder
+          presenter.createFilter();
+          expect(presenter.vm).toMatchObject({
+            currentFilter: {
+              id: "",
+              name: "Draft filter",
+              description: "",
+              operation: _domain.Operation.AND,
+              groups: [{
+                operation: _domain.Operation.AND,
+                filters: [{
+                  field: "",
+                  condition: "",
+                  value: ""
+                }]
+              }]
+            },
+            managerVm: {
+              isOpen: false
+            },
+            builderVm: {
+              isOpen: true
+            },
+            saverVm: {
+              isOpen: false
+            }
+          });
+
+          // Let's change the Filter and open the saver
+          filter = {
+            id: "",
+            name: "Draft filter",
+            description: "",
+            operation: _domain.Operation.AND,
+            groups: [{
+              operation: _domain.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
+            }
+          });
+
+          // Let's save it via the gateway
+          persistPromise = presenter.persistFilter(filter); // Let's check the transition to loading state
+          expect(presenter.vm.saverVm).toMatchObject({
+            isOpen: true,
+            isLoading: true,
+            loadingLabel: "Creating filter"
+          });
+          _context7.next = 13;
+          return persistPromise;
+        case 13:
+          expect(gateway.create).toBeCalledTimes(1);
+          expect(gateway.create).toHaveBeenCalledWith({
+            id: expect.any(String),
+            name: "Draft filter",
+            description: "",
+            namespace: namespace,
+            operation: _domain.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.'
+            }
+          });
+
+          // Let's open the manager again and check if the new filter is there.
+          // Be aware: data comes from the mocked gateway
+          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
+          });
+        case 19:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+  it("should be able to update an existing filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee8() {
+    var filter, persistPromise;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          _context8.next = 2;
+          return presenter.load();
+        case 2:
+          // Let's open the filter manager
+          presenter.openManager();
+          expect(presenter.vm).toMatchObject({
+            managerVm: {
+              isOpen: true
+            }
+          });
+
+          // Let's select a filter to edit in the builder
+          _context8.next = 6;
+          return presenter.editFilter("filter-1");
+        case 6:
+          expect(presenter.vm).toMatchObject({
+            currentFilter: filter1,
+            managerVm: {
+              isOpen: false
+            },
+            builderVm: {
+              isOpen: true
+            },
+            saverVm: {
+              isOpen: false
+            }
+          });
+
+          // Let's change the Filter and open the saver
+          filter = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, filter1), {}, {
+            groups: [{
+              operation: _domain.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
+            }
+          });
+
+          // Let's save it via the gateway
+          persistPromise = presenter.persistFilter(filter); // Let's check the transition to loading state
+          expect(presenter.vm.saverVm).toMatchObject({
+            isOpen: true,
+            isLoading: true,
+            loadingLabel: "Updating filter"
+          });
+          _context8.next = 14;
+          return persistPromise;
+        case 14:
+          expect(gateway.update).toBeCalledTimes(1);
+          expect(gateway.update).toHaveBeenCalledWith({
+            id: "filter-1",
+            name: "Filter 1",
+            description: "Filter description",
+            operation: _domain.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.'
+            }
+          });
+
+          // Let's open the manager again and check if the new data is there.
+          // Be aware: data comes from the mocked gateway
+          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
+          });
+        case 20:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  it("should be able to rename a filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee9() {
+    var persistPromise;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee9$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          _context9.next = 2;
+          return presenter.load();
+        case 2:
+          // Let's open the filter manager
+          presenter.openManager();
+          expect(presenter.vm).toMatchObject({
+            managerVm: {
+              isOpen: true
+            }
+          });
+
+          // Let's rename a filter
+          _context9.next = 6;
+          return presenter.renameFilter("filter-1");
+        case 6:
+          expect(presenter.vm).toMatchObject({
+            currentFilter: filter1,
+            managerVm: {
+              isOpen: false
+            },
+            builderVm: {
+              isOpen: false
+            },
+            saverVm: {
+              isOpen: true
+            }
+          });
+
+          // Let's save it via the gateway
+          persistPromise = presenter.persistFilter((0, _objectSpread2.default)((0, _objectSpread2.default)({}, filter1), {}, {
+            name: "".concat(filter1.name, " - Edit")
+          })); // Let's check the transition to loading state
+          expect(presenter.vm.saverVm).toMatchObject({
+            isOpen: true,
+            isLoading: true,
+            loadingLabel: "Updating filter"
+          });
+          _context9.next = 11;
+          return persistPromise;
+        case 11:
+          expect(gateway.update).toBeCalledTimes(1);
+          expect(gateway.update).toHaveBeenCalledWith({
+            id: "filter-1",
+            name: "".concat(filter1.name, " - Edit"),
+            description: "Filter description",
+            operation: _domain.Operation.AND,
+            groups: [filter1.groups[0]]
+          });
+          expect(presenter.vm).toMatchObject({
+            managerVm: {
+              isOpen: false
+            },
+            builderVm: {
+              isOpen: false
+            },
+            saverVm: {
+              isOpen: false
+            },
+            feedbackVm: {
+              isOpen: true,
+              message: "Filter \"".concat(filter1.name, " - Edit\" was successfully updated.")
+            }
+          });
+
+          // Let's open the manager again and check if the new data is there.
+          // Be aware: data comes from the mocked gateway
+          presenter.openManager();
+          expect(presenter.vm.managerVm.filters.length).toBe(2);
+          expect(presenter.vm.managerVm.filters[0]).toEqual({
+            id: filter1.id,
+            name: "".concat(filter1.name, " - Edit"),
+            description: filter1.description,
+            createdOn: filter1.createdOn
+          });
+        case 17:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  })));
+  it("should be able to clone a filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee10() {
+    var clonedFilter, persistPromise;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee10$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          _context10.next = 2;
+          return presenter.load();
+        case 2:
+          // Let's open the filter manager
+          presenter.openManager();
+          expect(presenter.vm).toMatchObject({
+            managerVm: {
+              isOpen: true
+            }
+          });
+
+          // Let's clone a filter
+          _context10.next = 6;
+          return presenter.cloneFilter("filter-1");
+        case 6:
+          clonedFilter = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, filter1), {}, {
+            id: "",
+            name: "Clone of ".concat(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
+            }
+          });
+
+          // Let's save it via the gateway
+          persistPromise = presenter.persistFilter(clonedFilter); // Let's check the transition to loading state
+          expect(presenter.vm.saverVm).toMatchObject({
+            isOpen: true,
+            isLoading: true,
+            loadingLabel: "Creating filter"
+          });
+          _context10.next = 14;
+          return persistPromise;
+        case 14:
+          expect(gateway.create).toBeCalledTimes(1);
+          expect(gateway.create).toHaveBeenCalledWith({
+            id: expect.any(String),
+            name: "Clone of ".concat(filter1.name),
+            description: "Filter description",
+            namespace: namespace,
+            operation: _domain.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 ".concat(filter1.name, "\" was successfully created.")
+            }
+          });
+
+          // Let's open the manager again and check if the new data is there
+          presenter.openManager();
+          expect(presenter.vm.managerVm.filters.length).toBe(3);
+        case 19:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  })));
+  it("should be able to delete a filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee11() {
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee11$(_context11) {
+      while (1) switch (_context11.prev = _context11.next) {
+        case 0:
+          _context11.next = 2;
+          return presenter.load();
+        case 2:
+          // Let's open the filter manager
+          presenter.openManager();
+          expect(presenter.vm).toMatchObject({
+            managerVm: {
+              isOpen: true
+            }
+          });
+
+          // Let's delete a filter
+          _context11.next = 6;
+          return presenter.deleteFilter("filter-1");
+        case 6:
+          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.'
+            }
+          });
+
+          // Let's check if the filter has been deleted and is not in the manager.
+          // Be aware: data comes from the mocked gateway
+          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
+          });
+        case 12:
+        case "end":
+          return _context11.stop();
+      }
+    }, _callee11);
+  })));
+  it("should be able to handle an empty list - error from the gateway", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee12() {
+    var message, gateway, repository, presenter;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee12$(_context12) {
+      while (1) switch (_context12.prev = _context12.next) {
+        case 0:
+          message = "Gateway error while listing filters";
+          gateway = createMockGateway({
+            list: jest.fn().mockRejectedValue(new Error(message))
+          });
+          repository = new _domain.FilterRepository(gateway, namespace);
+          presenter = new _AdvancedSearchPresenter.AdvancedSearchPresenter(repository); // Let's load the app, without filters
+          _context12.next = 6;
+          return presenter.load();
+        case 6:
+          expect(presenter.vm).toMatchObject({
+            managerVm: {
+              isOpen: false,
+              view: "EMPTY",
+              loadingLabel: "",
+              filters: []
+            },
+            feedbackVm: {
+              isOpen: true,
+              message: message
+            }
+          });
+        case 7:
+        case "end":
+          return _context12.stop();
+      }
+    }, _callee12);
+  })));
+  it("should be able to handle error while creating the filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee13() {
+    var message, createGateway, repository, presenter, filter;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee13$(_context13) {
+      while (1) switch (_context13.prev = _context13.next) {
+        case 0:
+          message = "Gateway error while creating filter";
+          createGateway = createMockGateway((0, _objectSpread2.default)((0, _objectSpread2.default)({}, gateway), {}, {
+            create: jest.fn().mockRejectedValue(new Error(message))
+          }));
+          repository = new _domain.FilterRepository(createGateway, namespace);
+          presenter = new _AdvancedSearchPresenter.AdvancedSearchPresenter(repository); // Let's load some filters
+          _context13.next = 6;
+          return presenter.load();
+        case 6:
+          // Let's try to save a Filter
+          filter = {
+            id: "",
+            name: "Draft filter",
+            description: "",
+            operation: _domain.Operation.AND,
+            groups: [{
+              operation: _domain.Operation.OR,
+              filters: [{
+                field: "Field value",
+                condition: "field_condition",
+                value: "Any value"
+              }]
+            }]
+          };
+          _context13.next = 9;
+          return presenter.persistFilter(filter);
+        case 9:
+          expect(presenter.vm).toMatchObject({
+            feedbackVm: {
+              isOpen: true,
+              message: message
+            }
+          });
+        case 10:
+        case "end":
+          return _context13.stop();
+      }
+    }, _callee13);
+  })));
+  it("should be able to handle error while updating a filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee14() {
+    var message, updateGateway, repository, presenter, filter;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee14$(_context14) {
+      while (1) switch (_context14.prev = _context14.next) {
+        case 0:
+          message = "Gateway error while updating filter";
+          updateGateway = createMockGateway((0, _objectSpread2.default)((0, _objectSpread2.default)({}, gateway), {}, {
+            update: jest.fn().mockRejectedValue(new Error(message))
+          }));
+          repository = new _domain.FilterRepository(updateGateway, namespace);
+          presenter = new _AdvancedSearchPresenter.AdvancedSearchPresenter(repository); // Let's load some filters
+          _context14.next = 6;
+          return presenter.load();
+        case 6:
+          // Let's try to save a Filter
+          filter = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, filter1), {}, {
+            name: filter1 + " - Edit"
+          });
+          _context14.next = 9;
+          return presenter.persistFilter(filter);
+        case 9:
+          expect(presenter.vm).toMatchObject({
+            feedbackVm: {
+              isOpen: true,
+              message: message
+            }
+          });
+        case 10:
+        case "end":
+          return _context14.stop();
+      }
+    }, _callee14);
+  })));
+  it("should be able to handle error while deleting a filter", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee15() {
+    var message, updateGateway, repository, presenter;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee15$(_context15) {
+      while (1) switch (_context15.prev = _context15.next) {
+        case 0:
+          message = "Gateway error while deleting filter";
+          updateGateway = createMockGateway((0, _objectSpread2.default)((0, _objectSpread2.default)({}, gateway), {}, {
+            delete: jest.fn().mockRejectedValue(new Error(message))
+          }));
+          repository = new _domain.FilterRepository(updateGateway, namespace);
+          presenter = new _AdvancedSearchPresenter.AdvancedSearchPresenter(repository); // Let's load some filters
+          _context15.next = 6;
+          return presenter.load();
+        case 6:
+          _context15.next = 8;
+          return presenter.deleteFilter(filter1.id);
+        case 8:
+          expect(presenter.vm).toMatchObject({
+            feedbackVm: {
+              isOpen: true,
+              message: message
+            }
+          });
+        case 9:
+        case "end":
+          return _context15.stop();
+      }
+    }, _callee15);
+  })));
+  it("should be able to show a feedback message", /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee16() {
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee16$(_context16) {
+      while (1) switch (_context16.prev = _context16.next) {
+        case 0:
+          _context16.next = 2;
+          return presenter.load();
+        case 2:
+          // Let's show any random feedback message
+          presenter.showFeedback("Any message");
+          expect(presenter.vm).toMatchObject({
+            currentFilter: null,
+            feedbackVm: {
+              isOpen: true,
+              message: "Any message"
+            }
+          });
+        case 4:
+        case "end":
+          return _context16.stop();
+      }
+    }, _callee16);
+  })));
+});
+
+//# sourceMappingURL=AdvancedSearchPresenter.test.js.map