@sap/open.fe 1.99.0 → 1.100.0

package/packages/sap.fe.core/test/sap/fe/core/jest/controllerextensions/InternalRouting.spec.js

@@ -1,182 +1,776 @@
-sap.ui.define(["sap/fe/core/controllerextensions/InternalRouting"], function(InternalRouting) {
-	"use strict";
-	describe("InternalRouting ControllerExtension", function() {
-		describe("createFilterFromSemanticPath", () => {
-			let oInternalRouting, sSemanticPath, aSemanticKeys;
-			let oMetaModelWithToLowerFilterFunction, oMetaModelWithoutToLowerFilterFunction, oMetaModelWithNoFilterFunction;
-			beforeAll(() => {
-				oInternalRouting = new InternalRouting();
-				oMetaModelWithToLowerFilterFunction = {
-					getObject: function() {
-						return ["contains", "endswith", "startswith", "length", "indexof", "substring", "tolower"];
-					}
-				};
-				oMetaModelWithoutToLowerFilterFunction = {
-					getObject: function() {
-						return ["contains", "endswith", "startswith", "length", "indexof", "substring"];
-					}
-				};
-				oMetaModelWithNoFilterFunction = {
-					getObject: function() {
-						return undefined;
-					}
-				};
-			});
-
-			describe("Filter created for single semantic key", () => {
-				beforeAll(() => {
-					sSemanticPath = "Products('NEW-1812')";
-					aSemanticKeys = [
-						{
-							"$PropertyPath": "identifier"
-						}
-					];
-				});
-				it(
-					"Service supports 'tolower' filter function",
-					{
-						"references": [
-							{
-								"type": "JIRA",
-								"ID": "FIORITECHP1-19019"
-							}
-						]
-					},
-					async () => {
-						const actual = oInternalRouting._createFilterFromSemanticPath(
-							sSemanticPath,
-							aSemanticKeys,
-							oMetaModelWithToLowerFilterFunction
-						);
-						expect(actual.aFilters.length).toEqual(2);
-						expect(actual.aFilters[0].bCaseSensitive).toEqual(false);
-						expect(actual.aFilters[1].bCaseSensitive).toEqual(undefined);
-					}
-				);
-				it(
-					"Service does not support 'tolower' filter function",
-					{
-						"references": [
-							{
-								"type": "JIRA",
-								"ID": "FIORITECHP1-19019"
-							}
-						]
-					},
-					async () => {
-						const actual = oInternalRouting._createFilterFromSemanticPath(
-							sSemanticPath,
-							aSemanticKeys,
-							oMetaModelWithoutToLowerFilterFunction
-						);
-						expect(actual.aFilters.length).toEqual(2);
-						expect(actual.aFilters[0].bCaseSensitive).toEqual(true);
-						expect(actual.aFilters[1].bCaseSensitive).toEqual(undefined);
-					}
-				);
-				it(
-					"Service defines no filter function",
-					{
-						"references": [
-							{
-								"type": "JIRA",
-								"ID": "FIORITECHP1-19019"
-							}
-						]
-					},
-					async () => {
-						const actual = oInternalRouting._createFilterFromSemanticPath(
-							sSemanticPath,
-							aSemanticKeys,
-							oMetaModelWithNoFilterFunction
-						);
-						expect(actual.aFilters.length).toEqual(2);
-						expect(actual.aFilters[0].bCaseSensitive).toEqual(true);
-						expect(actual.aFilters[1].bCaseSensitive).toEqual(undefined);
-					}
-				);
-			});
-
-			describe("Filters created for multiple semantic keys", () => {
-				beforeAll(() => {
-					sSemanticPath = "Products(identifier='NEW-1812',owner='Mueller AG')";
-					aSemanticKeys = [
-						{
-							"$PropertyPath": "identifier"
-						},
-						{
-							"$PropertyPath": "owner"
-						}
-					];
-				});
-
-				it(
-					"Service supports 'tolower' filter function",
-					{
-						"references": [
-							{
-								"type": "JIRA",
-								"ID": "FIORITECHP1-19019"
-							}
-						]
-					},
-					async () => {
-						const actual = oInternalRouting._createFilterFromSemanticPath(
-							sSemanticPath,
-							aSemanticKeys,
-							oMetaModelWithToLowerFilterFunction
-						);
-						expect(actual.aFilters.length).toEqual(3);
-						expect(actual.aFilters[0].bCaseSensitive).toEqual(false);
-						expect(actual.aFilters[1].bCaseSensitive).toEqual(false);
-						expect(actual.aFilters[2].bCaseSensitive).toEqual(undefined);
-					}
-				);
-				it(
-					"Service does not support 'tolower' filter function",
-					{
-						"references": [
-							{
-								"type": "JIRA",
-								"ID": "FIORITECHP1-19019"
-							}
-						]
-					},
-					async () => {
-						const actual = oInternalRouting._createFilterFromSemanticPath(
-							sSemanticPath,
-							aSemanticKeys,
-							oMetaModelWithoutToLowerFilterFunction
-						);
-						expect(actual.aFilters.length).toEqual(3);
-						expect(actual.aFilters[0].bCaseSensitive).toEqual(true);
-						expect(actual.aFilters[1].bCaseSensitive).toEqual(true);
-						expect(actual.aFilters[2].bCaseSensitive).toEqual(undefined);
-					}
-				);
-				it(
-					"Service defines no filter function",
-					{
-						"references": [
-							{
-								"type": "JIRA",
-								"ID": "FIORITECHP1-19019"
-							}
-						]
-					},
-					async () => {
-						const actual = oInternalRouting._createFilterFromSemanticPath(
-							sSemanticPath,
-							aSemanticKeys,
-							oMetaModelWithNoFilterFunction
-						);
-						expect(actual.aFilters.length).toEqual(3);
-						expect(actual.aFilters[0].bCaseSensitive).toEqual(true);
-						expect(actual.aFilters[1].bCaseSensitive).toEqual(true);
-						expect(actual.aFilters[2].bCaseSensitive).toEqual(undefined);
-					}
-				);
-			});
-		});
-	});
-});
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/BusyLocker", "sap/fe/test/UI5MockHelper", "sap/fe/core/controllerextensions/InternalRouting"], function (BusyLocker, UI5MockHelper, InternalRouting) {
+  "use strict";
+
+  var MockModel = UI5MockHelper.MockModel;
+  var MockMetaModel = UI5MockHelper.MockMetaModel;
+  var MockListBinding = UI5MockHelper.MockListBinding;
+  var MockContextBinding = UI5MockHelper.MockContextBinding;
+
+  function _catch(body, recover) {
+    try {
+      var result = body();
+    } catch (e) {
+      return recover(e);
+    }
+
+    if (result && result.then) {
+      return result.then(void 0, recover);
+    }
+
+    return result;
+  }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  // @ts-ignore
+  var TestableInternalRouting = /*#__PURE__*/function (_InternalRouting) {
+    _inherits(TestableInternalRouting, _InternalRouting);
+
+    function TestableInternalRouting() {
+      var _this;
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _InternalRouting.call.apply(_InternalRouting, [this].concat(args)) || this;
+      _this.onBeforeBinding = jest.fn();
+      _this.onAfterBinding = jest.fn();
+      _this._setBindingContext = jest.fn();
+      _this._getBindingContext = jest.fn(function () {
+        return null;
+      });
+      _this._oPageComponent = {
+        getEntitySet: function () {
+          return "com.c_salesordermanage_sd.SalesOrder";
+        }
+      };
+      _this._oRoutingService = {};
+      _this._oRouter = {};
+      return _this;
+    }
+
+    return TestableInternalRouting;
+  }(InternalRouting);
+
+  var oMetaModelDraft = new MockMetaModel({
+    "/SalesOrder@com.sap.vocabularies.Common.v1.DraftRoot": true,
+    "/com.c_salesordermanage_sd.SalesOrder@com.sap.vocabularies.Common.v1.DraftRoot": true,
+    "/com.c_salesordermanage_sd.SalesOrder/@com.sap.vocabularies.Common.v1.Messages/$Path": "SAP_Messages"
+  });
+  var oMetaModelDraftSemanticKey1 = new MockMetaModel({
+    "/SalesOrder@com.sap.vocabularies.Common.v1.DraftRoot": true,
+    "/SalesOrder/@com.sap.vocabularies.Common.v1.SemanticKey": [{
+      $PropertyPath: "sem1"
+    }]
+  });
+  var oMetaModelDraftSemanticKey2 = new MockMetaModel({
+    "/SalesOrder@com.sap.vocabularies.Common.v1.DraftRoot": true,
+    "/SalesOrder/@com.sap.vocabularies.Common.v1.SemanticKey": [{
+      $PropertyPath: "sem1"
+    }, {
+      $PropertyPath: "sem2"
+    }]
+  });
+  var oMetaModelSticky = new MockMetaModel({});
+  describe("InternalRouting = #resolveSemanticPath", function () {
+    it("resolves path with 1 semantic key (no semantic mapping)", function () {
+      var mockModel = MockModel.modelFromListBinding(new MockListBinding([{
+        $path: "/SalesOrder(key1=123,key2=456)"
+      }]));
+      mockModel.setMetaModel(oMetaModelDraftSemanticKey1);
+      var routingExtension = new TestableInternalRouting();
+      var setSemanticMapping = jest.fn();
+      routingExtension._oRoutingService.getLastSemanticMapping = jest.fn(function () {
+        return undefined;
+      });
+      routingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;
+      routingExtension._oRouter.getHashChanger = jest.fn(function () {
+        return {
+          getHash: jest.fn(function () {
+            return "/SalesOrder(123)";
+          })
+        };
+      });
+      return routingExtension._resolveSemanticPath("/SalesOrder(123)", mockModel).then(function (sPath) {
+        // The semantic path is properly resolved
+        expect(sPath).toBe("/SalesOrder(key1=123,key2=456)"); // The semantic mapping is stored on the routing service
+
+        expect(setSemanticMapping.mock.calls.length).toBe(1);
+        expect(setSemanticMapping.mock.calls[0][0]).toStrictEqual({
+          technicalPath: "/SalesOrder(key1=123,key2=456)",
+          semanticPath: "/SalesOrder(123)"
+        }); // A query has been sent to resolve the semantic path
+
+        expect(mockModel.bindList.mock.calls.length).toBe(1);
+      });
+    });
+    it("resolves path with 2 semantic keys (no semantic mapping)", function () {
+      var mockModel = MockModel.modelFromListBinding(new MockListBinding([{
+        $path: "/SalesOrder(key1=123,key2=456)"
+      }]));
+      mockModel.setMetaModel(oMetaModelDraftSemanticKey2);
+      var routingExtension = new TestableInternalRouting();
+      var setSemanticMapping = jest.fn();
+      routingExtension._oRoutingService.getLastSemanticMapping = jest.fn(function () {
+        return undefined;
+      });
+      routingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;
+      routingExtension._oRouter.getHashChanger = jest.fn(function () {
+        return {
+          getHash: jest.fn(function () {
+            return "/SalesOrder(sem1=ABC,sem2=DEF)";
+          })
+        };
+      });
+      return routingExtension._resolveSemanticPath("/SalesOrder(sem1=ABC,sem2=DEF)", mockModel).then(function (sPath) {
+        // The semantic path is properly resolved
+        expect(sPath).toBe("/SalesOrder(key1=123,key2=456)"); // The semantic mapping is stored on the routing service
+
+        expect(setSemanticMapping.mock.calls.length).toBe(1);
+        expect(setSemanticMapping.mock.calls[0][0]).toStrictEqual({
+          technicalPath: "/SalesOrder(key1=123,key2=456)",
+          semanticPath: "/SalesOrder(sem1=ABC,sem2=DEF)"
+        }); // A query has been sent to resolve the semantic path
+
+        expect(mockModel.bindList.mock.calls.length).toBe(1);
+      });
+    });
+    it("resolves path with 1 semantic key (with semantic mapping)", function () {
+      var mockModel = MockModel.modelFromListBinding(new MockListBinding([{
+        $path: "/SalesOrder(key1=123,key2=456)"
+      }]));
+      mockModel.setMetaModel(oMetaModelDraftSemanticKey1);
+      var routingExtension = new TestableInternalRouting();
+      var setSemanticMapping = jest.fn();
+      routingExtension._oRoutingService.getLastSemanticMapping = jest.fn(function () {
+        return {
+          technicalPath: "/SalesOrder(key1=123,key2=456)",
+          semanticPath: "/SalesOrder(123)"
+        };
+      });
+      routingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;
+      routingExtension._oRouter.getHashChanger = jest.fn(function () {
+        return {
+          getHash: jest.fn(function () {
+            return "/SalesOrder(123)";
+          })
+        };
+      });
+      return routingExtension._resolveSemanticPath("/SalesOrder(123)", mockModel).then(function (sPath) {
+        // The semantic path is properly resolved
+        expect(sPath).toBe("/SalesOrder(key1=123,key2=456)"); // The semantic mapping doesn't need to be stored on the routing service
+
+        expect(setSemanticMapping.mock.calls.length).toBe(0); // No query has been sent to resolve the semantic path
+
+        expect(mockModel.bindList.mock.calls.length).toBe(0);
+      });
+    });
+    it("resolves path with 1 semantic key (wrong semantic mapping)", function () {
+      var mockModel = MockModel.modelFromListBinding(new MockListBinding([{
+        $path: "/SalesOrder(key1=123,key2=456)"
+      }]));
+      mockModel.setMetaModel(oMetaModelDraftSemanticKey1);
+      var routingExtension = new TestableInternalRouting();
+      var setSemanticMapping = jest.fn();
+      routingExtension._oRoutingService.getLastSemanticMapping = jest.fn(function () {
+        return {
+          technicalPath: "/SalesOrder(key1=123,key2=456)",
+          semanticPath: "/SalesOrder(ABC)"
+        };
+      });
+      routingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;
+      routingExtension._oRouter.getHashChanger = jest.fn(function () {
+        return {
+          getHash: jest.fn(function () {
+            return "/SalesOrder(123)";
+          })
+        };
+      });
+      return routingExtension._resolveSemanticPath("/SalesOrder(123)", mockModel).then(function (sPath) {
+        // The semantic path is properly resolved
+        expect(sPath).toBe("/SalesOrder(key1=123,key2=456)"); // The semantic mapping is stored on the routing service
+
+        expect(setSemanticMapping.mock.calls.length).toBe(1);
+        expect(setSemanticMapping.mock.calls[0][0]).toStrictEqual({
+          technicalPath: "/SalesOrder(key1=123,key2=456)",
+          semanticPath: "/SalesOrder(123)"
+        }); // A query has been sent to resolve the semantic path
+
+        expect(mockModel.bindList.mock.calls.length).toBe(1);
+      });
+    });
+    it("doesn't resolve path if entity is not draft", function () {
+      var mockModel = MockModel.modelFromListBinding(new MockListBinding([{
+        $path: "/SalesOrder(key1=123,key2=456)"
+      }]));
+      mockModel.setMetaModel(oMetaModelSticky);
+      var routingExtension = new TestableInternalRouting();
+      var setSemanticMapping = jest.fn();
+      routingExtension._oRoutingService.getLastSemanticMapping = jest.fn(function () {
+        return {
+          technicalPath: "/SalesOrder(key1=123,key2=456)",
+          semanticPath: "/SalesOrder(123)"
+        };
+      });
+      routingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;
+      routingExtension._oRouter.getHashChanger = jest.fn(function () {
+        return {
+          getHash: jest.fn(function () {
+            return "/SalesOrder(123)";
+          })
+        };
+      });
+      return routingExtension._resolveSemanticPath("/SalesOrder(123)", mockModel).then(function (sPath) {
+        // The semantic path is properly resolved
+        expect(sPath).toBe("/SalesOrder(123)"); // No semantic mapping stored on the routing service
+
+        expect(setSemanticMapping.mock.calls.length).toBe(0); // No query has been sent to resolve the semantic path
+
+        expect(mockModel.bindList.mock.calls.length).toBe(0);
+      });
+    });
+    it("doesn't resolve path if entity doesn't have semantic keys", function () {
+      var mockModel = MockModel.modelFromListBinding(new MockListBinding([{
+        $path: "/SalesOrder(key1=123,key2=456)"
+      }]));
+      mockModel.setMetaModel(oMetaModelDraft);
+      var routingExtension = new TestableInternalRouting();
+      var setSemanticMapping = jest.fn();
+      routingExtension._oRoutingService.getLastSemanticMapping = jest.fn(function () {
+        return {
+          technicalPath: "/SalesOrder(key1=123,key2=456)",
+          semanticPath: "/SalesOrder(123)"
+        };
+      });
+      routingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;
+      routingExtension._oRouter.getHashChanger = jest.fn(function () {
+        return {
+          getHash: jest.fn(function () {
+            return "/SalesOrder(123)";
+          })
+        };
+      });
+      return routingExtension._resolveSemanticPath("/SalesOrder(123)", mockModel).then(function (sPath) {
+        // The semantic path is properly resolved
+        expect(sPath).toBe("/SalesOrder(123)"); // No semantic mapping stored on the routing service
+
+        expect(setSemanticMapping.mock.calls.length).toBe(0); // No query has been sent to resolve the semantic path
+
+        expect(mockModel.bindList.mock.calls.length).toBe(0);
+      });
+    });
+    it("doesn't resolve path on sub-object page", function () {
+      var mockModel = MockModel.modelFromListBinding(new MockListBinding([{
+        $path: "/SalesOrder(key1=123,key2=456)"
+      }]));
+      mockModel.setMetaModel(oMetaModelDraftSemanticKey1);
+      var routingExtension = new TestableInternalRouting();
+      var setSemanticMapping = jest.fn();
+      routingExtension._oRoutingService.getLastSemanticMapping = jest.fn(function () {
+        return undefined;
+      });
+      routingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;
+      routingExtension._oRouter.getHashChanger = jest.fn(function () {
+        return {
+          getHash: jest.fn(function () {
+            return "/SalesOrder(123)/_Item(456)";
+          })
+        };
+      });
+      return routingExtension._resolveSemanticPath("/SalesOrder(123)/_Item(456)", mockModel).then(function (sPath) {
+        // The semantic path is properly resolved
+        expect(sPath).toBe("/SalesOrder(123)/_Item(456)"); // No semantic mapping stored on the routing service
+
+        expect(setSemanticMapping.mock.calls.length).toBe(0); // No query has been sent to resolve the semantic path
+
+        expect(mockModel.bindList.mock.calls.length).toBe(0);
+      });
+    });
+    it("doesn't resolve path on object page if the app if FCL with 3 columns open", function () {
+      var mockModel = MockModel.modelFromListBinding(new MockListBinding([{
+        $path: "/SalesOrder(key1=123,key2=456)"
+      }]));
+      mockModel.setMetaModel(oMetaModelDraftSemanticKey1);
+      var routingExtension = new TestableInternalRouting();
+      var setSemanticMapping = jest.fn();
+      routingExtension._oRoutingService.getLastSemanticMapping = jest.fn(function () {
+        return undefined;
+      });
+      routingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;
+      routingExtension._oRouter.getHashChanger = jest.fn(function () {
+        return {
+          getHash: jest.fn(function () {
+            return "/SalesOrder(123)/_Item(456)";
+          })
+        };
+      });
+      return routingExtension._resolveSemanticPath("/SalesOrder(123)", mockModel).then(function (sPath) {
+        // The semantic path is properly resolved
+        expect(sPath).toBe("/SalesOrder(123)"); // No semantic mapping stored on the routing service
+
+        expect(setSemanticMapping.mock.calls.length).toBe(0); // No query has been sent to resolve the semantic path
+
+        expect(mockModel.bindList.mock.calls.length).toBe(0);
+      });
+    });
+  });
+  describe("InternalRouting - #bindPage", function () {
+    var routingExtension;
+    beforeEach(function () {
+      try {
+        routingExtension = new TestableInternalRouting(); // We don't test semantic bookmarking in this set of tests, so we can mock this method
+
+        routingExtension._resolveSemanticPath = jest.fn(function () {
+          return Promise.resolve("/SalesOrder(123)");
+        });
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("calls onBefore and onAfterBinding will called with an empty path", function () {
+      return routingExtension._bindPage("", null, {}).then(function () {
+        expect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBeNull();
+        expect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onAfterBinding.mock.calls[0][0]).toBeNull();
+        expect(routingExtension._setBindingContext.mock.calls.length).toBe(0);
+      });
+    });
+    it("creates a new context to bind the page when passed a target path with no context to use", function () {
+      var mockContextBinding = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockModel = MockModel.modelFromContextBinding(mockContextBinding);
+      mockModel.setMetaModel(oMetaModelDraft);
+      return routingExtension._bindPage("/SalesOrder(123)", mockModel, {}).then(function () {
+        // The context has been created
+        expect(mockModel.bindContext.mock.calls.length).toBe(1);
+        expect(mockModel.bindContext.mock.calls[0][0]).toBe("/SalesOrder(123)");
+        expect(mockModel.bindContext.mock.calls[0][2]).toStrictEqual({
+          $select: "SAP_Messages,HasActiveEntity,HasDraftEntity,IsActiveEntity",
+          $$patchWithoutSideEffects: true,
+          $$groupId: "$auto.Heroes",
+          $$updateGroupId: "$auto"
+        }); // The page is properly bound
+
+        expect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension._setBindingContext.mock.calls.length).toBe(1);
+        expect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+      });
+    });
+    it("creates a new context to bind the page when passed a target path with no context to use (non draft)", function () {
+      var mockContextBinding = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockModel = MockModel.modelFromContextBinding(mockContextBinding);
+      mockModel.setMetaModel(oMetaModelSticky);
+      return routingExtension._bindPage("/SalesOrder(123)", mockModel, {}).then(function () {
+        // The context has been created
+        expect(mockModel.bindContext.mock.calls.length).toBe(1);
+        expect(mockModel.bindContext.mock.calls[0][0]).toBe("/SalesOrder(123)");
+        expect(mockModel.bindContext.mock.calls[0][2]).toStrictEqual({
+          $$patchWithoutSideEffects: true,
+          $$groupId: "$auto.Heroes",
+          $$updateGroupId: "$auto"
+        }); // The page is properly bound
+
+        expect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension._setBindingContext.mock.calls.length).toBe(1);
+        expect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+      });
+    });
+    it("uses the context parameter to bind the page if it has the same path", function () {
+      var mockContextBindingToUse = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockContextBinding = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockModel = MockModel.modelFromContextBinding(mockContextBinding);
+      mockModel.setMetaModel(oMetaModelDraft);
+      return routingExtension._bindPage("/SalesOrder(123)", mockModel, {
+        useContext: mockContextBindingToUse.getBoundContext()
+      }).then(function () {
+        // No context has been created
+        expect(mockModel.bindContext.mock.calls.length).toBe(0); // The page is properly bound
+
+        expect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBindingToUse.getBoundContext());
+        expect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBindingToUse.getBoundContext());
+        expect(routingExtension._setBindingContext.mock.calls.length).toBe(1);
+        expect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBindingToUse.getBoundContext());
+      });
+    });
+    it("doesn't use the context parameter to bind the page if it has a different path", function () {
+      var mockContextBindingToUse = new MockContextBinding({
+        $path: "/SalesOrder(456)"
+      });
+      var mockContextBinding = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockModel = MockModel.modelFromContextBinding(mockContextBinding);
+      mockModel.setMetaModel(oMetaModelDraft);
+      return routingExtension._bindPage("/SalesOrder(123)", mockModel, {
+        useContext: mockContextBindingToUse.getBoundContext()
+      }).then(function () {
+        // A new context has been created
+        expect(mockModel.bindContext.mock.calls.length).toBe(1); // The page is properly bound
+
+        expect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension._setBindingContext.mock.calls.length).toBe(1);
+        expect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+      });
+    });
+    it("doesn't use the context parameter to bind the page if it comes from a list binding", function () {
+      var mockListBinding = new MockListBinding([{
+        $path: "/SalesOrder(123)"
+      }]);
+      var mockContextBinding = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockModel = MockModel.modelFromContextBinding(mockContextBinding);
+      mockModel.setMetaModel(oMetaModelDraft);
+      return routingExtension._bindPage("/SalesOrder(123)", mockModel, {
+        useContext: mockListBinding.getCurrentContexts()[0]
+      }).then(function () {
+        // A new context has been created
+        expect(mockModel.bindContext.mock.calls.length).toBe(1); // The page is properly bound
+
+        expect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension._setBindingContext.mock.calls.length).toBe(1);
+        expect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+      });
+    });
+    it("doesn't rebind the page if it's already bound to a context with the right path", function () {
+      var mockContextBindingUsed = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockContextBinding = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockModel = MockModel.modelFromContextBinding(mockContextBinding);
+      mockModel.setMetaModel(oMetaModelDraft);
+
+      routingExtension._getBindingContext.mockReturnValueOnce(mockContextBindingUsed.getInternalMockContext());
+
+      return routingExtension._bindPage("/SalesOrder(123)", mockModel, {}).then(function () {
+        // No context has been created
+        expect(mockModel.bindContext.mock.calls.length).toBe(0); // The page is not rebound
+
+        expect(routingExtension.onBeforeBinding.mock.calls.length).toBe(0);
+        expect(routingExtension.onAfterBinding.mock.calls.length).toBe(0);
+        expect(routingExtension._setBindingContext.mock.calls.length).toBe(0);
+      });
+    });
+    it("forces page rebind if a context is passed as a parameter", function () {
+      var mockContextBindingUsed = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockContextBinding = new MockContextBinding({
+        $path: "/SalesOrder(123)"
+      });
+      var mockModel = MockModel.modelFromContextBinding(mockContextBinding);
+      mockModel.setMetaModel(oMetaModelDraft);
+
+      routingExtension._getBindingContext.mockReturnValueOnce(mockContextBindingUsed.getInternalMockContext());
+
+      return routingExtension._bindPage("/SalesOrder(123)", mockModel, {
+        useContext: mockContextBinding.getBoundContext()
+      }).then(function () {
+        // No context has been created
+        expect(mockModel.bindContext.mock.calls.length).toBe(0); // The page is properly rebound
+
+        expect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);
+        expect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+        expect(routingExtension._setBindingContext.mock.calls.length).toBe(1);
+        expect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());
+      });
+    });
+  });
+  describe("InternalRouting - #_dataReceivedEventHandler", function () {
+    var routingExtension;
+    var libraryResourceBundleMock, busyUnLockMock, showMessagesMock;
+    beforeEach(function () {
+      try {
+        routingExtension = new TestableInternalRouting();
+        routingExtension.base = {
+          messageHandler: {
+            showMessages: function () {
+              return null;
+            }
+          }
+        };
+        libraryResourceBundleMock = jest.spyOn(sap.ui.getCore(), "getLibraryResourceBundle");
+        busyUnLockMock = jest.spyOn(BusyLocker, "unlock");
+        busyUnLockMock.mockReturnValue(true);
+        showMessagesMock = jest.spyOn(routingExtension.base.messageHandler, "showMessages");
+        showMessagesMock.mockReturnValue(true);
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("calls _dataReceivedEventHandler with error status as 503", function () {
+      try {
+        libraryResourceBundleMock.mockResolvedValue({
+          getText: function () {
+            return "Error";
+          }
+        });
+        var oEvent = {
+          getParameter: function () {
+            return {
+              status: 503
+            };
+          }
+        };
+        return Promise.resolve(routingExtension._dataReceivedEventHandler(oEvent)).then(function () {
+          expect(showMessagesMock).toHaveBeenCalledWith({
+            isInitialLoad503Error: true,
+            shellBack: true
+          });
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("calls _dataReceivedEventHandler without error status as 503", function () {
+      try {
+        libraryResourceBundleMock.mockResolvedValue({
+          getText: function () {
+            return "Error";
+          }
+        });
+        var oEvent = {
+          getParameter: function () {
+            return {
+              status: 404
+            };
+          }
+        };
+        return Promise.resolve(routingExtension._dataReceivedEventHandler(oEvent)).then(function () {
+          expect(showMessagesMock).toHaveBeenCalledWith({
+            title: "Error",
+            description: {
+              status: 404
+            },
+            isDataReceivedError: true,
+            shellBack: true
+          });
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("calls _dataReceivedEventHandler without sErrorDescription", function () {
+      try {
+        libraryResourceBundleMock.mockResolvedValue({
+          getText: function () {
+            return "Error";
+          }
+        });
+        var oEvent = {
+          getParameter: function () {
+            return null;
+          }
+        };
+        return Promise.resolve(routingExtension._dataReceivedEventHandler(oEvent)).then(function () {
+          expect(showMessagesMock).toHaveBeenCalledTimes(0);
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("calls _dataReceivedEventHandler getLibraryResourceBundle call rejected", function () {
+      try {
+        libraryResourceBundleMock.mockImplementation(function () {
+          return Promise.reject();
+        });
+        var oEvent = {
+          getParameter: function () {
+            return null;
+          }
+        };
+
+        var _temp2 = _catch(function () {
+          return Promise.resolve(routingExtension._dataReceivedEventHandler(oEvent)).then(function () {});
+        }, function () {
+          expect(showMessagesMock).toHaveBeenCalledTimes(0);
+        });
+
+        return Promise.resolve(_temp2 && _temp2.then ? _temp2.then(function () {}) : void 0);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    describe("createFilterFromSemanticPath", function () {
+      var oInternalRouting, sSemanticPath, aSemanticKeys;
+      var oMetaModelWithToLowerFilterFunction, oMetaModelWithoutToLowerFilterFunction, oMetaModelWithNoFilterFunction;
+      beforeAll(function () {
+        oInternalRouting = new InternalRouting();
+        oMetaModelWithToLowerFilterFunction = {
+          getObject: function () {
+            return ["contains", "endswith", "startswith", "length", "indexof", "substring", "tolower"];
+          }
+        };
+        oMetaModelWithoutToLowerFilterFunction = {
+          getObject: function () {
+            return ["contains", "endswith", "startswith", "length", "indexof", "substring"];
+          }
+        };
+        oMetaModelWithNoFilterFunction = {
+          getObject: function () {
+            return undefined;
+          }
+        };
+      });
+      describe("Filter created for single semantic key", function () {
+        beforeAll(function () {
+          sSemanticPath = "Products('NEW-1812')";
+          aSemanticKeys = [{
+            "$PropertyPath": "identifier"
+          }];
+        });
+        it("Service supports 'tolower' filter function", {
+          "references": [{
+            "type": "JIRA",
+            "ID": "FIORITECHP1-19019"
+          }]
+        }, function () {
+          try {
+            var actual = oInternalRouting._createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModelWithToLowerFilterFunction);
+
+            expect(actual.aFilters.length).toEqual(2);
+            expect(actual.aFilters[0].bCaseSensitive).toEqual(false);
+            expect(actual.aFilters[1].bCaseSensitive).toEqual(undefined);
+            return Promise.resolve();
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        });
+        it("Service does not support 'tolower' filter function", {
+          "references": [{
+            "type": "JIRA",
+            "ID": "FIORITECHP1-19019"
+          }]
+        }, function () {
+          try {
+            var actual = oInternalRouting._createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModelWithoutToLowerFilterFunction);
+
+            expect(actual.aFilters.length).toEqual(2);
+            expect(actual.aFilters[0].bCaseSensitive).toEqual(true);
+            expect(actual.aFilters[1].bCaseSensitive).toEqual(undefined);
+            return Promise.resolve();
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        });
+        it("Service defines no filter function", {
+          "references": [{
+            "type": "JIRA",
+            "ID": "FIORITECHP1-19019"
+          }]
+        }, function () {
+          try {
+            var actual = oInternalRouting._createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModelWithNoFilterFunction);
+
+            expect(actual.aFilters.length).toEqual(2);
+            expect(actual.aFilters[0].bCaseSensitive).toEqual(true);
+            expect(actual.aFilters[1].bCaseSensitive).toEqual(undefined);
+            return Promise.resolve();
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        });
+      });
+      describe("Filters created for multiple semantic keys", function () {
+        beforeAll(function () {
+          sSemanticPath = "Products(identifier='NEW-1812',owner='Mueller AG')";
+          aSemanticKeys = [{
+            "$PropertyPath": "identifier"
+          }, {
+            "$PropertyPath": "owner"
+          }];
+        });
+        it("Service supports 'tolower' filter function", {
+          "references": [{
+            "type": "JIRA",
+            "ID": "FIORITECHP1-19019"
+          }]
+        }, function () {
+          try {
+            var actual = oInternalRouting._createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModelWithToLowerFilterFunction);
+
+            expect(actual.aFilters.length).toEqual(3);
+            expect(actual.aFilters[0].bCaseSensitive).toEqual(false);
+            expect(actual.aFilters[1].bCaseSensitive).toEqual(false);
+            expect(actual.aFilters[2].bCaseSensitive).toEqual(undefined);
+            return Promise.resolve();
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        });
+        it("Service does not support 'tolower' filter function", {
+          "references": [{
+            "type": "JIRA",
+            "ID": "FIORITECHP1-19019"
+          }]
+        }, function () {
+          try {
+            var actual = oInternalRouting._createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModelWithoutToLowerFilterFunction);
+
+            expect(actual.aFilters.length).toEqual(3);
+            expect(actual.aFilters[0].bCaseSensitive).toEqual(true);
+            expect(actual.aFilters[1].bCaseSensitive).toEqual(true);
+            expect(actual.aFilters[2].bCaseSensitive).toEqual(undefined);
+            return Promise.resolve();
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        });
+        it("Service defines no filter function", {
+          "references": [{
+            "type": "JIRA",
+            "ID": "FIORITECHP1-19019"
+          }]
+        }, function () {
+          try {
+            var actual = oInternalRouting._createFilterFromSemanticPath(sSemanticPath, aSemanticKeys, oMetaModelWithNoFilterFunction);
+
+            expect(actual.aFilters.length).toEqual(3);
+            expect(actual.aFilters[0].bCaseSensitive).toEqual(true);
+            expect(actual.aFilters[1].bCaseSensitive).toEqual(true);
+            expect(actual.aFilters[2].bCaseSensitive).toEqual(undefined);
+            return Promise.resolve();
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        });
+      });
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["InternalRouting.spec.ts"],"names":["body","recover","result","e","then","TestableInternalRouting","onBeforeBinding","jest","fn","onAfterBinding","_setBindingContext","_getBindingContext","_oPageComponent","getEntitySet","_oRoutingService","_oRouter","InternalRouting","oMetaModelDraft","MockMetaModel","oMetaModelDraftSemanticKey1","$PropertyPath","oMetaModelDraftSemanticKey2","oMetaModelSticky","describe","it","mockModel","MockModel","modelFromListBinding","MockListBinding","$path","setMetaModel","routingExtension","setSemanticMapping","getLastSemanticMapping","undefined","setLastSemanticMapping","getHashChanger","getHash","_resolveSemanticPath","sPath","expect","toBe","mock","calls","length","toStrictEqual","technicalPath","semanticPath","bindList","beforeEach","Promise","resolve","_bindPage","toBeNull","mockContextBinding","MockContextBinding","modelFromContextBinding","bindContext","$select","$$patchWithoutSideEffects","$$groupId","$$updateGroupId","getBoundContext","mockContextBindingToUse","useContext","mockListBinding","getCurrentContexts","mockContextBindingUsed","mockReturnValueOnce","getInternalMockContext","libraryResourceBundleMock","busyUnLockMock","showMessagesMock","base","messageHandler","showMessages","spyOn","sap","ui","getCore","BusyLocker","mockReturnValue","mockResolvedValue","getText","oEvent","getParameter","status","_dataReceivedEventHandler","toHaveBeenCalledWith","isInitialLoad503Error","shellBack","title","description","isDataReceivedError","toHaveBeenCalledTimes","mockImplementation","reject","oInternalRouting","sSemanticPath","aSemanticKeys","oMetaModelWithToLowerFilterFunction","oMetaModelWithoutToLowerFilterFunction","oMetaModelWithNoFilterFunction","beforeAll","getObject","actual","_createFilterFromSemanticPath","aFilters","toEqual","bCaseSensitive"],"mappings":"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","sourceRoot":".","sourcesContent":["import BusyLocker from \"sap/fe/core/BusyLocker\";\nimport { MockContext, MockContextBinding, MockListBinding, MockMetaModel, MockModel } from \"sap/fe/test/UI5MockHelper\";\nimport InternalRouting from \"sap/fe/core/controllerextensions/InternalRouting\";\n\n// @ts-ignore\nclass TestableInternalRouting extends InternalRouting {\n\tonBeforeBinding = jest.fn();\n\tonAfterBinding = jest.fn();\n\t_setBindingContext = jest.fn();\n\t_getBindingContext: any = jest.fn((): MockContext | null => {\n\t\treturn null;\n\t});\n\t_oPageComponent: any = {\n\t\tgetEntitySet() {\n\t\t\treturn \"com.c_salesordermanage_sd.SalesOrder\";\n\t\t}\n\t};\n\t_oRoutingService: any = {};\n\t_oRouter: any = {};\n}\n\nconst oMetaModelDraft = new MockMetaModel({\n\t\"/SalesOrder@com.sap.vocabularies.Common.v1.DraftRoot\": true,\n\t\"/com.c_salesordermanage_sd.SalesOrder@com.sap.vocabularies.Common.v1.DraftRoot\": true,\n\t\"/com.c_salesordermanage_sd.SalesOrder/@com.sap.vocabularies.Common.v1.Messages/$Path\": \"SAP_Messages\"\n});\n\nconst oMetaModelDraftSemanticKey1 = new MockMetaModel({\n\t\"/SalesOrder@com.sap.vocabularies.Common.v1.DraftRoot\": true,\n\t\"/SalesOrder/@com.sap.vocabularies.Common.v1.SemanticKey\": [{ $PropertyPath: \"sem1\" }]\n});\n\nconst oMetaModelDraftSemanticKey2 = new MockMetaModel({\n\t\"/SalesOrder@com.sap.vocabularies.Common.v1.DraftRoot\": true,\n\t\"/SalesOrder/@com.sap.vocabularies.Common.v1.SemanticKey\": [{ $PropertyPath: \"sem1\" }, { $PropertyPath: \"sem2\" }]\n});\n\nconst oMetaModelSticky = new MockMetaModel({});\n\ndescribe(\"InternalRouting = #resolveSemanticPath\", () => {\n\tit(\"resolves path with 1 semantic key (no semantic mapping)\", () => {\n\t\tconst mockModel = MockModel.modelFromListBinding(new MockListBinding([{ $path: \"/SalesOrder(key1=123,key2=456)\" }]));\n\t\tmockModel.setMetaModel(oMetaModelDraftSemanticKey1);\n\t\tconst routingExtension = new TestableInternalRouting();\n\t\tconst setSemanticMapping = jest.fn();\n\t\troutingExtension._oRoutingService.getLastSemanticMapping = jest.fn(() => undefined);\n\t\troutingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;\n\t\troutingExtension._oRouter.getHashChanger = jest.fn(() => {\n\t\t\treturn { getHash: jest.fn(() => \"/SalesOrder(123)\") };\n\t\t});\n\n\t\treturn routingExtension._resolveSemanticPath(\"/SalesOrder(123)\", mockModel).then(sPath => {\n\t\t\t// The semantic path is properly resolved\n\t\t\texpect(sPath).toBe(\"/SalesOrder(key1=123,key2=456)\");\n\n\t\t\t// The semantic mapping is stored on the routing service\n\t\t\texpect(setSemanticMapping.mock.calls.length).toBe(1);\n\t\t\texpect(setSemanticMapping.mock.calls[0][0]).toStrictEqual({\n\t\t\t\ttechnicalPath: \"/SalesOrder(key1=123,key2=456)\",\n\t\t\t\tsemanticPath: \"/SalesOrder(123)\"\n\t\t\t});\n\n\t\t\t// A query has been sent to resolve the semantic path\n\t\t\texpect(mockModel.bindList.mock.calls.length).toBe(1);\n\t\t});\n\t});\n\n\tit(\"resolves path with 2 semantic keys (no semantic mapping)\", () => {\n\t\tconst mockModel = MockModel.modelFromListBinding(new MockListBinding([{ $path: \"/SalesOrder(key1=123,key2=456)\" }]));\n\t\tmockModel.setMetaModel(oMetaModelDraftSemanticKey2);\n\t\tconst routingExtension = new TestableInternalRouting();\n\t\tconst setSemanticMapping = jest.fn();\n\t\troutingExtension._oRoutingService.getLastSemanticMapping = jest.fn(() => undefined);\n\t\troutingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;\n\t\troutingExtension._oRouter.getHashChanger = jest.fn(() => {\n\t\t\treturn { getHash: jest.fn(() => \"/SalesOrder(sem1=ABC,sem2=DEF)\") };\n\t\t});\n\n\t\treturn routingExtension._resolveSemanticPath(\"/SalesOrder(sem1=ABC,sem2=DEF)\", mockModel).then(sPath => {\n\t\t\t// The semantic path is properly resolved\n\t\t\texpect(sPath).toBe(\"/SalesOrder(key1=123,key2=456)\");\n\n\t\t\t// The semantic mapping is stored on the routing service\n\t\t\texpect(setSemanticMapping.mock.calls.length).toBe(1);\n\t\t\texpect(setSemanticMapping.mock.calls[0][0]).toStrictEqual({\n\t\t\t\ttechnicalPath: \"/SalesOrder(key1=123,key2=456)\",\n\t\t\t\tsemanticPath: \"/SalesOrder(sem1=ABC,sem2=DEF)\"\n\t\t\t});\n\n\t\t\t// A query has been sent to resolve the semantic path\n\t\t\texpect(mockModel.bindList.mock.calls.length).toBe(1);\n\t\t});\n\t});\n\n\tit(\"resolves path with 1 semantic key (with semantic mapping)\", () => {\n\t\tconst mockModel = MockModel.modelFromListBinding(new MockListBinding([{ $path: \"/SalesOrder(key1=123,key2=456)\" }]));\n\t\tmockModel.setMetaModel(oMetaModelDraftSemanticKey1);\n\t\tconst routingExtension = new TestableInternalRouting();\n\t\tconst setSemanticMapping = jest.fn();\n\t\troutingExtension._oRoutingService.getLastSemanticMapping = jest.fn(() => {\n\t\t\treturn { technicalPath: \"/SalesOrder(key1=123,key2=456)\", semanticPath: \"/SalesOrder(123)\" };\n\t\t});\n\t\troutingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;\n\t\troutingExtension._oRouter.getHashChanger = jest.fn(() => {\n\t\t\treturn { getHash: jest.fn(() => \"/SalesOrder(123)\") };\n\t\t});\n\n\t\treturn routingExtension._resolveSemanticPath(\"/SalesOrder(123)\", mockModel).then(sPath => {\n\t\t\t// The semantic path is properly resolved\n\t\t\texpect(sPath).toBe(\"/SalesOrder(key1=123,key2=456)\");\n\n\t\t\t// The semantic mapping doesn't need to be stored on the routing service\n\t\t\texpect(setSemanticMapping.mock.calls.length).toBe(0);\n\n\t\t\t// No query has been sent to resolve the semantic path\n\t\t\texpect(mockModel.bindList.mock.calls.length).toBe(0);\n\t\t});\n\t});\n\n\tit(\"resolves path with 1 semantic key (wrong semantic mapping)\", () => {\n\t\tconst mockModel = MockModel.modelFromListBinding(new MockListBinding([{ $path: \"/SalesOrder(key1=123,key2=456)\" }]));\n\t\tmockModel.setMetaModel(oMetaModelDraftSemanticKey1);\n\t\tconst routingExtension = new TestableInternalRouting();\n\t\tconst setSemanticMapping = jest.fn();\n\t\troutingExtension._oRoutingService.getLastSemanticMapping = jest.fn(() => {\n\t\t\treturn { technicalPath: \"/SalesOrder(key1=123,key2=456)\", semanticPath: \"/SalesOrder(ABC)\" };\n\t\t});\n\t\troutingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;\n\t\troutingExtension._oRouter.getHashChanger = jest.fn(() => {\n\t\t\treturn { getHash: jest.fn(() => \"/SalesOrder(123)\") };\n\t\t});\n\n\t\treturn routingExtension._resolveSemanticPath(\"/SalesOrder(123)\", mockModel).then(sPath => {\n\t\t\t// The semantic path is properly resolved\n\t\t\texpect(sPath).toBe(\"/SalesOrder(key1=123,key2=456)\");\n\n\t\t\t// The semantic mapping is stored on the routing service\n\t\t\texpect(setSemanticMapping.mock.calls.length).toBe(1);\n\t\t\texpect(setSemanticMapping.mock.calls[0][0]).toStrictEqual({\n\t\t\t\ttechnicalPath: \"/SalesOrder(key1=123,key2=456)\",\n\t\t\t\tsemanticPath: \"/SalesOrder(123)\"\n\t\t\t});\n\n\t\t\t// A query has been sent to resolve the semantic path\n\t\t\texpect(mockModel.bindList.mock.calls.length).toBe(1);\n\t\t});\n\t});\n\n\tit(\"doesn't resolve path if entity is not draft\", () => {\n\t\tconst mockModel = MockModel.modelFromListBinding(new MockListBinding([{ $path: \"/SalesOrder(key1=123,key2=456)\" }]));\n\t\tmockModel.setMetaModel(oMetaModelSticky);\n\t\tconst routingExtension = new TestableInternalRouting();\n\t\tconst setSemanticMapping = jest.fn();\n\t\troutingExtension._oRoutingService.getLastSemanticMapping = jest.fn(() => {\n\t\t\treturn { technicalPath: \"/SalesOrder(key1=123,key2=456)\", semanticPath: \"/SalesOrder(123)\" };\n\t\t});\n\t\troutingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;\n\t\troutingExtension._oRouter.getHashChanger = jest.fn(() => {\n\t\t\treturn { getHash: jest.fn(() => \"/SalesOrder(123)\") };\n\t\t});\n\n\t\treturn routingExtension._resolveSemanticPath(\"/SalesOrder(123)\", mockModel).then(sPath => {\n\t\t\t// The semantic path is properly resolved\n\t\t\texpect(sPath).toBe(\"/SalesOrder(123)\");\n\n\t\t\t// No semantic mapping stored on the routing service\n\t\t\texpect(setSemanticMapping.mock.calls.length).toBe(0);\n\n\t\t\t// No query has been sent to resolve the semantic path\n\t\t\texpect(mockModel.bindList.mock.calls.length).toBe(0);\n\t\t});\n\t});\n\n\tit(\"doesn't resolve path if entity doesn't have semantic keys\", () => {\n\t\tconst mockModel = MockModel.modelFromListBinding(new MockListBinding([{ $path: \"/SalesOrder(key1=123,key2=456)\" }]));\n\t\tmockModel.setMetaModel(oMetaModelDraft);\n\t\tconst routingExtension = new TestableInternalRouting();\n\t\tconst setSemanticMapping = jest.fn();\n\t\troutingExtension._oRoutingService.getLastSemanticMapping = jest.fn(() => {\n\t\t\treturn { technicalPath: \"/SalesOrder(key1=123,key2=456)\", semanticPath: \"/SalesOrder(123)\" };\n\t\t});\n\t\troutingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;\n\t\troutingExtension._oRouter.getHashChanger = jest.fn(() => {\n\t\t\treturn { getHash: jest.fn(() => \"/SalesOrder(123)\") };\n\t\t});\n\n\t\treturn routingExtension._resolveSemanticPath(\"/SalesOrder(123)\", mockModel).then(sPath => {\n\t\t\t// The semantic path is properly resolved\n\t\t\texpect(sPath).toBe(\"/SalesOrder(123)\");\n\n\t\t\t// No semantic mapping stored on the routing service\n\t\t\texpect(setSemanticMapping.mock.calls.length).toBe(0);\n\n\t\t\t// No query has been sent to resolve the semantic path\n\t\t\texpect(mockModel.bindList.mock.calls.length).toBe(0);\n\t\t});\n\t});\n\n\tit(\"doesn't resolve path on sub-object page\", () => {\n\t\tconst mockModel = MockModel.modelFromListBinding(new MockListBinding([{ $path: \"/SalesOrder(key1=123,key2=456)\" }]));\n\t\tmockModel.setMetaModel(oMetaModelDraftSemanticKey1);\n\t\tconst routingExtension = new TestableInternalRouting();\n\t\tconst setSemanticMapping = jest.fn();\n\t\troutingExtension._oRoutingService.getLastSemanticMapping = jest.fn(() => undefined);\n\t\troutingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;\n\t\troutingExtension._oRouter.getHashChanger = jest.fn(() => {\n\t\t\treturn { getHash: jest.fn(() => \"/SalesOrder(123)/_Item(456)\") };\n\t\t});\n\n\t\treturn routingExtension._resolveSemanticPath(\"/SalesOrder(123)/_Item(456)\", mockModel).then(sPath => {\n\t\t\t// The semantic path is properly resolved\n\t\t\texpect(sPath).toBe(\"/SalesOrder(123)/_Item(456)\");\n\n\t\t\t// No semantic mapping stored on the routing service\n\t\t\texpect(setSemanticMapping.mock.calls.length).toBe(0);\n\n\t\t\t// No query has been sent to resolve the semantic path\n\t\t\texpect(mockModel.bindList.mock.calls.length).toBe(0);\n\t\t});\n\t});\n\n\tit(\"doesn't resolve path on object page if the app if FCL with 3 columns open\", () => {\n\t\tconst mockModel = MockModel.modelFromListBinding(new MockListBinding([{ $path: \"/SalesOrder(key1=123,key2=456)\" }]));\n\t\tmockModel.setMetaModel(oMetaModelDraftSemanticKey1);\n\t\tconst routingExtension = new TestableInternalRouting();\n\t\tconst setSemanticMapping = jest.fn();\n\t\troutingExtension._oRoutingService.getLastSemanticMapping = jest.fn(() => undefined);\n\t\troutingExtension._oRoutingService.setLastSemanticMapping = setSemanticMapping;\n\t\troutingExtension._oRouter.getHashChanger = jest.fn(() => {\n\t\t\treturn { getHash: jest.fn(() => \"/SalesOrder(123)/_Item(456)\") };\n\t\t});\n\n\t\treturn routingExtension._resolveSemanticPath(\"/SalesOrder(123)\", mockModel).then(sPath => {\n\t\t\t// The semantic path is properly resolved\n\t\t\texpect(sPath).toBe(\"/SalesOrder(123)\");\n\n\t\t\t// No semantic mapping stored on the routing service\n\t\t\texpect(setSemanticMapping.mock.calls.length).toBe(0);\n\n\t\t\t// No query has been sent to resolve the semantic path\n\t\t\texpect(mockModel.bindList.mock.calls.length).toBe(0);\n\t\t});\n\t});\n});\n\ndescribe(\"InternalRouting - #bindPage\", () => {\n\tlet routingExtension: TestableInternalRouting;\n\n\tbeforeEach(async function() {\n\t\troutingExtension = new TestableInternalRouting();\n\t\t// We don't test semantic bookmarking in this set of tests, so we can mock this method\n\t\troutingExtension._resolveSemanticPath = jest.fn(() => {\n\t\t\treturn Promise.resolve(\"/SalesOrder(123)\");\n\t\t});\n\t});\n\n\tit(\"calls onBefore and onAfterBinding will called with an empty path\", () => {\n\t\treturn routingExtension._bindPage(\"\", null, {}).then(() => {\n\t\t\texpect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBeNull();\n\t\t\texpect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension.onAfterBinding.mock.calls[0][0]).toBeNull();\n\t\t\texpect(routingExtension._setBindingContext.mock.calls.length).toBe(0);\n\t\t});\n\t});\n\n\tit(\"creates a new context to bind the page when passed a target path with no context to use\", () => {\n\t\tconst mockContextBinding = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockModel = MockModel.modelFromContextBinding(mockContextBinding);\n\t\tmockModel.setMetaModel(oMetaModelDraft);\n\n\t\treturn routingExtension._bindPage(\"/SalesOrder(123)\", mockModel, {}).then(() => {\n\t\t\t// The context has been created\n\t\t\texpect(mockModel.bindContext.mock.calls.length).toBe(1);\n\t\t\texpect(mockModel.bindContext.mock.calls[0][0]).toBe(\"/SalesOrder(123)\");\n\t\t\texpect(mockModel.bindContext.mock.calls[0][2]).toStrictEqual({\n\t\t\t\t$select: \"SAP_Messages,HasActiveEntity,HasDraftEntity,IsActiveEntity\",\n\t\t\t\t$$patchWithoutSideEffects: true,\n\t\t\t\t$$groupId: \"$auto.Heroes\",\n\t\t\t\t$$updateGroupId: \"$auto\"\n\t\t\t});\n\n\t\t\t// The page is properly bound\n\t\t\texpect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\texpect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\texpect(routingExtension._setBindingContext.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t});\n\t});\n\n\tit(\"creates a new context to bind the page when passed a target path with no context to use (non draft)\", () => {\n\t\tconst mockContextBinding = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockModel = MockModel.modelFromContextBinding(mockContextBinding);\n\t\tmockModel.setMetaModel(oMetaModelSticky);\n\n\t\treturn routingExtension._bindPage(\"/SalesOrder(123)\", mockModel, {}).then(() => {\n\t\t\t// The context has been created\n\t\t\texpect(mockModel.bindContext.mock.calls.length).toBe(1);\n\t\t\texpect(mockModel.bindContext.mock.calls[0][0]).toBe(\"/SalesOrder(123)\");\n\t\t\texpect(mockModel.bindContext.mock.calls[0][2]).toStrictEqual({\n\t\t\t\t$$patchWithoutSideEffects: true,\n\t\t\t\t$$groupId: \"$auto.Heroes\",\n\t\t\t\t$$updateGroupId: \"$auto\"\n\t\t\t});\n\n\t\t\t// The page is properly bound\n\t\t\texpect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\texpect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\texpect(routingExtension._setBindingContext.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t});\n\t});\n\n\tit(\"uses the context parameter to bind the page if it has the same path\", () => {\n\t\tconst mockContextBindingToUse = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockContextBinding = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockModel = MockModel.modelFromContextBinding(mockContextBinding);\n\t\tmockModel.setMetaModel(oMetaModelDraft);\n\n\t\treturn routingExtension\n\t\t\t._bindPage(\"/SalesOrder(123)\", mockModel, { useContext: mockContextBindingToUse.getBoundContext() })\n\t\t\t.then(() => {\n\t\t\t\t// No context has been created\n\t\t\t\texpect(mockModel.bindContext.mock.calls.length).toBe(0);\n\n\t\t\t\t// The page is properly bound\n\t\t\t\texpect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);\n\t\t\t\texpect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBindingToUse.getBoundContext());\n\t\t\t\texpect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);\n\t\t\t\texpect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBindingToUse.getBoundContext());\n\t\t\t\texpect(routingExtension._setBindingContext.mock.calls.length).toBe(1);\n\t\t\t\texpect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBindingToUse.getBoundContext());\n\t\t\t});\n\t});\n\n\tit(\"doesn't use the context parameter to bind the page if it has a different path\", () => {\n\t\tconst mockContextBindingToUse = new MockContextBinding({ $path: \"/SalesOrder(456)\" });\n\t\tconst mockContextBinding = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockModel = MockModel.modelFromContextBinding(mockContextBinding);\n\t\tmockModel.setMetaModel(oMetaModelDraft);\n\n\t\treturn routingExtension\n\t\t\t._bindPage(\"/SalesOrder(123)\", mockModel, { useContext: mockContextBindingToUse.getBoundContext() })\n\t\t\t.then(() => {\n\t\t\t\t// A new context has been created\n\t\t\t\texpect(mockModel.bindContext.mock.calls.length).toBe(1);\n\n\t\t\t\t// The page is properly bound\n\t\t\t\texpect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);\n\t\t\t\texpect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\t\texpect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);\n\t\t\t\texpect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\t\texpect(routingExtension._setBindingContext.mock.calls.length).toBe(1);\n\t\t\t\texpect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\t});\n\t});\n\n\tit(\"doesn't use the context parameter to bind the page if it comes from a list binding\", () => {\n\t\tconst mockListBinding = new MockListBinding([{ $path: \"/SalesOrder(123)\" }]);\n\t\tconst mockContextBinding = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockModel = MockModel.modelFromContextBinding(mockContextBinding);\n\t\tmockModel.setMetaModel(oMetaModelDraft);\n\n\t\treturn routingExtension\n\t\t\t._bindPage(\"/SalesOrder(123)\", mockModel, { useContext: mockListBinding.getCurrentContexts()[0] })\n\t\t\t.then(() => {\n\t\t\t\t// A new context has been created\n\t\t\t\texpect(mockModel.bindContext.mock.calls.length).toBe(1);\n\n\t\t\t\t// The page is properly bound\n\t\t\t\texpect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);\n\t\t\t\texpect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\t\texpect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);\n\t\t\t\texpect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\t\texpect(routingExtension._setBindingContext.mock.calls.length).toBe(1);\n\t\t\t\texpect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\t});\n\t});\n\n\tit(\"doesn't rebind the page if it's already bound to a context with the right path\", () => {\n\t\tconst mockContextBindingUsed = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockContextBinding = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockModel = MockModel.modelFromContextBinding(mockContextBinding);\n\t\tmockModel.setMetaModel(oMetaModelDraft);\n\n\t\troutingExtension._getBindingContext.mockReturnValueOnce(mockContextBindingUsed.getInternalMockContext());\n\t\treturn routingExtension._bindPage(\"/SalesOrder(123)\", mockModel, {}).then(() => {\n\t\t\t// No context has been created\n\t\t\texpect(mockModel.bindContext.mock.calls.length).toBe(0);\n\n\t\t\t// The page is not rebound\n\t\t\texpect(routingExtension.onBeforeBinding.mock.calls.length).toBe(0);\n\t\t\texpect(routingExtension.onAfterBinding.mock.calls.length).toBe(0);\n\t\t\texpect(routingExtension._setBindingContext.mock.calls.length).toBe(0);\n\t\t});\n\t});\n\n\tit(\"forces page rebind if a context is passed as a parameter\", () => {\n\t\tconst mockContextBindingUsed = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockContextBinding = new MockContextBinding({ $path: \"/SalesOrder(123)\" });\n\t\tconst mockModel = MockModel.modelFromContextBinding(mockContextBinding);\n\t\tmockModel.setMetaModel(oMetaModelDraft);\n\n\t\troutingExtension._getBindingContext.mockReturnValueOnce(mockContextBindingUsed.getInternalMockContext());\n\t\treturn routingExtension._bindPage(\"/SalesOrder(123)\", mockModel, { useContext: mockContextBinding.getBoundContext() }).then(() => {\n\t\t\t// No context has been created\n\t\t\texpect(mockModel.bindContext.mock.calls.length).toBe(0);\n\n\t\t\t// The page is properly rebound\n\t\t\texpect(routingExtension.onBeforeBinding.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension.onBeforeBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\texpect(routingExtension.onAfterBinding.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension.onAfterBinding.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t\texpect(routingExtension._setBindingContext.mock.calls.length).toBe(1);\n\t\t\texpect(routingExtension._setBindingContext.mock.calls[0][0]).toBe(mockContextBinding.getBoundContext());\n\t\t});\n\t});\n});\n\ndescribe(\"InternalRouting - #_dataReceivedEventHandler\", () => {\n\tlet routingExtension: TestableInternalRouting;\n\tlet libraryResourceBundleMock: any, busyUnLockMock, showMessagesMock: any;\n\tbeforeEach(async function() {\n\t\troutingExtension = new TestableInternalRouting();\n\t\t(routingExtension as any).base = {\n\t\t\tmessageHandler: {\n\t\t\t\tshowMessages: function() {\n\t\t\t\t\treturn null;\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\tlibraryResourceBundleMock = jest.spyOn(sap.ui.getCore() as any, \"getLibraryResourceBundle\");\n\t\tbusyUnLockMock = jest.spyOn(BusyLocker, \"unlock\");\n\t\tbusyUnLockMock.mockReturnValue(true);\n\t\tshowMessagesMock = jest.spyOn((routingExtension as any).base.messageHandler, \"showMessages\");\n\t\tshowMessagesMock.mockReturnValue(true);\n\t});\n\n\tit(\"calls _dataReceivedEventHandler with error status as 503\", async () => {\n\t\tlibraryResourceBundleMock.mockResolvedValue({\n\t\t\tgetText: function() {\n\t\t\t\treturn \"Error\";\n\t\t\t}\n\t\t});\n\t\tconst oEvent = {\n\t\t\tgetParameter: function() {\n\t\t\t\treturn {\n\t\t\t\t\tstatus: 503\n\t\t\t\t};\n\t\t\t}\n\t\t};\n\t\tawait (routingExtension as any)._dataReceivedEventHandler(oEvent);\n\t\texpect(showMessagesMock).toHaveBeenCalledWith({ isInitialLoad503Error: true, shellBack: true });\n\t});\n\n\tit(\"calls _dataReceivedEventHandler without error status as 503\", async () => {\n\t\tlibraryResourceBundleMock.mockResolvedValue({\n\t\t\tgetText: function() {\n\t\t\t\treturn \"Error\";\n\t\t\t}\n\t\t});\n\t\tconst oEvent = {\n\t\t\tgetParameter: function() {\n\t\t\t\treturn {\n\t\t\t\t\tstatus: 404\n\t\t\t\t};\n\t\t\t}\n\t\t};\n\t\tawait (routingExtension as any)._dataReceivedEventHandler(oEvent);\n\t\texpect(showMessagesMock).toHaveBeenCalledWith({\n\t\t\ttitle: \"Error\",\n\t\t\tdescription: { status: 404 },\n\t\t\tisDataReceivedError: true,\n\t\t\tshellBack: true\n\t\t});\n\t});\n\n\tit(\"calls _dataReceivedEventHandler without sErrorDescription\", async () => {\n\t\tlibraryResourceBundleMock.mockResolvedValue({\n\t\t\tgetText: function() {\n\t\t\t\treturn \"Error\";\n\t\t\t}\n\t\t});\n\t\tconst oEvent = {\n\t\t\tgetParameter: function() {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t};\n\t\tawait (routingExtension as any)._dataReceivedEventHandler(oEvent);\n\t\texpect(showMessagesMock).toHaveBeenCalledTimes(0);\n\t});\n\tit(\"calls _dataReceivedEventHandler getLibraryResourceBundle call rejected\", async () => {\n\t\tlibraryResourceBundleMock.mockImplementation(() => {\n\t\t\treturn Promise.reject();\n\t\t});\n\t\tconst oEvent = {\n\t\t\tgetParameter: function() {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t};\n\t\ttry {\n\t\t\tawait (routingExtension as any)._dataReceivedEventHandler(oEvent);\n\t\t} catch {\n\t\t\texpect(showMessagesMock).toHaveBeenCalledTimes(0);\n\t\t}\n\t});\n\tdescribe(\"createFilterFromSemanticPath\", () => {\n\t\tlet oInternalRouting: InternalRouting, sSemanticPath: string, aSemanticKeys: any[];\n\t\tlet oMetaModelWithToLowerFilterFunction: any, oMetaModelWithoutToLowerFilterFunction: any, oMetaModelWithNoFilterFunction: any;\n\t\tbeforeAll(() => {\n\t\t\toInternalRouting = new InternalRouting();\n\t\t\toMetaModelWithToLowerFilterFunction = {\n\t\t\t\tgetObject: function() {\n\t\t\t\t\treturn [\"contains\", \"endswith\", \"startswith\", \"length\", \"indexof\", \"substring\", \"tolower\"];\n\t\t\t\t}\n\t\t\t};\n\t\t\toMetaModelWithoutToLowerFilterFunction = {\n\t\t\t\tgetObject: function() {\n\t\t\t\t\treturn [\"contains\", \"endswith\", \"startswith\", \"length\", \"indexof\", \"substring\"];\n\t\t\t\t}\n\t\t\t};\n\t\t\toMetaModelWithNoFilterFunction = {\n\t\t\t\tgetObject: function() {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t};\n\t\t});\n\n\t\tdescribe(\"Filter created for single semantic key\", () => {\n\t\t\tbeforeAll(() => {\n\t\t\t\tsSemanticPath = \"Products('NEW-1812')\";\n\t\t\t\taSemanticKeys = [\n\t\t\t\t\t{\n\t\t\t\t\t\t\"$PropertyPath\": \"identifier\"\n\t\t\t\t\t}\n\t\t\t\t];\n\t\t\t});\n\t\t\tit(\n\t\t\t\t\"Service supports 'tolower' filter function\",\n\t\t\t\t{\n\t\t\t\t\t\"references\": [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\"type\": \"JIRA\",\n\t\t\t\t\t\t\t\"ID\": \"FIORITECHP1-19019\"\n\t\t\t\t\t\t}\n\t\t\t\t\t]\n\t\t\t\t},\n\t\t\t\tasync () => {\n\t\t\t\t\tconst actual = oInternalRouting._createFilterFromSemanticPath(\n\t\t\t\t\t\tsSemanticPath,\n\t\t\t\t\t\taSemanticKeys,\n\t\t\t\t\t\toMetaModelWithToLowerFilterFunction\n\t\t\t\t\t) as any;\n\t\t\t\t\texpect(actual.aFilters.length).toEqual(2);\n\t\t\t\t\texpect(actual.aFilters[0].bCaseSensitive).toEqual(false);\n\t\t\t\t\texpect(actual.aFilters[1].bCaseSensitive).toEqual(undefined);\n\t\t\t\t}\n\t\t\t);\n\t\t\tit(\n\t\t\t\t\"Service does not support 'tolower' filter function\",\n\t\t\t\t{\n\t\t\t\t\t\"references\": [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\"type\": \"JIRA\",\n\t\t\t\t\t\t\t\"ID\": \"FIORITECHP1-19019\"\n\t\t\t\t\t\t}\n\t\t\t\t\t]\n\t\t\t\t},\n\t\t\t\tasync () => {\n\t\t\t\t\tconst actual = oInternalRouting._createFilterFromSemanticPath(\n\t\t\t\t\t\tsSemanticPath,\n\t\t\t\t\t\taSemanticKeys,\n\t\t\t\t\t\toMetaModelWithoutToLowerFilterFunction\n\t\t\t\t\t) as any;\n\t\t\t\t\texpect(actual.aFilters.length).toEqual(2);\n\t\t\t\t\texpect(actual.aFilters[0].bCaseSensitive).toEqual(true);\n\t\t\t\t\texpect(actual.aFilters[1].bCaseSensitive).toEqual(undefined);\n\t\t\t\t}\n\t\t\t);\n\t\t\tit(\n\t\t\t\t\"Service defines no filter function\",\n\t\t\t\t{\n\t\t\t\t\t\"references\": [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\"type\": \"JIRA\",\n\t\t\t\t\t\t\t\"ID\": \"FIORITECHP1-19019\"\n\t\t\t\t\t\t}\n\t\t\t\t\t]\n\t\t\t\t},\n\t\t\t\tasync () => {\n\t\t\t\t\tconst actual = oInternalRouting._createFilterFromSemanticPath(\n\t\t\t\t\t\tsSemanticPath,\n\t\t\t\t\t\taSemanticKeys,\n\t\t\t\t\t\toMetaModelWithNoFilterFunction\n\t\t\t\t\t) as any;\n\t\t\t\t\texpect(actual.aFilters.length).toEqual(2);\n\t\t\t\t\texpect(actual.aFilters[0].bCaseSensitive).toEqual(true);\n\t\t\t\t\texpect(actual.aFilters[1].bCaseSensitive).toEqual(undefined);\n\t\t\t\t}\n\t\t\t);\n\t\t});\n\n\t\tdescribe(\"Filters created for multiple semantic keys\", () => {\n\t\t\tbeforeAll(() => {\n\t\t\t\tsSemanticPath = \"Products(identifier='NEW-1812',owner='Mueller AG')\";\n\t\t\t\taSemanticKeys = [\n\t\t\t\t\t{\n\t\t\t\t\t\t\"$PropertyPath\": \"identifier\"\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\t\"$PropertyPath\": \"owner\"\n\t\t\t\t\t}\n\t\t\t\t];\n\t\t\t});\n\n\t\t\tit(\n\t\t\t\t\"Service supports 'tolower' filter function\",\n\t\t\t\t{\n\t\t\t\t\t\"references\": [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\"type\": \"JIRA\",\n\t\t\t\t\t\t\t\"ID\": \"FIORITECHP1-19019\"\n\t\t\t\t\t\t}\n\t\t\t\t\t]\n\t\t\t\t},\n\t\t\t\tasync () => {\n\t\t\t\t\tconst actual = oInternalRouting._createFilterFromSemanticPath(\n\t\t\t\t\t\tsSemanticPath,\n\t\t\t\t\t\taSemanticKeys,\n\t\t\t\t\t\toMetaModelWithToLowerFilterFunction\n\t\t\t\t\t) as any;\n\t\t\t\t\texpect(actual.aFilters.length).toEqual(3);\n\t\t\t\t\texpect(actual.aFilters[0].bCaseSensitive).toEqual(false);\n\t\t\t\t\texpect(actual.aFilters[1].bCaseSensitive).toEqual(false);\n\t\t\t\t\texpect(actual.aFilters[2].bCaseSensitive).toEqual(undefined);\n\t\t\t\t}\n\t\t\t);\n\t\t\tit(\n\t\t\t\t\"Service does not support 'tolower' filter function\",\n\t\t\t\t{\n\t\t\t\t\t\"references\": [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\"type\": \"JIRA\",\n\t\t\t\t\t\t\t\"ID\": \"FIORITECHP1-19019\"\n\t\t\t\t\t\t}\n\t\t\t\t\t]\n\t\t\t\t},\n\t\t\t\tasync () => {\n\t\t\t\t\tconst actual = oInternalRouting._createFilterFromSemanticPath(\n\t\t\t\t\t\tsSemanticPath,\n\t\t\t\t\t\taSemanticKeys,\n\t\t\t\t\t\toMetaModelWithoutToLowerFilterFunction\n\t\t\t\t\t) as any;\n\t\t\t\t\texpect(actual.aFilters.length).toEqual(3);\n\t\t\t\t\texpect(actual.aFilters[0].bCaseSensitive).toEqual(true);\n\t\t\t\t\texpect(actual.aFilters[1].bCaseSensitive).toEqual(true);\n\t\t\t\t\texpect(actual.aFilters[2].bCaseSensitive).toEqual(undefined);\n\t\t\t\t}\n\t\t\t);\n\t\t\tit(\n\t\t\t\t\"Service defines no filter function\",\n\t\t\t\t{\n\t\t\t\t\t\"references\": [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\"type\": \"JIRA\",\n\t\t\t\t\t\t\t\"ID\": \"FIORITECHP1-19019\"\n\t\t\t\t\t\t}\n\t\t\t\t\t]\n\t\t\t\t},\n\t\t\t\tasync () => {\n\t\t\t\t\tconst actual = oInternalRouting._createFilterFromSemanticPath(\n\t\t\t\t\t\tsSemanticPath,\n\t\t\t\t\t\taSemanticKeys,\n\t\t\t\t\t\toMetaModelWithNoFilterFunction\n\t\t\t\t\t) as any;\n\t\t\t\t\texpect(actual.aFilters.length).toEqual(3);\n\t\t\t\t\texpect(actual.aFilters[0].bCaseSensitive).toEqual(true);\n\t\t\t\t\texpect(actual.aFilters[1].bCaseSensitive).toEqual(true);\n\t\t\t\t\texpect(actual.aFilters[2].bCaseSensitive).toEqual(undefined);\n\t\t\t\t}\n\t\t\t);\n\t\t});\n\t});\n});\n"]}