@sap/open.fe 1.98.0 → 1.99.0

package/packages/sap.fe.templates/test/sap/fe/templates/jest/ListReport/overrides/ViewState.spec.js

@@ -1,262 +1,485 @@
 /*!
  * SAP UI development toolkit for HTML5 (SAPUI5)
-        (c) Copyright 2009-2021 SAP SE. All rights reserved
-    
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
  */
-sap.ui.define(
-	[
-		"sap/fe/templates/ListReport/overrides/ViewState",
-		"sap/ui/mdc/p13n/StateUtil",
-		"sap/fe/core/CommonUtils",
-		"sap/fe/macros/filter/FilterUtils",
-		"sap/fe/core/templating/PropertyFormatters",
-		"sap/fe/core/helpers/ModelHelper",
-		"sap/fe/macros/DelegateUtil",
-		"sap/fe/test/UI5MockHelper",
-		"sap/ui/fl/apply/api/ControlVariantApplyAPI"
-	],
-	function(
-		ViewState,
-		StateUtil,
-		CommonUtils,
-		FilterUtils,
-		PropertyFormatters,
-		ModelHelper,
-		DelegateUtil,
-		UI5MockHelper,
-		ControlVariantApplyAPI
-	) {
-		ViewState._checkIfVariantIdIsAvailable = jest.fn(() => {
-			return true;
-		});
-		describe("ViewState", function() {
-			describe("_fnApplyConditions", () => {
-				var oGetFilterRestrictionsByPathMock,
-					oGetConvertedFilterFieldsMock,
-					oGetEntitySetPathMock,
-					oHasValueHelpMock,
-					oGetCustomDataMock,
-					oApplyExternalStateMock;
-				const mockModel = new UI5MockHelper.MockModel();
-				const mockMetaModel = new UI5MockHelper.MockMetaModel();
-				mockModel.setMetaModel(mockMetaModel);
-				const oFilterBar = {
-					getModel: function() {
-						return mockModel;
-					},
-					initialized: function() {
-						return Promise.resolve();
-					}
-				};
-				beforeAll(() => {
-					oGetFilterRestrictionsByPathMock = jest.spyOn(CommonUtils, "getFilterRestrictionsByPath");
-					oGetFilterRestrictionsByPathMock.mockImplementation(() => {
-						return {
-							FilterAllowedExpressions: {
-								SalesOrderDate: ["SingleRange"],
-								SoldToParty: ["SingleValue"]
-							},
-							NonFilterableProperties: ["OverallSDProcessStatus"],
-							RequiredProperties: []
-						};
-					});
-					oGetEntitySetPathMock = jest.spyOn(ModelHelper, "getEntitySetPath");
-					oGetEntitySetPathMock.mockImplementation(() => "/SalesOrderManage");
-					oGetConvertedFilterFieldsMock = jest.spyOn(FilterUtils, "getConvertedFilterFields");
-					oGetConvertedFilterFieldsMock.mockImplementation(() => {
-						return [
-							{
-								annotationPath: "/SalesOrderManage/SalesOrder",
-								availability: "Default",
-								caseSensitive: true,
-								conditionPath: "SalesOrder",
-								group: "",
-								groupLabel: "",
-								isParameter: false,
-								key: "SalesOrder",
-								label: "Sales Order No."
-							},
-							{
-								annotationPath: "/SalesOrderManage/SoldToParty",
-								availability: "Default",
-								caseSensitive: true,
-								conditionPath: "SoldToParty",
-								group: "",
-								groupLabel: "",
-								isParameter: false,
-								key: "SoldToParty",
-								label: "Sold-To Party"
-							},
-							{
-								annotationPath: "/SalesOrderManage/OverallSDProcessStatus",
-								availability: "Default",
-								caseSensitive: true,
-								conditionPath: "OverallSDProcessStatus",
-								group: "",
-								groupLabel: "",
-								isParameter: false,
-								key: "OverallSDProcessStatus",
-								label: "Overall Status"
-							},
-							{
-								annotationPath: "/SalesOrderManage/_SalesGroup_SalesGroup",
-								availability: "Adaptation",
-								caseSensitive: true,
-								conditionPath: "_SalesGroup_SalesGroup",
-								group: "SalesOrderManage",
-								groupLabel: "Manage Sales Order",
-								key: "_SalesGroup_SalesGroup",
-								label: "_SalesGroup_SalesGroup"
-							}
-						];
-					});
-					oHasValueHelpMock = jest.spyOn(PropertyFormatters, "hasValueHelp");
-					oHasValueHelpMock.mockImplementation(() => true);
-					oGetCustomDataMock = jest.spyOn(DelegateUtil, "getCustomData");
-					oGetCustomDataMock.mockImplementation(() => "/SalesOrderManage/");
-					oApplyExternalStateMock = jest.spyOn(StateUtil, "applyExternalState");
-					oApplyExternalStateMock.mockImplementation(() => {
-						return Promise.resolve();
-					});
-				});
-
-				it("check if conditions are applied correctly", async () => {
-					const oCondition = {
-						SalesOrder: [
-							{
-								operator: "EQ",
-								isEmpty: "null",
-								validated: "Validated",
-								values: ["6437"]
-							}
-						],
-						SoldToParty: [
-							{
-								operator: "Empty",
-								validated: "Validated",
-								values: ["69406910"]
-							}
-						],
-						OverallSDProcessStatus: [
-							{
-								operator: "EQ",
-								isEmpty: "null",
-								validated: "Validated",
-								values: ["A"]
-							}
-						]
-					};
-					await ViewState._fnApplyConditions(oFilterBar, oCondition);
-					var oState = {
-						filter: {
-							_SalesGroup_SalesGroup: [],
-							SalesOrder: [
-								{
-									operator: "EQ",
-									validated: "Validated",
-									values: ["6437"]
-								}
-							],
-							SoldToParty: [
-								{
-									operator: "EQ",
-									validated: "Validated",
-									values: [""]
-								}
-							]
-						},
-						items: [
-							{
-								name: "SalesOrder"
-							},
-							{
-								name: "SoldToParty"
-							}
-						]
-					};
-					expect(StateUtil.applyExternalState).toHaveBeenCalledWith(oFilterBar, oState);
-				});
-			});
-			describe("handleVariantIdPassedViaURLParams", function() {
-				const oUriParams = {
-					"sap-ui-fe-filterbar-variant-id": "123"
-				};
-				afterAll(() => {
-					jest.restoreAllMocks();
-				});
-				it("handleVariantIdPassedViaURLParams", async function() {
-					jest.spyOn(ViewState, "_handleControlVariantId").mockImplementationOnce(oUriParams => {
-						return Promise.resolve();
-					});
-					await expect(ViewState.handleVariantIdPassedViaURLParams(oUriParams)).resolves.toBe(undefined);
-				});
-				it("handleVariantIdPassedViaURLParams", async function() {
-					jest.spyOn(ViewState, "_handleControlVariantId").mockImplementationOnce(oUriParams => {
-						return Promise.reject();
-					});
-					await expect(ViewState.handleVariantIdPassedViaURLParams(oUriParams)).rejects;
-				});
-			});
-
-			describe("_handleControlVariantId", function() {
-				const oVariants = {
-					sPageVariantId: "123"
-				};
-
-				beforeAll(() => {
-					// @ts-ignore
-					ViewState.getView = jest.fn(() => {
-						return {
-							getViewData: function() {
-								return { variantManagement: "Page" };
-							},
-							byId: function() {
-								return {
-									getVariants: function() {
-										return [{ "key": "123" }];
-									}
-								};
-							}
-						};
-					});
-				});
-				afterAll(() => {
-					jest.restoreAllMocks();
-				});
-				it("_handleControlVariantId", async function() {
-					jest.spyOn(ViewState, "_applyControlVariant").mockImplementationOnce(() => {
-						return Promise.resolve();
-					});
-					await expect(ViewState._handleControlVariantId(oVariants)).resolves.toEqual([undefined]);
-				});
-				it("_handleControlVariantId", async function() {
-					jest.spyOn(ViewState, "_applyControlVariant").mockImplementationOnce(() => {
-						return Promise.reject();
-					});
-					await expect(ViewState._handleControlVariantId(oVariants)).rejects;
-				});
-			});
-
-			describe("_applyControlVariant", function() {
-				const oVariants = {
-					sPageVariantId: "123"
-				};
-				afterAll(() => {
-					jest.restoreAllMocks();
-				});
-				it("_applyControlVariant", async function() {
-					jest.spyOn(ControlVariantApplyAPI, "activateVariant").mockImplementationOnce(() => {
-						return Promise.resolve();
-					});
-					await expect(ViewState._applyControlVariant(oVariants, "123", true)).resolves.toBe(true);
-				});
-				it("_applyControlVariant", async function() {
-					jest.spyOn(ControlVariantApplyAPI, "activateVariant").mockImplementationOnce(() => {
-						return Promise.reject();
-					});
-					await expect(ViewState._applyControlVariant(oVariants, "123", true)).rejects;
-				});
-			});
-		});
-	}
-);
+sap.ui.define(["@sap-ux/jest-mock-ui5/dist/mvc", "sap/ui/core/mvc/View", "sap/fe/core/CommonUtils", "sap/fe/test/FeMocks", "sap/fe/templates/ListReport/overrides/ViewState", "@sap-ux/jest-mock-ui5/dist/generic", "sap/ui/mdc/Table", "sap/ui/fl/variants/VariantManagement", "sap/ui/fl/apply/api/ControlVariantApplyAPI", "sap/fe/core/controllerextensions/ViewState", "sap/fe/core/helpers/KeepAliveHelper", "sap/ui/core/Control", "sap/fe/core/helpers/ModelHelper", "sap/fe/macros/filter/FilterUtils", "sap/fe/core/templating/PropertyFormatters", "sap/fe/macros/DelegateUtil", "sap/ui/mdc/p13n/StateUtil", "sap/ui/model/odata/v4/ODataModel"], function (mvc, View, CommonUtils, FeMocks, ViewStateOverrides, generic, Table, VariantManagement, ControlVariantApplyAPI, ViewState, KeepAliveHelper, Control, ModelHelper, FilterUtils, PropertyFormatters, DelegateUtil, StateUtil, ODataModel) {
+  "use strict";
+
+  var mock = generic.mock;
+  var mockContextForExtension = FeMocks.mockContextForExtension;
+  var mockListReportController = FeMocks.mockListReportController;
+  var mockFilterBar = FeMocks.mockFilterBar;
+  var mockMVC = mvc.mockMVC;
+
+  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  var app;
+  var viewState;
+  describe("overrides/ViewState", function () {
+    beforeAll(function () {
+      // mock FE app around the controller extension ViewState
+      var controller = mockListReportController();
+      app = mockMVC(controller, View, ODataModel);
+      viewState = mockContextForExtension(ViewStateOverrides, controller, ViewState); // mock calls to ViewState base
+
+      viewState.mock._checkIfVariantIdIsAvailable.mockReturnValue(true);
+    });
+    describe("applyInitialStateOnly", function () {
+      test("empty method that always returns true", function () {
+        expect(viewState.applyInitialStateOnly()).toBe(true);
+      });
+    });
+    describe("onBeforeStateApplied", function () {
+      var filterBar = mockFilterBar();
+      var table = mock(Table);
+      beforeEach(function () {
+        filterBar.mock.initialized.mockReset();
+        table.mock.initialized.mockReset();
+      });
+      test("with FilterBar and tables", function () {
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+
+        app.controller.mock._getControls.mockReturnValueOnce([table]);
+
+        var promises = [];
+        viewState.onBeforeStateApplied(promises);
+        expect(promises.length).toBe(2);
+        expect(filterBar.initialized).toBeCalled();
+        expect(table.initialized).toBeCalled();
+      });
+      test("only FilterBar", function () {
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+
+        app.controller.mock._getControls.mockReturnValueOnce([]);
+
+        var promises = [];
+        viewState.onBeforeStateApplied(promises);
+        expect(promises.length).toBe(1);
+        expect(filterBar.initialized).toBeCalled();
+      });
+      test("only tables", function () {
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(undefined);
+
+        app.controller.mock._getControls.mockReturnValueOnce([table, table]);
+
+        var promises = [];
+        viewState.onBeforeStateApplied(promises);
+        expect(promises.length).toBe(2);
+        expect(table.initialized).toBeCalledTimes(2);
+      });
+      test("nothing to be initialized", function () {
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(undefined);
+
+        app.controller.mock._getControls.mockReturnValueOnce([]);
+
+        var promises = [];
+        viewState.onBeforeStateApplied(promises);
+        expect(promises.length).toBe(0);
+      });
+    });
+    describe("onAfterStateApplied", function () {
+      var filterBar = mockFilterBar();
+      beforeEach(function () {
+        filterBar.mock.setSuspendSelection.mockReset();
+
+        app.controller.mock._isFilterBarHidden.mockReset();
+      });
+      test("no FilterBar", function () {
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(undefined);
+
+        app.controller.mock._isFilterBarHidden.mockReturnValueOnce(false);
+
+        viewState.onAfterStateApplied();
+        expect(filterBar.mock.setSuspendSelection).not.toBeCalled();
+      });
+      test("visible FilterBar", function () {
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+
+        viewState.onAfterStateApplied();
+        expect(filterBar.mock.setSuspendSelection).toBeCalled();
+      });
+      test("hidden FilterBar", function () {
+        app.controller.mock._getFilterBarControl.mockReturnValue(undefined);
+
+        app.controller.mock._isFilterBarHidden.mockReturnValue(true);
+
+        var mockContext = {
+          setProperty: jest.fn()
+        };
+        app.view.mock.getBindingContext.mockReturnValue(mockContext);
+
+        app.controller.mock._isMultiMode.mockReturnValueOnce(false);
+
+        viewState.onAfterStateApplied();
+        expect(mockContext.setProperty).toBeCalledWith("hasPendingFilters", false);
+
+        app.controller.mock._isMultiMode.mockReturnValueOnce(true);
+
+        app.controller.mock._getControls.mockReturnValueOnce([]);
+
+        app.controller.mock._getCurrentControl.mockReturnValueOnce({
+          getId: function () {
+            return "";
+          }
+        });
+
+        viewState.onAfterStateApplied();
+        expect(mockContext.setProperty).toBeCalledWith("hasPendingFilters", false);
+        expect(app.controller._setCountsOutDated).toBeCalled();
+      });
+    });
+    describe("adaptBindingRefreshControls", function () {
+      test("controls are added", function () {
+        jest.spyOn(KeepAliveHelper, "getControlsForRefresh").mockImplementation(function () {
+          return [mock(Control)];
+        });
+        var controls = [];
+        viewState.adaptBindingRefreshControls(controls);
+        expect(controls.length).toBe(1);
+      });
+    });
+    describe("adaptStateControls", function () {
+      var vm = mock(VariantManagement);
+      var filterBar = mockFilterBar();
+      beforeAll(function () {
+        app.view.mock.byId.mockImplementation(function (id) {
+          var control = mock(Control);
+          control.mock.getId.mockReturnValue(id);
+          return control;
+        });
+      });
+      test("only the page", function () {
+        app.view.mock.getViewData.mockReturnValue({
+          variantManagement: "None"
+        });
+
+        app.controller.mock._getControls.mockReturnValueOnce([]);
+
+        var controls = [];
+        viewState.adaptStateControls(controls);
+        expect(controls.length).toBe(1);
+        expect(controls[0].getId()).toBe("fe::ListReport");
+      });
+      test("with filter bar", function () {
+        app.view.mock.getViewData.mockReturnValue({
+          variantManagement: "None"
+        });
+
+        app.controller.mock._getControls.mockReturnValueOnce([]);
+
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+
+        var controls = [];
+        viewState.adaptStateControls(controls);
+        expect(controls.length).toBe(2);
+        expect(controls[0]).toBe(filterBar);
+        expect(controls[1].getId()).toBe("fe::ListReport");
+      });
+      test("isMultiNode & control variant management", function () {
+        // multinode
+        app.controller.mock._isMultiMode.mockReturnValue(true);
+
+        var mnControl = mock(Control);
+
+        app.controller.mock._getMultiModeControl.mockReturnValueOnce(mnControl); // tables
+
+
+        app.controller.mock._getControls.mockReturnValueOnce([]); // control variant management
+
+
+        app.view.mock.getViewData.mockReturnValue({
+          variantManagement: "Control"
+        });
+        app.view.mock.getContent.mockReturnValue([{
+          data: function (id) {
+            return id;
+          }
+        }]);
+        var controls = [];
+        viewState.adaptStateControls(controls);
+        expect(controls.length).toBe(3); // FilterBar/Page VM must be listed before IconTabBar (MultiModeControl)
+
+        expect(controls[0].getId()).toBe("filterBarVariantId");
+        expect(controls[1]).toBe(mnControl);
+      });
+      test.skip("multiple tables", function () {// TODO
+      });
+    });
+    describe("retrieveAdditionalStates", function () {});
+    describe("_applySelectionVariant", function () {
+      test("no filter bar", function () {
+        var result = viewState._applySelectionVariant(app.view, {
+          selectionVariant: {}
+        }, true);
+
+        expect(result).toBeDefined();
+      });
+    });
+    describe("applyAdditionalStates", function () {
+      var filterBar = mockFilterBar();
+      test("data is not loaded", function () {
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+
+        viewState.applyAdditionalStates({
+          dataLoaded: false
+        });
+        expect(filterBar._bSearchTriggered).toBe(false);
+      });
+      test("data is loaded, with filterbar", function () {
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+
+        viewState.applyAdditionalStates({
+          dataLoaded: true
+        });
+        expect(filterBar.triggerSearch).toBeCalled();
+        expect(viewState._bSearchTriggered).toBe(true);
+      });
+    });
+    describe("applyNavigationParameters", function () {
+      var filterBar = mockFilterBar();
+      test("should add a promise to the promises parameter - without component data", function () {
+        app.controller.mock.getAppComponent.mockReturnValueOnce({
+          getComponentData: function () {
+            return {};
+          }
+        });
+        jest.spyOn(viewState, "handleVariantIdPassedViaURLParams").mockImplementation(function () {
+          return Promise.resolve([]);
+        });
+        var promises = [];
+        viewState.applyNavigationParameters({}, promises);
+        expect(app.controller.mock.getAppComponent).toBeCalled();
+        expect(viewState.handleVariantIdPassedViaURLParams).toBeCalled();
+        expect(promises.length).toBe(1);
+      });
+      test("should add a promise to the promises parameter - with component data", function () {
+        app.controller.mock.getAppComponent.mockReturnValueOnce({
+          getComponentData: function () {
+            return {};
+          }
+        });
+        jest.spyOn(viewState, "handleVariantIdPassedViaURLParams").mockImplementation(function () {
+          return Promise.resolve([]);
+        });
+        var vm = mock(VariantManagement);
+        jest.spyOn(viewState, "_getFilterBarVM").mockReturnValueOnce(vm);
+
+        app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+
+        app.view.mock.getViewData.mockReturnValue({
+          initialLoad: "Enabled"
+        });
+
+        app.controller.mock._shouldAutoTriggerSearch.mockReturnValueOnce(true);
+
+        app.view.mock.byId.mockReturnValue({
+          setHeaderExpanded: function () {
+            return jest.fn();
+          }
+        });
+        filterBar.mock.triggerSearch.mockImplementation(function () {
+          return true;
+        });
+        var promises = [];
+        viewState.applyNavigationParameters({}, promises);
+        expect(promises.length).toBe(1);
+      });
+      afterEach(function () {
+        jest.restoreAllMocks();
+      });
+    });
+    describe("handleVariantIdPassedViaURLParams", function () {
+      var variantId = "testId";
+      var vm = mock(VariantManagement);
+      beforeAll(function () {
+        app.view.mock.byId.mockReturnValue(vm);
+        app.view.mock.getContent.mockReturnValue([{
+          data: function (id) {
+            return id;
+          }
+        }]);
+        jest.spyOn(ControlVariantApplyAPI, "activateVariant").mockResolvedValue(true);
+        vm.mock.getVariants.mockReturnValue([{
+          key: variantId
+        }]);
+      });
+      test("Page variant", function () {
+        try {
+          app.view.mock.getViewData.mockReturnValue({
+            variantManagement: "Page"
+          });
+          return Promise.resolve(viewState.handleVariantIdPassedViaURLParams({
+            "sap-ui-fe-variant-id": [variantId]
+          })).then(function (results) {
+            expect(results).toBeDefined();
+            expect(results[0]).toBe(true);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      test("FilterBar variant", function () {
+        try {
+          app.view.mock.getViewData.mockReturnValue({
+            variantManagement: "Control"
+          });
+          return Promise.resolve(viewState.handleVariantIdPassedViaURLParams({
+            "sap-ui-fe-filterbar-variant-id": [variantId]
+          })).then(function (results) {
+            expect(results).toBeDefined();
+            expect(results[0]).toBe(true);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      test("Table variant", function () {
+        try {
+          app.view.mock.getViewData.mockReturnValue({
+            variantManagement: "Control"
+          });
+          var table = mock(Table);
+          table.mock.getVariant.mockReturnValue(vm);
+
+          app.controller.mock._getControls.mockReturnValue([table]);
+
+          return Promise.resolve(viewState.handleVariantIdPassedViaURLParams({
+            "sap-ui-fe-table-variant-id": [variantId]
+          })).then(function (results) {
+            expect(results).toBeDefined();
+            expect(results[0]).toBe(undefined);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+    describe("private", function () {
+      describe("_fnApplyConditions", function () {
+        beforeAll(function () {
+          jest.spyOn(CommonUtils, "getFilterRestrictionsByPath").mockImplementation(function () {
+            return {
+              FilterAllowedExpressions: {
+                SalesOrderDate: ["SingleRange"],
+                SoldToParty: ["SingleValue"]
+              },
+              NonFilterableProperties: ["OverallSDProcessStatus"],
+              RequiredProperties: []
+            };
+          });
+          jest.spyOn(ModelHelper, "getEntitySetPath").mockImplementation(function () {
+            return "/SalesOrderManage";
+          });
+          jest.spyOn(FilterUtils, "getConvertedFilterFields").mockImplementation(function () {
+            return [{
+              annotationPath: "/SalesOrderManage/SalesOrder",
+              availability: "Default",
+              caseSensitive: true,
+              conditionPath: "SalesOrder",
+              group: "",
+              groupLabel: "",
+              isParameter: false,
+              key: "SalesOrder",
+              label: "Sales Order No."
+            }, {
+              annotationPath: "/SalesOrderManage/SoldToParty",
+              availability: "Default",
+              caseSensitive: true,
+              conditionPath: "SoldToParty",
+              group: "",
+              groupLabel: "",
+              isParameter: false,
+              key: "SoldToParty",
+              label: "Sold-To Party"
+            }, {
+              annotationPath: "/SalesOrderManage/OverallSDProcessStatus",
+              availability: "Default",
+              caseSensitive: true,
+              conditionPath: "OverallSDProcessStatus",
+              group: "",
+              groupLabel: "",
+              isParameter: false,
+              key: "OverallSDProcessStatus",
+              label: "Overall Status"
+            }, {
+              annotationPath: "/SalesOrderManage/_SalesGroup_SalesGroup",
+              availability: "Adaptation",
+              caseSensitive: true,
+              conditionPath: "_SalesGroup_SalesGroup",
+              group: "SalesOrderManage",
+              groupLabel: "Manage Sales Order",
+              key: "_SalesGroup_SalesGroup",
+              label: "_SalesGroup_SalesGroup"
+            }];
+          });
+          jest.spyOn(PropertyFormatters, "hasValueHelp").mockImplementation(function () {
+            return true;
+          });
+          jest.spyOn(DelegateUtil, "getCustomData").mockReturnValue("/SalesOrderManage/");
+          jest.spyOn(StateUtil, "applyExternalState").mockResolvedValue(true);
+        });
+        afterAll(function () {
+          jest.restoreAllMocks();
+        });
+        it("check if conditions are applied correctly", function () {
+          try {
+            var order = {
+              operator: "EQ",
+              validated: "Validated",
+              values: ["6437"]
+            };
+            var condition = {
+              SalesOrder: [_objectSpread(_objectSpread({}, order), {}, {
+                isEmpty: "null"
+              })],
+              SoldToParty: [{
+                operator: "Empty",
+                validated: "Validated",
+                values: ["69406910"]
+              }],
+              OverallSDProcessStatus: [{
+                operator: "EQ",
+                isEmpty: "null",
+                validated: "Validated",
+                values: ["A"]
+              }]
+            };
+            var state = {
+              filter: {
+                _SalesGroup_SalesGroup: [],
+                SalesOrder: [order],
+                SoldToParty: [{
+                  operator: "EQ",
+                  validated: "Validated",
+                  values: [""]
+                }]
+              },
+              items: [{
+                name: "SalesOrder"
+              }, {
+                name: "SoldToParty"
+              }]
+            };
+            var filterBar = mockFilterBar();
+            filterBar.mock.initialized.mockResolvedValue(true);
+            filterBar.mock.getModel.mockReturnValue(app.model);
+            var metaModel = app.model.mock.getMetaModel();
+            metaModel.mock.createBindingContext.mockReturnValue({
+              getObject: jest.fn()
+            });
+            return Promise.resolve(viewState._fnApplyConditions(filterBar, condition)).then(function () {
+              expect(StateUtil.applyExternalState).toHaveBeenCalledWith(filterBar, state);
+            });
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        });
+      });
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["ViewState.spec.ts"],"names":["app","viewState","describe","beforeAll","controller","mockListReportController","mockMVC","View","ODataModel","mockContextForExtension","ViewStateOverrides","ViewState","mock","_checkIfVariantIdIsAvailable","mockReturnValue","test","expect","applyInitialStateOnly","toBe","filterBar","mockFilterBar","table","Table","beforeEach","initialized","mockReset","_getFilterBarControl","mockReturnValueOnce","_getControls","promises","onBeforeStateApplied","length","toBeCalled","undefined","toBeCalledTimes","setSuspendSelection","_isFilterBarHidden","onAfterStateApplied","not","mockContext","setProperty","jest","fn","view","getBindingContext","_isMultiMode","toBeCalledWith","_getCurrentControl","getId","_setCountsOutDated","spyOn","KeepAliveHelper","mockImplementation","Control","controls","adaptBindingRefreshControls","vm","VariantManagement","byId","id","control","getViewData","variantManagement","adaptStateControls","mnControl","_getMultiModeControl","getContent","data","skip","result","_applySelectionVariant","selectionVariant","toBeDefined","applyAdditionalStates","dataLoaded","_bSearchTriggered","triggerSearch","getAppComponent","getComponentData","Promise","resolve","applyNavigationParameters","handleVariantIdPassedViaURLParams","initialLoad","_shouldAutoTriggerSearch","setHeaderExpanded","afterEach","restoreAllMocks","variantId","ControlVariantApplyAPI","mockResolvedValue","getVariants","key","results","getVariant","CommonUtils","FilterAllowedExpressions","SalesOrderDate","SoldToParty","NonFilterableProperties","RequiredProperties","ModelHelper","FilterUtils","annotationPath","availability","caseSensitive","conditionPath","group","groupLabel","isParameter","label","PropertyFormatters","DelegateUtil","StateUtil","afterAll","it","order","operator","validated","values","condition","SalesOrder","isEmpty","OverallSDProcessStatus","state","filter","_SalesGroup_SalesGroup","items","name","getModel","model","metaModel","getMetaModel","createBindingContext","getObject","_fnApplyConditions","applyExternalState","toHaveBeenCalledWith"],"mappings":"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","sourceRoot":".","sourcesContent":["import { mockMVC, MVCMock } from \"@sap-ux/jest-mock-ui5/dist/mvc\";\nimport Controller from \"sap/ui/core/mvc/Controller\";\nimport View from \"sap/ui/core/mvc/View\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport PageController from \"sap/fe/core/PageController\";\nimport { ListReportControllerType, mockFilterBar, mockListReportController, mockContextForExtension } from \"sap/fe/test/FeMocks\";\nimport { ViewState as ViewStateOverrides, ViewStateType } from \"sap/fe/templates/ListReport/overrides\";\nimport { mock, WithMock } from \"@sap-ux/jest-mock-ui5/dist/generic\";\nimport Table from \"sap/ui/mdc/Table\";\nimport VariantManagement from \"sap/ui/fl/variants/VariantManagement\";\nimport ControlVariantApplyAPI from \"sap/ui/fl/apply/api/ControlVariantApplyAPI\";\nimport { ViewState } from \"sap/fe/core/controllerextensions\";\nimport KeepAliveHelper from \"sap/fe/core/helpers/KeepAliveHelper\";\nimport Control from \"sap/ui/core/Control\";\nimport ModelHelper from \"sap/fe/core/helpers/ModelHelper\";\nimport { FilterUtils } from \"sap/fe/macros/filter\";\nimport * as PropertyFormatters from \"sap/fe/core/templating/PropertyFormatters\";\nimport { DelegateUtil } from \"sap/fe/macros\";\nimport StateUtil from \"sap/ui/mdc/p13n/StateUtil\";\nimport ODataModel from \"sap/ui/model/odata/v4/ODataModel\";\n\nlet app!: MVCMock<ODataModel, View, ListReportControllerType & PageController & Controller>;\nlet viewState!: WithMock<ViewStateType & ViewState>;\n\ndescribe(\"overrides/ViewState\", () => {\n\tbeforeAll(() => {\n\t\t// mock FE app around the controller extension ViewState\n\t\tconst controller = mockListReportController();\n\t\tapp = mockMVC(controller, View, ODataModel);\n\t\tviewState = mockContextForExtension(ViewStateOverrides, controller, ViewState);\n\t\t// mock calls to ViewState base\n\t\tviewState.mock._checkIfVariantIdIsAvailable.mockReturnValue(true);\n\t});\n\n\tdescribe(\"applyInitialStateOnly\", () => {\n\t\ttest(\"empty method that always returns true\", () => {\n\t\t\texpect(viewState.applyInitialStateOnly()).toBe(true);\n\t\t});\n\t});\n\n\tdescribe(\"onBeforeStateApplied\", () => {\n\t\tconst filterBar = mockFilterBar();\n\t\tconst table = mock(Table);\n\n\t\tbeforeEach(() => {\n\t\t\tfilterBar.mock.initialized.mockReset();\n\t\t\ttable.mock.initialized.mockReset();\n\t\t});\n\n\t\ttest(\"with FilterBar and tables\", () => {\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);\n\t\t\tapp.controller.mock._getControls.mockReturnValueOnce([table]);\n\t\t\tconst promises: unknown[] = [];\n\t\t\tviewState.onBeforeStateApplied(promises);\n\t\t\texpect(promises.length).toBe(2);\n\t\t\texpect(filterBar.initialized).toBeCalled();\n\t\t\texpect(table.initialized).toBeCalled();\n\t\t});\n\n\t\ttest(\"only FilterBar\", () => {\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);\n\t\t\tapp.controller.mock._getControls.mockReturnValueOnce([]);\n\t\t\tconst promises: unknown[] = [];\n\t\t\tviewState.onBeforeStateApplied(promises);\n\t\t\texpect(promises.length).toBe(1);\n\t\t\texpect(filterBar.initialized).toBeCalled();\n\t\t});\n\n\t\ttest(\"only tables\", () => {\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(undefined);\n\t\t\tapp.controller.mock._getControls.mockReturnValueOnce([table, table]);\n\t\t\tconst promises: unknown[] = [];\n\t\t\tviewState.onBeforeStateApplied(promises);\n\t\t\texpect(promises.length).toBe(2);\n\t\t\texpect(table.initialized).toBeCalledTimes(2);\n\t\t});\n\n\t\ttest(\"nothing to be initialized\", () => {\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(undefined);\n\t\t\tapp.controller.mock._getControls.mockReturnValueOnce([]);\n\t\t\tconst promises: unknown[] = [];\n\t\t\tviewState.onBeforeStateApplied(promises);\n\t\t\texpect(promises.length).toBe(0);\n\t\t});\n\t});\n\n\tdescribe(\"onAfterStateApplied\", () => {\n\t\tconst filterBar = mockFilterBar();\n\n\t\tbeforeEach(() => {\n\t\t\tfilterBar.mock.setSuspendSelection.mockReset();\n\t\t\tapp.controller.mock._isFilterBarHidden.mockReset();\n\t\t});\n\n\t\ttest(\"no FilterBar\", () => {\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(undefined);\n\t\t\tapp.controller.mock._isFilterBarHidden.mockReturnValueOnce(false);\n\t\t\tviewState.onAfterStateApplied();\n\t\t\texpect(filterBar.mock.setSuspendSelection).not.toBeCalled();\n\t\t});\n\n\t\ttest(\"visible FilterBar\", () => {\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);\n\t\t\tviewState.onAfterStateApplied();\n\t\t\texpect(filterBar.mock.setSuspendSelection).toBeCalled();\n\t\t});\n\n\t\ttest(\"hidden FilterBar\", () => {\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValue(undefined);\n\t\t\tapp.controller.mock._isFilterBarHidden.mockReturnValue(true);\n\t\t\tconst mockContext = { setProperty: jest.fn() };\n\t\t\tapp.view.mock.getBindingContext.mockReturnValue(mockContext);\n\n\t\t\tapp.controller.mock._isMultiMode.mockReturnValueOnce(false);\n\t\t\tviewState.onAfterStateApplied();\n\t\t\texpect(mockContext.setProperty).toBeCalledWith(\"hasPendingFilters\", false);\n\n\t\t\tapp.controller.mock._isMultiMode.mockReturnValueOnce(true);\n\t\t\tapp.controller.mock._getControls.mockReturnValueOnce([]);\n\t\t\tapp.controller.mock._getCurrentControl.mockReturnValueOnce({ getId: () => \"\" });\n\t\t\tviewState.onAfterStateApplied();\n\t\t\texpect(mockContext.setProperty).toBeCalledWith(\"hasPendingFilters\", false);\n\t\t\texpect(app.controller._setCountsOutDated).toBeCalled();\n\t\t});\n\t});\n\n\tdescribe(\"adaptBindingRefreshControls\", () => {\n\t\ttest(\"controls are added\", () => {\n\t\t\tjest.spyOn(KeepAliveHelper, \"getControlsForRefresh\").mockImplementation(() => [mock(Control)]);\n\t\t\tconst controls: Control[] = [];\n\t\t\tviewState.adaptBindingRefreshControls(controls);\n\t\t\texpect(controls.length).toBe(1);\n\t\t});\n\t});\n\n\tdescribe(\"adaptStateControls\", () => {\n\t\tconst vm = mock(VariantManagement);\n\t\tconst filterBar = mockFilterBar();\n\n\t\tbeforeAll(() => {\n\t\t\tapp.view.mock.byId.mockImplementation((id: string) => {\n\t\t\t\tconst control = mock(Control);\n\t\t\t\tcontrol.mock.getId.mockReturnValue(id);\n\t\t\t\treturn control;\n\t\t\t});\n\t\t});\n\n\t\ttest(\"only the page\", () => {\n\t\t\tapp.view.mock.getViewData.mockReturnValue({ variantManagement: \"None\" });\n\t\t\tapp.controller.mock._getControls.mockReturnValueOnce([]);\n\n\t\t\tconst controls: Control[] = [];\n\t\t\tviewState.adaptStateControls(controls);\n\t\t\texpect(controls.length).toBe(1);\n\t\t\texpect(controls[0].getId()).toBe(\"fe::ListReport\");\n\t\t});\n\n\t\ttest(\"with filter bar\", () => {\n\t\t\tapp.view.mock.getViewData.mockReturnValue({ variantManagement: \"None\" });\n\t\t\tapp.controller.mock._getControls.mockReturnValueOnce([]);\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);\n\n\t\t\tconst controls: Control[] = [];\n\t\t\tviewState.adaptStateControls(controls);\n\t\t\texpect(controls.length).toBe(2);\n\t\t\texpect(controls[0]).toBe(filterBar);\n\t\t\texpect(controls[1].getId()).toBe(\"fe::ListReport\");\n\t\t});\n\n\t\ttest(\"isMultiNode & control variant management\", () => {\n\t\t\t// multinode\n\t\t\tapp.controller.mock._isMultiMode.mockReturnValue(true);\n\t\t\tconst mnControl = mock(Control);\n\t\t\tapp.controller.mock._getMultiModeControl.mockReturnValueOnce(mnControl);\n\n\t\t\t// tables\n\t\t\tapp.controller.mock._getControls.mockReturnValueOnce([]);\n\n\t\t\t// control variant management\n\t\t\tapp.view.mock.getViewData.mockReturnValue({ variantManagement: \"Control\" });\n\t\t\tapp.view.mock.getContent.mockReturnValue([{ data: (id: string) => id }]);\n\n\t\t\tconst controls: Control[] = [];\n\t\t\tviewState.adaptStateControls(controls);\n\t\t\texpect(controls.length).toBe(3);\n\t\t\t// FilterBar/Page VM must be listed before IconTabBar (MultiModeControl)\n\t\t\texpect(controls[0].getId()).toBe(\"filterBarVariantId\");\n\t\t\texpect(controls[1]).toBe(mnControl);\n\t\t});\n\n\t\ttest.skip(\"multiple tables\", () => {\n\t\t\t// TODO\n\t\t});\n\t});\n\n\tdescribe(\"retrieveAdditionalStates\", () => {});\n\n\tdescribe(\"_applySelectionVariant\", () => {\n\t\ttest(\"no filter bar\", () => {\n\t\t\tconst result = viewState._applySelectionVariant(app.view, { selectionVariant: {} }, true);\n\t\t\texpect(result).toBeDefined();\n\t\t});\n\t});\n\n\tdescribe(\"applyAdditionalStates\", () => {\n\t\tconst filterBar = mockFilterBar();\n\n\t\ttest(\"data is not loaded\", () => {\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);\n\t\t\tviewState.applyAdditionalStates({\n\t\t\t\tdataLoaded: false\n\t\t\t});\n\t\t\texpect(filterBar._bSearchTriggered).toBe(false);\n\t\t});\n\n\t\ttest(\"data is loaded, with filterbar\", () => {\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);\n\t\t\tviewState.applyAdditionalStates({\n\t\t\t\tdataLoaded: true\n\t\t\t});\n\t\t\texpect(filterBar.triggerSearch).toBeCalled();\n\t\t\texpect(viewState._bSearchTriggered).toBe(true);\n\t\t});\n\t});\n\n\tdescribe(\"applyNavigationParameters\", () => {\n\t\tconst filterBar = mockFilterBar();\n\n\t\ttest(\"should add a promise to the promises parameter - without component data\", () => {\n\t\t\tapp.controller.mock.getAppComponent.mockReturnValueOnce({\n\t\t\t\tgetComponentData: () => ({})\n\t\t\t});\n\t\t\tjest.spyOn(viewState, \"handleVariantIdPassedViaURLParams\").mockImplementation(() => Promise.resolve([]));\n\t\t\tconst promises: unknown[] = [];\n\t\t\tviewState.applyNavigationParameters({}, promises);\n\t\t\texpect(app.controller.mock.getAppComponent).toBeCalled();\n\t\t\texpect(viewState.handleVariantIdPassedViaURLParams).toBeCalled();\n\t\t\texpect(promises.length).toBe(1);\n\t\t});\n\t\ttest(\"should add a promise to the promises parameter - with component data\", () => {\n\t\t\tapp.controller.mock.getAppComponent.mockReturnValueOnce({\n\t\t\t\tgetComponentData: () => ({})\n\t\t\t});\n\t\t\tjest.spyOn(viewState, \"handleVariantIdPassedViaURLParams\").mockImplementation(() => Promise.resolve([]));\n\t\t\tconst vm = mock(VariantManagement);\n\t\t\tjest.spyOn(viewState, \"_getFilterBarVM\").mockReturnValueOnce(vm);\n\t\t\tapp.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);\n\t\t\tapp.view.mock.getViewData.mockReturnValue({ initialLoad: \"Enabled\" });\n\t\t\tapp.controller.mock._shouldAutoTriggerSearch.mockReturnValueOnce(true);\n\n\t\t\tapp.view.mock.byId.mockReturnValue({\n\t\t\t\tsetHeaderExpanded: () => jest.fn()\n\t\t\t});\n\n\t\t\tfilterBar.mock.triggerSearch.mockImplementation(() => true);\n\n\t\t\tconst promises: unknown[] = [];\n\t\t\tviewState.applyNavigationParameters({}, promises);\n\t\t\texpect(promises.length).toBe(1);\n\t\t});\n\n\t\tafterEach(() => {\n\t\t\tjest.restoreAllMocks();\n\t\t});\n\t});\n\n\tdescribe(\"handleVariantIdPassedViaURLParams\", () => {\n\t\tconst variantId = \"testId\";\n\t\tconst vm = mock(VariantManagement);\n\n\t\tbeforeAll(() => {\n\t\t\tapp.view.mock.byId.mockReturnValue(vm);\n\t\t\tapp.view.mock.getContent.mockReturnValue([\n\t\t\t\t{\n\t\t\t\t\tdata(id: string) {\n\t\t\t\t\t\treturn id;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t]);\n\t\t\tjest.spyOn(ControlVariantApplyAPI, \"activateVariant\").mockResolvedValue(true);\n\t\t\tvm.mock.getVariants.mockReturnValue([{ key: variantId }]);\n\t\t});\n\n\t\ttest(\"Page variant\", async () => {\n\t\t\tapp.view.mock.getViewData.mockReturnValue({ variantManagement: \"Page\" });\n\t\t\tconst results = await viewState.handleVariantIdPassedViaURLParams({ \"sap-ui-fe-variant-id\": [variantId] });\n\t\t\texpect(results).toBeDefined();\n\t\t\texpect(results[0]).toBe(true);\n\t\t});\n\n\t\ttest(\"FilterBar variant\", async () => {\n\t\t\tapp.view.mock.getViewData.mockReturnValue({ variantManagement: \"Control\" });\n\t\t\tconst results = await viewState.handleVariantIdPassedViaURLParams({ \"sap-ui-fe-filterbar-variant-id\": [variantId] });\n\t\t\texpect(results).toBeDefined();\n\t\t\texpect(results[0]).toBe(true);\n\t\t});\n\n\t\ttest(\"Table variant\", async () => {\n\t\t\tapp.view.mock.getViewData.mockReturnValue({ variantManagement: \"Control\" });\n\t\t\tconst table = mock(Table);\n\t\t\ttable.mock.getVariant.mockReturnValue(vm);\n\t\t\tapp.controller.mock._getControls.mockReturnValue([table]);\n\t\t\tconst results = await viewState.handleVariantIdPassedViaURLParams({ \"sap-ui-fe-table-variant-id\": [variantId] });\n\t\t\texpect(results).toBeDefined();\n\t\t\texpect(results[0]).toBe(undefined);\n\t\t});\n\t});\n\n\tdescribe(\"private\", () => {\n\t\tdescribe(\"_fnApplyConditions\", () => {\n\t\t\tbeforeAll(() => {\n\t\t\t\tjest.spyOn(CommonUtils, \"getFilterRestrictionsByPath\").mockImplementation(() => {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tFilterAllowedExpressions: {\n\t\t\t\t\t\t\tSalesOrderDate: [\"SingleRange\"],\n\t\t\t\t\t\t\tSoldToParty: [\"SingleValue\"]\n\t\t\t\t\t\t},\n\t\t\t\t\t\tNonFilterableProperties: [\"OverallSDProcessStatus\"],\n\t\t\t\t\t\tRequiredProperties: []\n\t\t\t\t\t};\n\t\t\t\t});\n\t\t\t\tjest.spyOn(ModelHelper, \"getEntitySetPath\").mockImplementation(() => \"/SalesOrderManage\");\n\t\t\t\tjest.spyOn(FilterUtils, \"getConvertedFilterFields\").mockImplementation(() => {\n\t\t\t\t\treturn [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tannotationPath: \"/SalesOrderManage/SalesOrder\",\n\t\t\t\t\t\t\tavailability: \"Default\",\n\t\t\t\t\t\t\tcaseSensitive: true,\n\t\t\t\t\t\t\tconditionPath: \"SalesOrder\",\n\t\t\t\t\t\t\tgroup: \"\",\n\t\t\t\t\t\t\tgroupLabel: \"\",\n\t\t\t\t\t\t\tisParameter: false,\n\t\t\t\t\t\t\tkey: \"SalesOrder\",\n\t\t\t\t\t\t\tlabel: \"Sales Order No.\"\n\t\t\t\t\t\t},\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tannotationPath: \"/SalesOrderManage/SoldToParty\",\n\t\t\t\t\t\t\tavailability: \"Default\",\n\t\t\t\t\t\t\tcaseSensitive: true,\n\t\t\t\t\t\t\tconditionPath: \"SoldToParty\",\n\t\t\t\t\t\t\tgroup: \"\",\n\t\t\t\t\t\t\tgroupLabel: \"\",\n\t\t\t\t\t\t\tisParameter: false,\n\t\t\t\t\t\t\tkey: \"SoldToParty\",\n\t\t\t\t\t\t\tlabel: \"Sold-To Party\"\n\t\t\t\t\t\t},\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tannotationPath: \"/SalesOrderManage/OverallSDProcessStatus\",\n\t\t\t\t\t\t\tavailability: \"Default\",\n\t\t\t\t\t\t\tcaseSensitive: true,\n\t\t\t\t\t\t\tconditionPath: \"OverallSDProcessStatus\",\n\t\t\t\t\t\t\tgroup: \"\",\n\t\t\t\t\t\t\tgroupLabel: \"\",\n\t\t\t\t\t\t\tisParameter: false,\n\t\t\t\t\t\t\tkey: \"OverallSDProcessStatus\",\n\t\t\t\t\t\t\tlabel: \"Overall Status\"\n\t\t\t\t\t\t},\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tannotationPath: \"/SalesOrderManage/_SalesGroup_SalesGroup\",\n\t\t\t\t\t\t\tavailability: \"Adaptation\",\n\t\t\t\t\t\t\tcaseSensitive: true,\n\t\t\t\t\t\t\tconditionPath: \"_SalesGroup_SalesGroup\",\n\t\t\t\t\t\t\tgroup: \"SalesOrderManage\",\n\t\t\t\t\t\t\tgroupLabel: \"Manage Sales Order\",\n\t\t\t\t\t\t\tkey: \"_SalesGroup_SalesGroup\",\n\t\t\t\t\t\t\tlabel: \"_SalesGroup_SalesGroup\"\n\t\t\t\t\t\t}\n\t\t\t\t\t];\n\t\t\t\t});\n\t\t\t\tjest.spyOn(PropertyFormatters, \"hasValueHelp\").mockImplementation(() => true);\n\t\t\t\tjest.spyOn(DelegateUtil, \"getCustomData\").mockReturnValue(\"/SalesOrderManage/\");\n\t\t\t\tjest.spyOn(StateUtil, \"applyExternalState\").mockResolvedValue(true);\n\t\t\t});\n\n\t\t\tafterAll(() => {\n\t\t\t\tjest.restoreAllMocks();\n\t\t\t});\n\n\t\t\tit(\"check if conditions are applied correctly\", async () => {\n\t\t\t\tconst order = {\n\t\t\t\t\toperator: \"EQ\",\n\t\t\t\t\tvalidated: \"Validated\",\n\t\t\t\t\tvalues: [\"6437\"]\n\t\t\t\t};\n\t\t\t\tconst condition = {\n\t\t\t\t\tSalesOrder: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t...order,\n\t\t\t\t\t\t\tisEmpty: \"null\"\n\t\t\t\t\t\t}\n\t\t\t\t\t],\n\t\t\t\t\tSoldToParty: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\toperator: \"Empty\",\n\t\t\t\t\t\t\tvalidated: \"Validated\",\n\t\t\t\t\t\t\tvalues: [\"69406910\"]\n\t\t\t\t\t\t}\n\t\t\t\t\t],\n\t\t\t\t\tOverallSDProcessStatus: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\toperator: \"EQ\",\n\t\t\t\t\t\t\tisEmpty: \"null\",\n\t\t\t\t\t\t\tvalidated: \"Validated\",\n\t\t\t\t\t\t\tvalues: [\"A\"]\n\t\t\t\t\t\t}\n\t\t\t\t\t]\n\t\t\t\t};\n\n\t\t\t\tconst state = {\n\t\t\t\t\tfilter: {\n\t\t\t\t\t\t_SalesGroup_SalesGroup: [],\n\t\t\t\t\t\tSalesOrder: [order],\n\t\t\t\t\t\tSoldToParty: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\toperator: \"EQ\",\n\t\t\t\t\t\t\t\tvalidated: \"Validated\",\n\t\t\t\t\t\t\t\tvalues: [\"\"]\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t]\n\t\t\t\t\t},\n\t\t\t\t\titems: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tname: \"SalesOrder\"\n\t\t\t\t\t\t},\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tname: \"SoldToParty\"\n\t\t\t\t\t\t}\n\t\t\t\t\t]\n\t\t\t\t};\n\t\t\t\tconst filterBar = mockFilterBar();\n\t\t\t\tfilterBar.mock.initialized.mockResolvedValue(true);\n\t\t\t\tfilterBar.mock.getModel.mockReturnValue(app.model);\n\n\t\t\t\tconst metaModel = app.model.mock.getMetaModel();\n\t\t\t\tmetaModel.mock.createBindingContext.mockReturnValue({ getObject: jest.fn() });\n\n\t\t\t\tawait viewState._fnApplyConditions(filterBar, condition);\n\t\t\t\texpect(StateUtil.applyExternalState).toHaveBeenCalledWith(filterBar, state);\n\t\t\t});\n\t\t});\n\t});\n});\n"]}