@sap/open.fe 1.97.0 → 1.98.0

package/packages/sap.fe.core/test/sap/fe/core/jest/controllerextensions/KPIManagement.spec.ts

@@ -24,6 +24,10 @@ class KPIManagementForTest extends KPIManagementControllerExtension {
 	public initCardManifestPublic(kpiDefinition: KPIDefinition, oKPIModel: JSONModel<any>) {
 		return this.initCardManifest(kpiDefinition, oKPIModel);
 	}
+
+	public initNavigationInfoPublic(kpiDefinition: KPIDefinition, oKPIModel: JSONModel<any>, oShellService: any): Promise<void> {
+		return this.initNavigationInfo(kpiDefinition, oKPIModel, oShellService);
+	}
 }
 
 let kpiExtension: KPIManagementForTest;
@@ -221,6 +225,229 @@ describe("KPIManagement - #initKPIManifest", function() {
 	});
 });
 
+describe("KPIManagement - #initNavigationInfo", function() {
+	const mockShellService = {
+		getLinks: jest.fn(),
+		getPrimaryIntent: jest.fn(),
+		parseShellHash: jest.fn()
+	};
+	const kpiModel = new JSONModel();
+
+	beforeAll(async function() {
+		kpiExtension = new KPIManagementForTest();
+	});
+	beforeEach(async function() {
+		// Clean JSON and mocks
+		kpiModel.setProperty("/1", { manifest: { "sap.card": { header: {} } } });
+
+		mockShellService.getLinks.mockReset();
+		mockShellService.getPrimaryIntent.mockReset();
+		mockShellService.parseShellHash.mockReset();
+	});
+
+	it("builds navigation info from a semantic object and an action", () => {
+		const kpiDefinition: KPIDefinition = {
+			id: "1",
+			entitySet: "unused",
+			datapoint: {
+				annotationPath: "unused",
+				propertyPath: "kpiProperty"
+			},
+			chart: {
+				chartType: "Line",
+				dimensions: [],
+				measures: []
+			},
+			navigation: {
+				semanticObject: "SemObject",
+				action: "theAction"
+			}
+		};
+
+		mockShellService.getLinks.mockReturnValue(Promise.resolve([true]));
+
+		return kpiExtension.initNavigationInfoPublic(kpiDefinition, kpiModel, mockShellService).then(() => {
+			expect(mockShellService.getLinks.mock.calls.length).toBe(1);
+			expect(mockShellService.getLinks.mock.calls[0][0]).toStrictEqual({
+				semanticObject: "SemObject",
+				action: "theAction"
+			});
+			expect(mockShellService.getPrimaryIntent.mock.calls.length).toBe(0);
+			expect(mockShellService.parseShellHash.mock.calls.length).toBe(0);
+			expect(kpiModel.getProperty("/1/manifest/sap.card/header/actions")).toStrictEqual([
+				{
+					type: "Navigation",
+					parameters: {
+						semanticObject: "SemObject",
+						action: "theAction"
+					}
+				}
+			]);
+		});
+	});
+
+	it("doesn't build navigation info from a semantic object and an action not available in the Shell", () => {
+		const kpiDefinition: KPIDefinition = {
+			id: "1",
+			entitySet: "unused",
+			datapoint: {
+				annotationPath: "unused",
+				propertyPath: "kpiProperty"
+			},
+			chart: {
+				chartType: "Line",
+				dimensions: [],
+				measures: []
+			},
+			navigation: {
+				semanticObject: "SemObject",
+				action: "theAction"
+			}
+		};
+
+		mockShellService.getLinks.mockReturnValue(Promise.resolve([]));
+
+		return kpiExtension.initNavigationInfoPublic(kpiDefinition, kpiModel, mockShellService).then(() => {
+			expect(mockShellService.getLinks.mock.calls.length).toBe(1);
+			expect(mockShellService.getLinks.mock.calls[0][0]).toStrictEqual({
+				semanticObject: "SemObject",
+				action: "theAction"
+			});
+			expect(mockShellService.getPrimaryIntent.mock.calls.length).toBe(0);
+			expect(mockShellService.parseShellHash.mock.calls.length).toBe(0);
+			expect(kpiModel.getProperty("/1/manifest/sap.card/header/actions")).toBeUndefined();
+		});
+	});
+
+	it("builds navigation info from a semantic object only (primary intent)", () => {
+		const kpiDefinition: KPIDefinition = {
+			id: "1",
+			entitySet: "unused",
+			datapoint: {
+				annotationPath: "unused",
+				propertyPath: "kpiProperty"
+			},
+			chart: {
+				chartType: "Line",
+				dimensions: [],
+				measures: []
+			},
+			navigation: {
+				semanticObject: "SemObject"
+			}
+		};
+
+		mockShellService.getPrimaryIntent.mockReturnValue(Promise.resolve({ intent: "/SemObject-primaryAction" }));
+		mockShellService.parseShellHash.mockReturnValue({ semanticObject: "SemObject", action: "primaryAction" });
+
+		return kpiExtension.initNavigationInfoPublic(kpiDefinition, kpiModel, mockShellService).then(() => {
+			expect(mockShellService.getPrimaryIntent.mock.calls.length).toBe(1);
+			expect(mockShellService.getPrimaryIntent.mock.calls[0][0]).toBe("SemObject");
+			expect(mockShellService.parseShellHash.mock.calls.length).toBe(1);
+			expect(mockShellService.parseShellHash.mock.calls[0][0]).toBe("/SemObject-primaryAction");
+
+			expect(kpiModel.getProperty("/1/manifest/sap.card/header/actions")).toStrictEqual([
+				{
+					type: "Navigation",
+					parameters: {
+						semanticObject: "SemObject",
+						action: "primaryAction"
+					}
+				}
+			]);
+		});
+	});
+
+	it("doesn't build navigation info from a semantic object only if it has no primary intent", () => {
+		const kpiDefinition: KPIDefinition = {
+			id: "1",
+			entitySet: "unused",
+			datapoint: {
+				annotationPath: "unused",
+				propertyPath: "kpiProperty"
+			},
+			chart: {
+				chartType: "Line",
+				dimensions: [],
+				measures: []
+			},
+			navigation: {
+				semanticObject: "SemObject"
+			}
+		};
+
+		mockShellService.getPrimaryIntent.mockReturnValue(Promise.resolve());
+
+		return kpiExtension.initNavigationInfoPublic(kpiDefinition, kpiModel, mockShellService).then(() => {
+			expect(mockShellService.getPrimaryIntent.mock.calls.length).toBe(1);
+			expect(mockShellService.getPrimaryIntent.mock.calls[0][0]).toBe("SemObject");
+			expect(mockShellService.parseShellHash.mock.calls.length).toBe(0);
+			expect(kpiModel.getProperty("/1/manifest/sap.card/header/actions")).toBeUndefined();
+		});
+	});
+
+	it("doesn't build navigation info from a semantic object only if the primary intent is unavailable", () => {
+		const kpiDefinition: KPIDefinition = {
+			id: "1",
+			entitySet: "unused",
+			datapoint: {
+				annotationPath: "unused",
+				propertyPath: "kpiProperty"
+			},
+			chart: {
+				chartType: "Line",
+				dimensions: [],
+				measures: []
+			},
+			navigation: {
+				semanticObject: "SemObject",
+				unavailableActions: ["action1", "primaryAction"]
+			}
+		};
+
+		mockShellService.getPrimaryIntent.mockReturnValue(Promise.resolve({ intent: "/SemObject-primaryAction" }));
+		mockShellService.parseShellHash.mockReturnValue({ semanticObject: "SemObject", action: "primaryAction" });
+
+		return kpiExtension.initNavigationInfoPublic(kpiDefinition, kpiModel, mockShellService).then(() => {
+			expect(mockShellService.getPrimaryIntent.mock.calls.length).toBe(1);
+			expect(mockShellService.getPrimaryIntent.mock.calls[0][0]).toBe("SemObject");
+			expect(mockShellService.parseShellHash.mock.calls.length).toBe(1);
+			expect(mockShellService.parseShellHash.mock.calls[0][0]).toBe("/SemObject-primaryAction");
+			expect(kpiModel.getProperty("/1/manifest/sap.card/header/actions")).toBeUndefined();
+		});
+	});
+
+	it("builds navigation info from the manifest (outbound)", () => {
+		const kpiDefinition: KPIDefinition = {
+			id: "1",
+			entitySet: "unused",
+			datapoint: {
+				annotationPath: "unused",
+				propertyPath: "kpiProperty"
+			},
+			chart: {
+				chartType: "Line",
+				dimensions: [],
+				measures: []
+			},
+			navigation: {
+				outboundNavigation: "outboundNav"
+			}
+		};
+
+		return kpiExtension.initNavigationInfoPublic(kpiDefinition, kpiModel, mockShellService).then(() => {
+			expect(kpiModel.getProperty("/1/manifest/sap.card/header/actions")).toStrictEqual([
+				{
+					type: "Navigation",
+					parameters: {
+						outbound: "outboundNav"
+					}
+				}
+			]);
+		});
+	});
+});
+
 describe("KPIManagement - #loadKPITagData (query creation)", function() {
 	beforeAll(async function() {
 		kpiExtension = new KPIManagementForTest();

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

@@ -2,9 +2,11 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2021 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/core/controllerextensions/MessageHandler", "sap/fe/core/actions/messageHandling"], function (MessageHandler, messageHandling) {
+sap.ui.define(["sap/fe/core/controllerextensions/MessageHandler", "sap/fe/core/actions/messageHandling", "console", "sap/fe/core/CommonUtils"], function (MessageHandler, messageHandling, console, CommonUtils) {
   "use strict";
 
+  var error = console.error;
+
   function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
   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); }
@@ -13,7 +15,7 @@ sap.ui.define(["sap/fe/core/controllerextensions/MessageHandler", "sap/fe/core/a
 
   function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
 
   function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
@@ -23,34 +25,47 @@ sap.ui.define(["sap/fe/core/controllerextensions/MessageHandler", "sap/fe/core/a
 
   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 TestableMessageHandler = /*#__PURE__*/function (_MessageHandler) {
-    _inherits(TestableMessageHandler, _MessageHandler);
+  describe("ShowMessages and ShowMessagesInDialog", function () {
+    var TestableMessageHandler = /*#__PURE__*/function (_MessageHandler) {
+      _inherits(TestableMessageHandler, _MessageHandler);
 
-    var _super = _createSuper(TestableMessageHandler);
+      var _super = _createSuper(TestableMessageHandler);
 
-    function TestableMessageHandler() {
-      var _this;
+      function TestableMessageHandler() {
+        var _this;
 
-      _classCallCheck(this, TestableMessageHandler);
+        _classCallCheck(this, TestableMessageHandler);
 
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        _this = _super.call.apply(_super, [this].concat(args));
+
+        _defineProperty(_assertThisInitialized(_this), "getShowBoundMessagesInMessageDialog", jest.fn());
 
-      _this = _super.call.apply(_super, [this].concat(args));
+        _defineProperty(_assertThisInitialized(_this), "_checkNavigationToMessagePage", jest.fn());
 
-      _defineProperty(_assertThisInitialized(_this), "getShowBoundMessagesInMessageDialog", jest.fn());
+        _defineProperty(_assertThisInitialized(_this), "removeTransitionMessages", jest.fn());
 
-      return _this;
-    }
+        _defineProperty(_assertThisInitialized(_this), "_getSecondsBeforeRetryAfter", jest.fn());
 
-    return TestableMessageHandler;
-  }(MessageHandler);
+        return _this;
+      }
+
+      return TestableMessageHandler;
+    }(MessageHandler);
 
-  describe("showMessageDialog", function () {
+    var oMockAppComponent = {
+      _isFclEnabled: jest.fn()
+    };
     var oMockGetShowBoundMessagesInMessageDialog;
     var oMockShowUnboundMessages;
     var MessageHandlerExt = new TestableMessageHandler();
+    var oCheckFclEnabled; // let oMockGetMessages: any;
+    // let oMockIsSticky: any;
+    // let oMockGetSecondsBeforeRetryAfter: any;
+
     beforeAll(function () {
       MessageHandlerExt.base = {
         getView: function () {
@@ -63,59 +78,216 @@ sap.ui.define(["sap/fe/core/controllerextensions/MessageHandler", "sap/fe/core/a
               };
             }
           };
+        },
+        _routing: {
+          navigateToMessagePage: jest.fn()
         }
       };
       oMockGetShowBoundMessagesInMessageDialog = jest.spyOn(MessageHandlerExt, "getShowBoundMessagesInMessageDialog");
       oMockGetShowBoundMessagesInMessageDialog.mockReturnValue(true);
       oMockShowUnboundMessages = jest.spyOn(messageHandling, "showUnboundMessages");
+      oCheckFclEnabled = jest.spyOn(CommonUtils, "getAppComponent"); // oMockGetMessages = jest.spyOn(messageHandling, "getMessages");
     });
-    beforeEach(function () {
-      oMockGetShowBoundMessagesInMessageDialog.mockReset();
-      oMockShowUnboundMessages.mockReset();
+    afterEach(function () {
+      jest.resetAllMocks();
     });
-    it("ensures that basic flow of showMessageDialog is correct", function () {
-      try {
-        oMockShowUnboundMessages.mockImplementationOnce(function () {
-          return Promise.resolve(true);
-        });
-        return Promise.resolve(MessageHandlerExt.showMessageDialog()).then(function (bResponse) {
-          expect(bResponse).toEqual(true); // check that getShowBoundMessagesInMessageDialog is called before showUnboundMessages
-
-          expect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(oMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]); // check that getShowBoundMessagesInDialog is only called once
-
-          expect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1); // check that showUnboundMessages is only called once
-
-          expect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);
-        });
-      } catch (e) {
-        return Promise.reject(e);
-      }
+    describe("showMessageDialog", function () {
+      it("ensures that basic flow of showMessageDialog is correct", function () {
+        try {
+          oMockShowUnboundMessages.mockImplementationOnce(function () {
+            return Promise.resolve(true);
+          });
+          return Promise.resolve(MessageHandlerExt.showMessageDialog()).then(function (bResponse) {
+            expect(bResponse).toEqual(true); // check that getShowBoundMessagesInMessageDialog is called before showUnboundMessages
+
+            expect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(oMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]); // check that getShowBoundMessagesInDialog is only called once
+
+            expect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1); // check that showUnboundMessages is only called once
+
+            expect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("rejects the promise if promise returned by messageHandling.showUnboundMessages is rejected", function () {
+        try {
+          oMockShowUnboundMessages.mockImplementationOnce(function () {
+            return Promise.reject(function () {
+              throw error;
+            });
+          });
+          return Promise.resolve(expect(MessageHandlerExt.showMessageDialog()).rejects.toThrowError()).then(function () {
+            expect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(oMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]);
+            expect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1);
+            expect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("resolves the promise if promise returned by messageHandling.showUnboundMessages is resolved", function () {
+        try {
+          oMockShowUnboundMessages.mockImplementationOnce(function () {
+            return Promise.resolve("Resolved");
+          });
+          return Promise.resolve(expect(MessageHandlerExt.showMessageDialog()).resolves.toEqual("Resolved")).then(function () {
+            expect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(oMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]);
+            expect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1);
+            expect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("resolves with true when messageHandling.showUnboundMessages resolve with true", function () {
+        try {
+          oMockShowUnboundMessages.mockImplementationOnce(function () {
+            return Promise.resolve(true);
+          });
+          return Promise.resolve(expect(MessageHandlerExt.showMessageDialog()).resolves.toBe(true)).then(function () {});
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }); // test('returns a promise when there are messages to be shown ', () => {
+      //     //expect(false).toBeFalsy();
+      // });
     });
-    it("resolves with true when messageHandling.showUnboundMessages resolve with true", function () {
-      try {
-        oMockShowUnboundMessages.mockImplementationOnce(function () {
-          return Promise.resolve(true);
-        });
-        return Promise.resolve(MessageHandlerExt.showMessageDialog()).then(function (bResponse) {
-          expect(bResponse).toEqual(true);
-        });
-      } catch (e) {
-        return Promise.reject(e);
-      }
+    describe("showMessages", function () {
+      beforeEach(function () {
+        oCheckFclEnabled.mockReturnValue(oMockAppComponent);
+
+        oMockAppComponent._isFclEnabled.mockReturnValue(false);
+      });
+      it("ensures that basic flow of showMessages (dialog)", function () {
+        try {
+          oMockShowUnboundMessages.mockImplementationOnce(function () {
+            return Promise.resolve(true);
+          });
+          return Promise.resolve(MessageHandlerExt.showMessages()).then(function (bResponse) {
+            expect(bResponse).toEqual(true);
+            expect(MessageHandlerExt._checkNavigationToMessagePage).toBeCalledTimes(1);
+            expect(MessageHandlerExt._checkNavigationToMessagePage.mock.invocationCallOrder[0]).toBeLessThan(oMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]);
+            expect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(oMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]); // check that getShowBoundMessagesInDialog is only called once
+
+            expect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1); // check that showUnboundMessages is only called once
+
+            expect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);
+            expect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);
+            expect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("rejects the promise of showMessages (dialog) if showUnboundMessages throws error", function () {
+        try {
+          oMockShowUnboundMessages.mockImplementationOnce(function () {
+            return Promise.reject(function () {
+              throw error;
+            });
+          });
+          return Promise.resolve(expect(MessageHandlerExt.showMessages()).rejects.toThrowError()).then(function () {
+            expect(MessageHandlerExt._checkNavigationToMessagePage).toBeCalledTimes(1);
+            expect(MessageHandlerExt._checkNavigationToMessagePage.mock.invocationCallOrder[0]).toBeLessThan(oMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]);
+            expect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(oMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]); // check that getShowBoundMessagesInDialog is only called once
+
+            expect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1); // check that showUnboundMessages is only called once
+
+            expect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);
+            expect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("ensures the basic flow of showMessages (page)", function () {
+        try {
+          MessageHandlerExt.base._routing.navigateToMessagePage.mockImplementationOnce(function () {
+            try {
+              return Promise.resolve(true);
+            } catch (e) {
+              return Promise.reject(e);
+            }
+          });
+
+          MessageHandlerExt._checkNavigationToMessagePage.mockReturnValueOnce({
+            handleShellBack: false
+          });
+
+          return Promise.resolve(MessageHandlerExt.showMessages()).then(function (bResponse) {
+            expect(bResponse).toEqual(true);
+            expect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);
+            expect(MessageHandlerExt.base._routing.navigateToMessagePage).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("rejects the promise of showMessages (page) if navigateToMessagePage throws error", function () {
+        try {
+          MessageHandlerExt.base._routing.navigateToMessagePage.mockImplementationOnce(function () {
+            try {
+              return Promise.reject(function () {
+                throw error;
+              });
+            } catch (e) {
+              return Promise.reject(e);
+            }
+          });
+
+          MessageHandlerExt._checkNavigationToMessagePage.mockReturnValueOnce({
+            handleShellBack: false
+          });
+
+          return Promise.resolve(expect(MessageHandlerExt.showMessages()).rejects.toThrowError()).then(function () {
+            expect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);
+            expect(MessageHandlerExt.base._routing.navigateToMessagePage).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("resolves the promise of showMessages (page) if navigateToMessagePage resolves", function () {
+        try {
+          MessageHandlerExt.base._routing.navigateToMessagePage.mockImplementationOnce(function () {
+            try {
+              return Promise.resolve(function () {
+                return true;
+              });
+            } catch (e) {
+              return Promise.reject(e);
+            }
+          });
+
+          MessageHandlerExt._checkNavigationToMessagePage.mockReturnValueOnce({
+            handleShellBack: false
+          });
+
+          return Promise.resolve(expect(MessageHandlerExt.showMessages()).resolves.toBeTruthy()).then(function () {
+            expect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);
+            expect(MessageHandlerExt.base._routing.navigateToMessagePage).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("Does not check navigation to error page if it is an FCL enabled App", function () {
+        try {
+          oMockAppComponent._isFclEnabled.mockReturnValue(true);
+
+          oMockShowUnboundMessages.mockImplementationOnce(function () {
+            return Promise.resolve(true);
+          });
+          return Promise.resolve(MessageHandlerExt.showMessages()).then(function (bResponse) {
+            expect(bResponse).toEqual(true);
+            expect(MessageHandlerExt._checkNavigationToMessagePage).toBeCalledTimes(0);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
     });
-    /*it('returns a promise incase showUnboundMessage throws an error')
-       test('returns a promise when there are messages to be shown ', () => {
-           expect(false).toBeFalsy();
-       });
-        it ('calls getShowBoundMessagesInMessageDialog once', () => {
-           expect(false).toBeFalsy();
-        });    
-        it ('resolves the promise if promise returned by messageHandling.getUnboundMessages is resolved', () => {
-           expect(false).toBeFalsy();
-        });
-        it ('rejects the promise if promise returned by messageHandling.getUnboundMessages is rejected', () => {
-           expect(false).toBeFalsy();
-        });  */
   });
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["MessageHandler.spec.ts"],"names":["describe","TestableMessageHandler","jest","fn","MessageHandler","oMockAppComponent","_isFclEnabled","oMockGetShowBoundMessagesInMessageDialog","oMockShowUnboundMessages","MessageHandlerExt","oCheckFclEnabled","beforeAll","base","getView","getBindingContext","setProperty","_routing","navigateToMessagePage","spyOn","mockReturnValue","messageHandling","CommonUtils","afterEach","resetAllMocks","it","mockImplementationOnce","Promise","resolve","showMessageDialog","bResponse","expect","toEqual","mock","invocationCallOrder","toBeGreaterThan","toHaveBeenCalledTimes","reject","error","rejects","toThrowError","resolves","toBe","beforeEach","showMessages","_checkNavigationToMessagePage","toBeCalledTimes","toBeLessThan","mockReturnValueOnce","handleShellBack","toBeTruthy"],"mappings":"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","sourceRoot":".","sourcesContent":["import { MessageHandler } from \"sap/fe/core/controllerextensions\";\nimport { messageHandling } from \"sap/fe/core/actions\";\nimport { error } from \"console\";\nimport { CommonUtils } from \"sap/fe/core\";\n\ndescribe(\"ShowMessages and ShowMessagesInDialog\", () => {\n\tclass TestableMessageHandler extends MessageHandler {\n\t\tgetShowBoundMessagesInMessageDialog = jest.fn();\n\t\t_checkNavigationToMessagePage = jest.fn();\n\t\tremoveTransitionMessages = jest.fn();\n\t\t_getSecondsBeforeRetryAfter = jest.fn();\n\t}\n\tlet oMockAppComponent = {\n\t\t_isFclEnabled: jest.fn()\n\t};\n\tlet oMockGetShowBoundMessagesInMessageDialog: any;\n\tlet oMockShowUnboundMessages: any;\n\tlet MessageHandlerExt = new TestableMessageHandler();\n\tlet oCheckFclEnabled: any;\n\t// let oMockGetMessages: any;\n\t// let oMockIsSticky: any;\n\t// let oMockGetSecondsBeforeRetryAfter: any;\n\n\tbeforeAll(() => {\n\t\t(MessageHandlerExt as any).base = {\n\t\t\tgetView: () => {\n\t\t\t\treturn {\n\t\t\t\t\tgetBindingContext: () => {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tsetProperty: () => {\n\t\t\t\t\t\t\t\treturn true;\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};\n\t\t\t},\n\t\t\t_routing: {\n\t\t\t\tnavigateToMessagePage: jest.fn()\n\t\t\t}\n\t\t};\n\t\toMockGetShowBoundMessagesInMessageDialog = jest.spyOn(MessageHandlerExt, \"getShowBoundMessagesInMessageDialog\");\n\t\toMockGetShowBoundMessagesInMessageDialog.mockReturnValue(true);\n\n\t\toMockShowUnboundMessages = jest.spyOn(messageHandling, \"showUnboundMessages\");\n\t\toCheckFclEnabled = jest.spyOn(CommonUtils, \"getAppComponent\");\n\t\t// oMockGetMessages = jest.spyOn(messageHandling, \"getMessages\");\n\t});\n\n\tafterEach(() => {\n\t\tjest.resetAllMocks();\n\t});\n\n\tdescribe(\"showMessageDialog\", () => {\n\t\tit(\"ensures that basic flow of showMessageDialog is correct\", async () => {\n\t\t\toMockShowUnboundMessages.mockImplementationOnce(() => {\n\t\t\t\treturn Promise.resolve(true);\n\t\t\t});\n\t\t\tconst bResponse = await MessageHandlerExt.showMessageDialog();\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\t// check that getShowBoundMessagesInMessageDialog is called before showUnboundMessages\n\t\t\texpect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(\n\t\t\t\toMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]\n\t\t\t);\n\t\t\t// check that getShowBoundMessagesInDialog is only called once\n\t\t\texpect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1);\n\t\t\t// check that showUnboundMessages is only called once\n\t\t\texpect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);\n\t\t});\n\n\t\tit(\"rejects the promise if promise returned by messageHandling.showUnboundMessages is rejected\", async () => {\n\t\t\toMockShowUnboundMessages.mockImplementationOnce(() => {\n\t\t\t\treturn Promise.reject(() => {\n\t\t\t\t\tthrow error;\n\t\t\t\t});\n\t\t\t});\n\t\t\tawait expect(MessageHandlerExt.showMessageDialog()).rejects.toThrowError();\n\t\t\texpect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(\n\t\t\t\toMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]\n\t\t\t);\n\t\t\texpect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1);\n\t\t\texpect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);\n\t\t});\n\n\t\tit(\"resolves the promise if promise returned by messageHandling.showUnboundMessages is resolved\", async () => {\n\t\t\toMockShowUnboundMessages.mockImplementationOnce(() => {\n\t\t\t\treturn Promise.resolve(\"Resolved\");\n\t\t\t});\n\t\t\tawait expect(MessageHandlerExt.showMessageDialog()).resolves.toEqual(\"Resolved\");\n\t\t\texpect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(\n\t\t\t\toMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]\n\t\t\t);\n\t\t\texpect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1);\n\t\t\texpect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);\n\t\t});\n\n\t\tit(\"resolves with true when messageHandling.showUnboundMessages resolve with true\", async () => {\n\t\t\toMockShowUnboundMessages.mockImplementationOnce(() => {\n\t\t\t\treturn Promise.resolve(true);\n\t\t\t});\n\n\t\t\tawait expect(MessageHandlerExt.showMessageDialog()).resolves.toBe(true);\n\t\t});\n\t\t// test('returns a promise when there are messages to be shown ', () => {\n\t\t//     //expect(false).toBeFalsy();\n\t\t// });\n\t});\n\n\tdescribe(\"showMessages\", () => {\n\t\tbeforeEach(() => {\n\t\t\toCheckFclEnabled.mockReturnValue(oMockAppComponent);\n\t\t\toMockAppComponent._isFclEnabled.mockReturnValue(false);\n\t\t});\n\n\t\tit(\"ensures that basic flow of showMessages (dialog)\", async () => {\n\t\t\toMockShowUnboundMessages.mockImplementationOnce(() => {\n\t\t\t\treturn Promise.resolve(true);\n\t\t\t});\n\t\t\tconst bResponse = await MessageHandlerExt.showMessages();\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage).toBeCalledTimes(1);\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage.mock.invocationCallOrder[0]).toBeLessThan(\n\t\t\t\toMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]\n\t\t\t);\n\t\t\texpect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(\n\t\t\t\toMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]\n\t\t\t);\n\t\t\t// check that getShowBoundMessagesInDialog is only called once\n\t\t\texpect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1);\n\t\t\t// check that showUnboundMessages is only called once\n\t\t\texpect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);\n\t\t});\n\n\t\tit(\"rejects the promise of showMessages (dialog) if showUnboundMessages throws error\", async () => {\n\t\t\toMockShowUnboundMessages.mockImplementationOnce(() => {\n\t\t\t\treturn Promise.reject(() => {\n\t\t\t\t\tthrow error;\n\t\t\t\t});\n\t\t\t});\n\t\t\tawait expect(MessageHandlerExt.showMessages()).rejects.toThrowError();\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage).toBeCalledTimes(1);\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage.mock.invocationCallOrder[0]).toBeLessThan(\n\t\t\t\toMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]\n\t\t\t);\n\t\t\texpect(oMockShowUnboundMessages.mock.invocationCallOrder[0]).toBeGreaterThan(\n\t\t\t\toMockGetShowBoundMessagesInMessageDialog.mock.invocationCallOrder[0]\n\t\t\t);\n\t\t\t// check that getShowBoundMessagesInDialog is only called once\n\t\t\texpect(oMockGetShowBoundMessagesInMessageDialog).toHaveBeenCalledTimes(1);\n\t\t\t// check that showUnboundMessages is only called once\n\t\t\texpect(oMockShowUnboundMessages).toHaveBeenCalledTimes(1);\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);\n\t\t});\n\n\t\tit(\"ensures the basic flow of showMessages (page)\", async () => {\n\t\t\t(MessageHandlerExt as any).base._routing.navigateToMessagePage.mockImplementationOnce(async () => {\n\t\t\t\treturn Promise.resolve(true);\n\t\t\t});\n\t\t\tMessageHandlerExt._checkNavigationToMessagePage.mockReturnValueOnce({ handleShellBack: false });\n\t\t\tconst bResponse = await MessageHandlerExt.showMessages();\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);\n\t\t\texpect((MessageHandlerExt as any).base._routing.navigateToMessagePage).toHaveBeenCalledTimes(1);\n\t\t});\n\n\t\tit(\"rejects the promise of showMessages (page) if navigateToMessagePage throws error\", async () => {\n\t\t\t(MessageHandlerExt as any).base._routing.navigateToMessagePage.mockImplementationOnce(async () => {\n\t\t\t\treturn Promise.reject(() => {\n\t\t\t\t\tthrow error;\n\t\t\t\t});\n\t\t\t});\n\t\t\tMessageHandlerExt._checkNavigationToMessagePage.mockReturnValueOnce({ handleShellBack: false });\n\t\t\tawait expect(MessageHandlerExt.showMessages()).rejects.toThrowError();\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);\n\t\t\texpect((MessageHandlerExt as any).base._routing.navigateToMessagePage).toHaveBeenCalledTimes(1);\n\t\t});\n\n\t\tit(\"resolves the promise of showMessages (page) if navigateToMessagePage resolves\", async () => {\n\t\t\t(MessageHandlerExt as any).base._routing.navigateToMessagePage.mockImplementationOnce(async () => {\n\t\t\t\treturn Promise.resolve(() => {\n\t\t\t\t\treturn true;\n\t\t\t\t});\n\t\t\t});\n\t\t\tMessageHandlerExt._checkNavigationToMessagePage.mockReturnValueOnce({ handleShellBack: false });\n\t\t\tawait expect(MessageHandlerExt.showMessages()).resolves.toBeTruthy();\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage).toHaveBeenCalledTimes(1);\n\t\t\texpect((MessageHandlerExt as any).base._routing.navigateToMessagePage).toHaveBeenCalledTimes(1);\n\t\t});\n\n\t\tit(\"Does not check navigation to error page if it is an FCL enabled App\", async () => {\n\t\t\toMockAppComponent._isFclEnabled.mockReturnValue(true);\n\t\t\toMockShowUnboundMessages.mockImplementationOnce(() => {\n\t\t\t\treturn Promise.resolve(true);\n\t\t\t});\n\t\t\tconst bResponse = await MessageHandlerExt.showMessages();\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(MessageHandlerExt._checkNavigationToMessagePage).toBeCalledTimes(0);\n\t\t});\n\t});\n});\n"]}