@sap/open.fe 1.98.0 → 1.99.0

package/packages/sap.fe.core/test/sap/fe/core/jest/actions/messageHandling.spec.js

@@ -0,0 +1,492 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/ui/core/library", "sap/fe/core/actions/messageHandling", "sap/m/MessageToast", "sap/m/MessageBox", "sap/ui/core/format/DateFormat"], function (library, MessageHandling, MessageToast, MessageBox, DateFormat) {
+  "use strict";
+
+  var MessageType = library.MessageType;
+  describe("Message handling tests", function () {
+    //function to return the Message Manager Stub
+    function getMessageManager(aMessages) {
+      var MessageStub = {
+        removeMessages: jest.fn(),
+        addMessages: jest.fn(),
+        getMessageModel: jest.fn().mockReturnValue({
+          getObject: jest.fn().mockReturnValue(aMessages),
+          bindList: jest.fn().mockReturnValue({
+            getCurrentContexts: jest.fn().mockReturnValue([])
+          })
+        }),
+        registerMessageProcessor: jest.fn()
+      };
+      return MessageStub;
+    }
+
+    var oMockMessage = {
+      getTechnicalDetails: jest.fn(),
+      technicalDetails: {
+        originalMessage: {
+          message: "<503 error message>"
+        }
+      },
+      setMessage: jest.fn().mockImplementation(function (sMsg) {
+        oMockMessage.technicalDetails.originalMessage.message = sMsg;
+      }),
+      getMessage: jest.fn().mockImplementation(function () {
+        return oMockMessage.technicalDetails.originalMessage.message;
+      })
+    };
+    afterEach(function () {
+      try {
+        jest.restoreAllMocks();
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    test("removeBoundTransistionMessages()- shall remove the Bound Transistion Messages - ", function () {
+      //PREPARE
+      var Message = [{
+        type: MessageType.Success,
+        message: "Message __field1",
+        description: "__field1",
+        subtitle: "Example of subtitle",
+        code: 200,
+        technical: false,
+        persistent: true,
+        validation: true,
+        target: "/musicApp"
+      }];
+      var MessageStub = getMessageManager(Message);
+      var oUICore = sap.ui.getCore();
+      var fGetMessageManager = jest.spyOn(oUICore, "getMessageManager");
+      fGetMessageManager.mockImplementation(function () {
+        return MessageStub;
+      }); //INVOKE METHOD
+
+      MessageHandling.removeBoundTransitionMessages(); //CHECK - RemoveMessage Stub is being called
+
+      expect(MessageStub.removeMessages).toHaveBeenCalledWith(Message);
+      expect(MessageStub.removeMessages).toHaveBeenCalledTimes(1);
+      fGetMessageManager.mockRestore();
+    });
+    test("removeUnBoundTransistionMessages() -  shall remove the Unbound Transistion Messages - ", function () {
+      //PREPARE
+      var Message = [{
+        type: MessageType.Success,
+        code: 200,
+        message: "Message __field1",
+        description: "__field1",
+        subtitle: "Example of subtitle",
+        technical: false,
+        persistent: true,
+        validation: true,
+        target: ""
+      }];
+      var MessageStub = getMessageManager(Message);
+      var oUICore = sap.ui.getCore();
+      var fGetMessageManager = jest.spyOn(oUICore, "getMessageManager");
+      fGetMessageManager.mockImplementation(function () {
+        return MessageStub;
+      }); //INVOKE METHOD
+
+      MessageHandling.removeUnboundTransitionMessages(); //CHECK - RemoveMessage Stub is being called
+
+      expect(MessageStub.removeMessages).toHaveBeenCalledWith(Message);
+      expect(MessageStub.removeMessages).toHaveBeenCalledTimes(1);
+      fGetMessageManager.mockRestore();
+    });
+    test("showUnboundMessages() - shall resolve the promise if there is no message in the Message Manager", function () {
+      //INVOKE METHOD - Message Manager is empty
+      var promise = MessageHandling.showUnboundMessages(); //CHECK
+
+      promise.then(function (temp) {
+        expect(temp).toEqual(true); // "promise is resolved and dialog is not opened");
+      });
+      return promise;
+    });
+    test("showUnboundMessages() - shall resolve the promise if Message Type is Success", function () {
+      var Message = [{
+        type: MessageType.Success,
+        code: 200,
+        message: "Message __field1",
+        description: "__field1",
+        subtitle: "Example of subtitle",
+        technical: false,
+        persistent: true,
+        validation: true,
+        getType: function () {
+          return "Success";
+        },
+        getCode: function () {
+          return "200";
+        },
+        target: ""
+      }];
+      var MessageStub = getMessageManager(Message),
+          MessageToastStub = jest.spyOn(MessageToast, "show").mockReturnValue();
+      var oUICore = sap.ui.getCore();
+      var fGetMessageManager = jest.spyOn(oUICore, "getMessageManager");
+      fGetMessageManager.mockImplementation(function () {
+        return MessageStub;
+      }); //INVOKE METHOD
+
+      MessageHandling.showUnboundMessages(); //CHECK - RemoveMessage Stub is being called
+
+      expect(MessageToastStub).toHaveBeenCalledTimes(1);
+      expect(MessageStub.removeMessages).toHaveBeenCalledTimes(1);
+      MessageToastStub.mockRestore();
+      fGetMessageManager.mockRestore();
+    });
+    test("fnModifyETagMessagesOnly() - shall return : true, if any e-Tag message is modified, otherwise false", function () {
+      ///PREPARE
+      var sETagMessage = "Your changes could not be saved. Refresh the data to work with the most recent version.";
+      var oResourceBundle = {
+        getText: jest.fn().mockReturnValue(sETagMessage)
+      };
+      var oGetLibraryResourceBundleSpy = jest.spyOn(sap.ui.getCore(), "getLibraryResourceBundle").mockReturnValue(oResourceBundle);
+      var aMessage = [{
+        type: MessageType.Error,
+        code: null,
+        message: "Precondition failed",
+        description: "__field1",
+        subtitle: "Example of subtitle",
+        technical: true,
+        persistent: true,
+        validation: false,
+        target: "",
+        technicalDetails: {
+          httpStatus: 412,
+          isConcurrentModification: true,
+          originalMessage: {
+            code: null,
+            message: "Precondition failed"
+          }
+        },
+        getTechnicalDetails: function () {
+          return this.technicalDetails;
+        },
+        setMessage: function (sMessage) {
+          this.message = sMessage;
+        }
+      }, {
+        type: MessageType.Error,
+        code: null,
+        message: "Sample Error Message",
+        description: "__field2",
+        subtitle: "Example of subtitle",
+        technical: true,
+        persistent: true,
+        validation: false,
+        target: "",
+        technicalDetails: {
+          httpStatus: 404,
+          isConcurrentModification: true,
+          originalMessage: {
+            code: null,
+            message: "Sample Error Message"
+          }
+        },
+        getTechnicalDetails: function () {
+          return this.technicalDetails;
+        },
+        setMessage: function (sMessage) {
+          this.message = sMessage;
+        }
+      }];
+      var oMessageStub = getMessageManager(aMessage);
+      var oUICore = sap.ui.getCore();
+      var fGetMessageManager = jest.spyOn(oUICore, "getMessageManager");
+      fGetMessageManager.mockImplementation(function () {
+        return oMessageStub;
+      }); //INVOKE METHOD
+
+      MessageHandling.modifyETagMessagesOnly(oUICore.getMessageManager(), oResourceBundle); //CHECK
+
+      expect(sap.ui.getCore().getMessageManager().getMessageModel().getObject("/")[0].message).toEqual(sETagMessage); //"e-Tag message is modified."
+
+      expect(sap.ui.getCore().getMessageManager().getMessageModel().getObject("/")[1].message).not.toEqual(sETagMessage); //"message is not modified."
+
+      fGetMessageManager.mockRestore();
+      oGetLibraryResourceBundleSpy.mockRestore();
+    });
+    test("getRetryAfter execution in showUnboundMessages", function () {
+      try {
+        var oMessageBoxErrorMock, oGetMessagesMock;
+        oGetMessagesMock = jest.fn();
+        oGetMessagesMock.mockImplementation(function () {
+          return [{
+            getCode: function () {
+              return "503";
+            },
+            getMessage: function () {
+              return "Delete service is not available";
+            },
+            getType: function () {
+              return "Error";
+            },
+            getTechnicalDetails: function () {
+              return {
+                httpStatus: 503,
+                retryAfter: false
+              };
+            },
+            technicalDetails: {
+              originalMessage: {
+                message: "Delete service is not available"
+              }
+            }
+          }];
+        });
+        MessageHandling.getMessages = oGetMessagesMock;
+        oMessageBoxErrorMock = jest.spyOn(MessageBox, "error");
+        oMessageBoxErrorMock.mockReturnValue();
+        MessageHandling.showUnboundMessages([], {}, true, false);
+        expect(oMessageBoxErrorMock).toHaveBeenCalledTimes(1);
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    test("getRetryAfter execution in showUnboundMessages with technicalDetails as null", function () {
+      try {
+        var oMessageBoxErrorMock, oGetMessagesMock;
+        oGetMessagesMock = jest.spyOn(MessageHandling, "getMessages");
+        oGetMessagesMock.mockImplementation(function () {
+          return [{
+            getCode: function () {
+              return "503";
+            },
+            getMessage: function () {
+              return "Delete service is not available";
+            },
+            getType: function () {
+              return "Error";
+            },
+            getTechnicalDetails: function () {
+              return {
+                httpStatus: 503,
+                retryAfter: false
+              };
+            },
+            technicalDetails: null
+          }];
+        });
+        oMessageBoxErrorMock = jest.spyOn(MessageBox, "error");
+        oMessageBoxErrorMock.mockReturnValue();
+        MessageHandling.showUnboundMessages([], {}, true, false);
+        expect(oMessageBoxErrorMock).toHaveBeenCalledTimes(0);
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    test("showUnboundMessages with empty array", function () {
+      try {
+        var oMessageBoxErrorMock, oGetMessagesMock;
+        oGetMessagesMock = jest.spyOn(MessageHandling, "getMessages");
+        oGetMessagesMock.mockImplementation(function () {
+          return [];
+        });
+        var oBindListMock = jest.spyOn(sap.ui.getCore().getMessageManager().getMessageModel(), "bindList");
+        oBindListMock.mockImplementation(function () {
+          return {
+            getCurrentContexts: function () {
+              return [{
+                getObject: function () {
+                  return {
+                    technicalDetails: {
+                      originalMessage: {
+                        message: "Delete service is not available"
+                      }
+                    }
+                  };
+                }
+              }, {
+                getObject: function () {
+                  return {
+                    technicalDetails: null
+                  };
+                }
+              }];
+            }
+          };
+        });
+        oMessageBoxErrorMock = jest.spyOn(MessageBox, "error");
+        oMessageBoxErrorMock.mockReturnValue();
+        MessageHandling.showUnboundMessages([], {}, false, false);
+        expect(oMessageBoxErrorMock).toHaveBeenCalledTimes(0);
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }); // QUnit.test('showUnboundMessages() - shall resolve the promise once Message Dialog is opened if Message Type is Success', function (assert) {
+    // 	var fDone = assert.async();
+    // 	//PREPARE - Add Error Message to Message Manager
+    // 	var Message = [{
+    // 		type: MessageType.Error,
+    //		code: 404,
+    // 		message: 'Message __field1',
+    // 		description: '__field1',
+    // 		subtitle: 'Example of subtitle',
+    // 		technical: false,
+    // 		persistent: true,
+    // 		validation: true,
+    // 		getType: function () {
+    // 			return "Error";
+    // 		},
+    // 		target: ''
+    // 	}];
+    // 	//Message Manager stub
+    // 	var MessageStub = getMessageManager(Message);
+    // 	var oUICore = sap.ui.getCore(),
+    // 		fGetMessageManager = oUICore.getMessageManager;
+    // 	oUICore.getMessageManager = sinon.stub().returns(MessageStub);
+    // 	//Stubbing the MessageView
+    // 	var oMessageViewStub = {
+    // 		setModel: sinon.stub(),
+    // 		destroy: sinon.stub(),
+    // 		close: sinon.stub()
+    // 	};
+    // 	var fnGetMessageViewControl = UI5ControlFactory.getMessageView;
+    // 	UI5ControlFactory.getMessageView = function () {
+    // 		return oMessageViewStub;
+    // 	};
+    // 	//Stubbing the oDialog
+    // 	var dialogArgs;
+    // 	var oDialogStub = {
+    // 		open: function () {
+    // 			assert.ok(true, "UI5ControlFactory.getDialogControl");
+    // 			assert.ok(typeof dialogArgs.afterClose === "function", "afterClose property in the configuration passed as function");
+    // 			if (dialogArgs && dialogArgs.afterClose) {
+    // 				dialogArgs.afterClose();
+    // 			}
+    // 		},
+    // 		destroy: sinon.stub(),
+    // 		close: sinon.stub()
+    // 	};
+    // 	var fnGetDialogControl = UI5ControlFactory.getDialogControl;
+    // 	UI5ControlFactory.getDialogControl = function (args) {
+    // 		dialogArgs = args;
+    // 		return oDialogStub;
+    // 	};
+    // 	//INVOKE
+    // 	var oPromise = MessageHandling.showUnboundMessages();
+    // 	//CHECK
+    // 	oPromise.then(function () {
+    // 		assert.ok(true, "Promise successfully resolved on calling afterClose");
+    // 		UI5ControlFactory.getDialogControl = fnGetDialogControl;
+    // 		UI5ControlFactory.getMessageView = fnGetMessageViewControl;
+    // 		fDone();
+    // 	});
+    // });
+  });
+  describe("getRetryAfter", function () {
+    var oMockMessage = {
+      getTechnicalDetails: jest.fn()
+    };
+    test("for different year", function () {
+      try {
+        var dRetryAfter = new Date();
+        dRetryAfter.setFullYear(dRetryAfter.getFullYear() + 1);
+        oMockMessage.getTechnicalDetails.mockReturnValueOnce({
+          httpStatus: 503,
+          originalMessage: {
+            "@Common.numericSeverity": 4,
+            code: "503"
+          },
+          retryAfter: dRetryAfter
+        });
+        var oResourceBundle = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core");
+        var sMessage = oResourceBundle.getText("C_MESSAGE_HANDLING_SAPFE_503_ERROR", [DateFormat.getDateTimeInstance({
+          pattern: "MMMM dd, yyyy 'at' hh:mm a"
+        }).format(dRetryAfter)]);
+        expect(MessageHandling.getRetryAfterMessage(oMockMessage)).toBe(sMessage);
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    test("for different day", function () {
+      try {
+        var dRetryAfter = new Date();
+        dRetryAfter.setDate(dRetryAfter.getDate() + 1);
+        oMockMessage.getTechnicalDetails.mockReturnValueOnce({
+          httpStatus: 503,
+          originalMessage: {
+            "@Common.numericSeverity": 4,
+            code: "503"
+          },
+          retryAfter: dRetryAfter
+        });
+        var oResourceBundle = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core");
+        var sMessage = oResourceBundle.getText("C_MESSAGE_HANDLING_SAPFE_503_ERROR", [DateFormat.getDateTimeInstance({
+          pattern: "MMMM dd 'at' hh:mm a"
+        }).format(dRetryAfter)]);
+        console.log(sMessage);
+        expect(MessageHandling.getRetryAfterMessage(oMockMessage)).toBe(sMessage);
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }); // Doesn't build after 23h :P
+
+    test("for same day", function () {
+      try {
+        var dRetryAfter = new Date();
+        dRetryAfter.setHours(dRetryAfter.getHours() + 1);
+        oMockMessage.getTechnicalDetails.mockReturnValueOnce({
+          httpStatus: 503,
+          originalMessage: {
+            "@Common.numericSeverity": 4,
+            code: "503"
+          },
+          retryAfter: dRetryAfter
+        });
+        var oResourceBundle = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core");
+        var sMessage = oResourceBundle.getText("C_MESSAGE_HANDLING_SAPFE_503_ERROR_DAY", [DateFormat.getDateTimeInstance({
+          pattern: "hh:mm a"
+        }).format(dRetryAfter)]);
+        console.log(sMessage);
+        expect(MessageHandling.getRetryAfterMessage(oMockMessage)).toBe(sMessage);
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    test("no retry after", function () {
+      try {
+        oMockMessage.getTechnicalDetails.mockReturnValueOnce({
+          httpStatus: 503,
+          originalMessage: {
+            "@Common.numericSeverity": 4,
+            code: "503"
+          }
+        });
+        var oResourceBundle = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core");
+        var sMessage = oResourceBundle.getText("C_MESSAGE_HANDLING_SAPFE_503_ERROR_NO_RETRY_AFTER");
+        expect(MessageHandling.getRetryAfterMessage(oMockMessage)).toBe(sMessage);
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    test("Error code is not 503", function () {
+      try {
+        oMockMessage.getTechnicalDetails.mockReturnValueOnce({
+          httpStatus: 404,
+          originalMessage: {
+            "@Common.numericSeverity": 4,
+            code: "404"
+          }
+        });
+        expect(MessageHandling.getRetryAfterMessage(oMockMessage)).toBeUndefined();
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["messageHandling.spec.ts"],"names":["MessageType","library","describe","getMessageManager","aMessages","MessageStub","removeMessages","jest","fn","addMessages","getMessageModel","mockReturnValue","getObject","bindList","getCurrentContexts","registerMessageProcessor","oMockMessage","getTechnicalDetails","technicalDetails","originalMessage","message","setMessage","mockImplementation","sMsg","getMessage","afterEach","restoreAllMocks","test","Message","type","Success","description","subtitle","code","technical","persistent","validation","target","oUICore","sap","ui","getCore","fGetMessageManager","spyOn","MessageHandling","removeBoundTransitionMessages","expect","toHaveBeenCalledWith","toHaveBeenCalledTimes","mockRestore","removeUnboundTransitionMessages","promise","showUnboundMessages","then","temp","toEqual","getType","getCode","MessageToastStub","MessageToast","sETagMessage","oResourceBundle","getText","oGetLibraryResourceBundleSpy","aMessage","Error","httpStatus","isConcurrentModification","sMessage","oMessageStub","modifyETagMessagesOnly","not","oMessageBoxErrorMock","oGetMessagesMock","retryAfter","getMessages","MessageBox","oBindListMock","dRetryAfter","Date","setFullYear","getFullYear","mockReturnValueOnce","getLibraryResourceBundle","DateFormat","getDateTimeInstance","pattern","format","getRetryAfterMessage","toBe","setDate","getDate","console","log","setHours","getHours","toBeUndefined"],"mappings":"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","sourceRoot":".","sourcesContent":["import library from \"sap/ui/core/library\";\nimport ResourceBundle from \"sap/base/i18n/ResourceBundle\";\nimport MessageHandling from \"sap/fe/core/actions/messageHandling\";\nimport MessageToast from \"sap/m/MessageToast\";\nimport MessageBox from \"sap/m/MessageBox\";\nimport DateFormat from \"sap/ui/core/format/DateFormat\";\n\nconst MessageType = library.MessageType;\n\ndescribe(\"Message handling tests\", () => {\n\t//function to return the Message Manager Stub\n\tfunction getMessageManager(aMessages: any[]) {\n\t\tconst MessageStub = {\n\t\t\tremoveMessages: jest.fn(),\n\t\t\taddMessages: jest.fn(),\n\t\t\tgetMessageModel: jest.fn().mockReturnValue({\n\t\t\t\tgetObject: jest.fn().mockReturnValue(aMessages),\n\t\t\t\tbindList: jest.fn().mockReturnValue({\n\t\t\t\t\tgetCurrentContexts: jest.fn().mockReturnValue([])\n\t\t\t\t})\n\t\t\t}),\n\t\t\tregisterMessageProcessor: jest.fn()\n\t\t};\n\t\treturn MessageStub;\n\t}\n\tlet oMockMessage: any = {\n\t\tgetTechnicalDetails: jest.fn(),\n\t\ttechnicalDetails: {\n\t\t\toriginalMessage: {\n\t\t\t\tmessage: \"<503 error message>\"\n\t\t\t}\n\t\t},\n\t\tsetMessage: jest.fn().mockImplementation(sMsg => {\n\t\t\toMockMessage.technicalDetails.originalMessage.message = sMsg;\n\t\t}),\n\t\tgetMessage: jest.fn().mockImplementation(() => {\n\t\t\treturn oMockMessage.technicalDetails.originalMessage.message;\n\t\t})\n\t};\n\tafterEach(async function() {\n\t\tjest.restoreAllMocks();\n\t});\n\n\ttest(\"removeBoundTransistionMessages()- shall remove the Bound Transistion Messages - \", function() {\n\t\t//PREPARE\n\t\tconst Message = [\n\t\t\t{\n\t\t\t\ttype: MessageType.Success,\n\t\t\t\tmessage: \"Message __field1\",\n\t\t\t\tdescription: \"__field1\",\n\t\t\t\tsubtitle: \"Example of subtitle\",\n\t\t\t\tcode: 200,\n\t\t\t\ttechnical: false,\n\t\t\t\tpersistent: true,\n\t\t\t\tvalidation: true,\n\t\t\t\ttarget: \"/musicApp\"\n\t\t\t}\n\t\t];\n\t\tconst MessageStub = getMessageManager(Message);\n\n\t\tconst oUICore = sap.ui.getCore();\n\t\tconst fGetMessageManager = jest.spyOn(oUICore, \"getMessageManager\");\n\t\tfGetMessageManager.mockImplementation(() => {\n\t\t\treturn MessageStub;\n\t\t});\n\n\t\t//INVOKE METHOD\n\t\tMessageHandling.removeBoundTransitionMessages();\n\n\t\t//CHECK - RemoveMessage Stub is being called\n\t\texpect(MessageStub.removeMessages).toHaveBeenCalledWith(Message);\n\t\texpect(MessageStub.removeMessages).toHaveBeenCalledTimes(1);\n\t\tfGetMessageManager.mockRestore();\n\t});\n\n\ttest(\"removeUnBoundTransistionMessages() -  shall remove the Unbound Transistion Messages - \", function() {\n\t\t//PREPARE\n\t\tconst Message = [\n\t\t\t{\n\t\t\t\ttype: MessageType.Success,\n\t\t\t\tcode: 200,\n\t\t\t\tmessage: \"Message __field1\",\n\t\t\t\tdescription: \"__field1\",\n\t\t\t\tsubtitle: \"Example of subtitle\",\n\t\t\t\ttechnical: false,\n\t\t\t\tpersistent: true,\n\t\t\t\tvalidation: true,\n\t\t\t\ttarget: \"\"\n\t\t\t}\n\t\t];\n\t\tconst MessageStub = getMessageManager(Message);\n\n\t\tconst oUICore = sap.ui.getCore();\n\t\tconst fGetMessageManager = jest.spyOn(oUICore, \"getMessageManager\");\n\t\tfGetMessageManager.mockImplementation(() => {\n\t\t\treturn MessageStub;\n\t\t});\n\n\t\t//INVOKE METHOD\n\t\tMessageHandling.removeUnboundTransitionMessages();\n\n\t\t//CHECK - RemoveMessage Stub is being called\n\t\texpect(MessageStub.removeMessages).toHaveBeenCalledWith(Message);\n\t\texpect(MessageStub.removeMessages).toHaveBeenCalledTimes(1);\n\t\tfGetMessageManager.mockRestore();\n\t});\n\n\ttest(\"showUnboundMessages() - shall resolve the promise if there is no message in the Message Manager\", function() {\n\t\t//INVOKE METHOD - Message Manager is empty\n\t\tconst promise = MessageHandling.showUnboundMessages();\n\n\t\t//CHECK\n\t\tpromise.then(function(temp) {\n\t\t\texpect(temp).toEqual(true); // \"promise is resolved and dialog is not opened\");\n\t\t});\n\t\treturn promise;\n\t});\n\n\ttest(\"showUnboundMessages() - shall resolve the promise if Message Type is Success\", function() {\n\t\tconst Message = [\n\t\t\t{\n\t\t\t\ttype: MessageType.Success,\n\t\t\t\tcode: 200,\n\t\t\t\tmessage: \"Message __field1\",\n\t\t\t\tdescription: \"__field1\",\n\t\t\t\tsubtitle: \"Example of subtitle\",\n\t\t\t\ttechnical: false,\n\t\t\t\tpersistent: true,\n\t\t\t\tvalidation: true,\n\t\t\t\tgetType: function() {\n\t\t\t\t\treturn \"Success\";\n\t\t\t\t},\n\t\t\t\tgetCode: function() {\n\t\t\t\t\treturn \"200\";\n\t\t\t\t},\n\t\t\t\ttarget: \"\"\n\t\t\t}\n\t\t];\n\t\tconst MessageStub = getMessageManager(Message),\n\t\t\tMessageToastStub = jest.spyOn(MessageToast, \"show\").mockReturnValue();\n\n\t\tconst oUICore = sap.ui.getCore();\n\t\tconst fGetMessageManager = jest.spyOn(oUICore, \"getMessageManager\");\n\t\tfGetMessageManager.mockImplementation(() => {\n\t\t\treturn MessageStub;\n\t\t});\n\n\t\t//INVOKE METHOD\n\t\tMessageHandling.showUnboundMessages();\n\n\t\t//CHECK - RemoveMessage Stub is being called\n\t\texpect(MessageToastStub).toHaveBeenCalledTimes(1);\n\t\texpect(MessageStub.removeMessages).toHaveBeenCalledTimes(1);\n\t\tMessageToastStub.mockRestore();\n\t\tfGetMessageManager.mockRestore();\n\t});\n\n\ttest(\"fnModifyETagMessagesOnly() - shall return : true, if any e-Tag message is modified, otherwise false\", function() {\n\t\t///PREPARE\n\t\tconst sETagMessage = \"Your changes could not be saved. Refresh the data to work with the most recent version.\";\n\t\tconst oResourceBundle: any = {\n\t\t\tgetText: jest.fn().mockReturnValue(sETagMessage)\n\t\t};\n\t\tconst oGetLibraryResourceBundleSpy = jest.spyOn(sap.ui.getCore(), \"getLibraryResourceBundle\").mockReturnValue(oResourceBundle);\n\n\t\tconst aMessage = [\n\t\t\t{\n\t\t\t\ttype: MessageType.Error,\n\t\t\t\tcode: null,\n\t\t\t\tmessage: \"Precondition failed\",\n\t\t\t\tdescription: \"__field1\",\n\t\t\t\tsubtitle: \"Example of subtitle\",\n\t\t\t\ttechnical: true,\n\t\t\t\tpersistent: true,\n\t\t\t\tvalidation: false,\n\t\t\t\ttarget: \"\",\n\t\t\t\ttechnicalDetails: {\n\t\t\t\t\thttpStatus: 412,\n\t\t\t\t\tisConcurrentModification: true,\n\t\t\t\t\toriginalMessage: {\n\t\t\t\t\t\tcode: null,\n\t\t\t\t\t\tmessage: \"Precondition failed\"\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tgetTechnicalDetails: function() {\n\t\t\t\t\treturn this.technicalDetails;\n\t\t\t\t},\n\t\t\t\tsetMessage: function(sMessage: string) {\n\t\t\t\t\tthis.message = sMessage;\n\t\t\t\t}\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: MessageType.Error,\n\t\t\t\tcode: null,\n\t\t\t\tmessage: \"Sample Error Message\",\n\t\t\t\tdescription: \"__field2\",\n\t\t\t\tsubtitle: \"Example of subtitle\",\n\t\t\t\ttechnical: true,\n\t\t\t\tpersistent: true,\n\t\t\t\tvalidation: false,\n\t\t\t\ttarget: \"\",\n\t\t\t\ttechnicalDetails: {\n\t\t\t\t\thttpStatus: 404,\n\t\t\t\t\tisConcurrentModification: true,\n\t\t\t\t\toriginalMessage: {\n\t\t\t\t\t\tcode: null,\n\t\t\t\t\t\tmessage: \"Sample Error Message\"\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tgetTechnicalDetails: function() {\n\t\t\t\t\treturn this.technicalDetails;\n\t\t\t\t},\n\t\t\t\tsetMessage: function(sMessage: string) {\n\t\t\t\t\tthis.message = sMessage;\n\t\t\t\t}\n\t\t\t}\n\t\t];\n\n\t\tconst oMessageStub = getMessageManager(aMessage);\n\n\t\tconst oUICore = sap.ui.getCore();\n\t\tconst fGetMessageManager = jest.spyOn(oUICore, \"getMessageManager\");\n\t\tfGetMessageManager.mockImplementation(() => {\n\t\t\treturn oMessageStub;\n\t\t});\n\n\t\t//INVOKE METHOD\n\t\tMessageHandling.modifyETagMessagesOnly(oUICore.getMessageManager(), oResourceBundle);\n\n\t\t//CHECK\n\t\texpect(\n\t\t\tsap.ui\n\t\t\t\t.getCore()\n\t\t\t\t.getMessageManager()\n\t\t\t\t.getMessageModel()\n\t\t\t\t.getObject(\"/\")[0].message\n\t\t).toEqual(sETagMessage);\n\t\t//\"e-Tag message is modified.\"\n\t\texpect(\n\t\t\tsap.ui\n\t\t\t\t.getCore()\n\t\t\t\t.getMessageManager()\n\t\t\t\t.getMessageModel()\n\t\t\t\t.getObject(\"/\")[1].message\n\t\t).not.toEqual(sETagMessage); //\"message is not modified.\"\n\t\tfGetMessageManager.mockRestore();\n\t\toGetLibraryResourceBundleSpy.mockRestore();\n\t});\n\ttest(\"getRetryAfter execution in showUnboundMessages\", async () => {\n\t\tlet oMessageBoxErrorMock, oGetMessagesMock;\n\t\toGetMessagesMock = jest.fn();\n\t\toGetMessagesMock.mockImplementation(() => {\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\tgetCode: function() {\n\t\t\t\t\t\treturn \"503\";\n\t\t\t\t\t},\n\t\t\t\t\tgetMessage: function() {\n\t\t\t\t\t\treturn \"Delete service is not available\";\n\t\t\t\t\t},\n\t\t\t\t\tgetType: function() {\n\t\t\t\t\t\treturn \"Error\";\n\t\t\t\t\t},\n\t\t\t\t\tgetTechnicalDetails: function() {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\thttpStatus: 503,\n\t\t\t\t\t\t\tretryAfter: false\n\t\t\t\t\t\t};\n\t\t\t\t\t},\n\t\t\t\t\ttechnicalDetails: {\n\t\t\t\t\t\toriginalMessage: {\n\t\t\t\t\t\t\tmessage: \"Delete service is not available\"\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});\n\t\t(MessageHandling as any).getMessages = oGetMessagesMock;\n\t\toMessageBoxErrorMock = jest.spyOn(MessageBox, \"error\");\n\t\toMessageBoxErrorMock.mockReturnValue();\n\t\t(MessageHandling as any).showUnboundMessages([], {}, true, false);\n\t\texpect(oMessageBoxErrorMock).toHaveBeenCalledTimes(1);\n\t});\n\ttest(\"getRetryAfter execution in showUnboundMessages with technicalDetails as null\", async () => {\n\t\tlet oMessageBoxErrorMock, oGetMessagesMock;\n\t\toGetMessagesMock = jest.spyOn(MessageHandling, \"getMessages\");\n\t\toGetMessagesMock.mockImplementation(() => {\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\tgetCode: function() {\n\t\t\t\t\t\treturn \"503\";\n\t\t\t\t\t},\n\t\t\t\t\tgetMessage: function() {\n\t\t\t\t\t\treturn \"Delete service is not available\";\n\t\t\t\t\t},\n\t\t\t\t\tgetType: function() {\n\t\t\t\t\t\treturn \"Error\";\n\t\t\t\t\t},\n\t\t\t\t\tgetTechnicalDetails: function() {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\thttpStatus: 503,\n\t\t\t\t\t\t\tretryAfter: false\n\t\t\t\t\t\t};\n\t\t\t\t\t},\n\t\t\t\t\ttechnicalDetails: null\n\t\t\t\t}\n\t\t\t];\n\t\t});\n\t\toMessageBoxErrorMock = jest.spyOn(MessageBox, \"error\");\n\t\toMessageBoxErrorMock.mockReturnValue();\n\t\t(MessageHandling as any).showUnboundMessages([], {}, true, false);\n\t\texpect(oMessageBoxErrorMock).toHaveBeenCalledTimes(0);\n\t});\n\ttest(\"showUnboundMessages with empty array\", async () => {\n\t\tlet oMessageBoxErrorMock, oGetMessagesMock;\n\t\toGetMessagesMock = jest.spyOn(MessageHandling, \"getMessages\");\n\t\toGetMessagesMock.mockImplementation(() => {\n\t\t\treturn [];\n\t\t});\n\t\tlet oBindListMock = jest.spyOn((sap.ui.getCore() as any).getMessageManager().getMessageModel(), \"bindList\");\n\t\toBindListMock.mockImplementation(() => {\n\t\t\treturn {\n\t\t\t\tgetCurrentContexts: function() {\n\t\t\t\t\treturn [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tgetObject: function() {\n\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\ttechnicalDetails: {\n\t\t\t\t\t\t\t\t\t\toriginalMessage: {\n\t\t\t\t\t\t\t\t\t\t\tmessage: \"Delete service is not available\"\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t},\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tgetObject: function() {\n\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\ttechnicalDetails: null\n\t\t\t\t\t\t\t\t};\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});\n\t\toMessageBoxErrorMock = jest.spyOn(MessageBox, \"error\");\n\t\toMessageBoxErrorMock.mockReturnValue();\n\t\t(MessageHandling as any).showUnboundMessages([], {}, false, false);\n\t\texpect(oMessageBoxErrorMock).toHaveBeenCalledTimes(0);\n\t});\n\n\t// QUnit.test('showUnboundMessages() - shall resolve the promise once Message Dialog is opened if Message Type is Success', function (assert) {\n\n\t// \tvar fDone = assert.async();\n\n\t// \t//PREPARE - Add Error Message to Message Manager\n\t// \tvar Message = [{\n\t// \t\ttype: MessageType.Error,\n\t//\t\tcode: 404,\n\t// \t\tmessage: 'Message __field1',\n\t// \t\tdescription: '__field1',\n\t// \t\tsubtitle: 'Example of subtitle',\n\t// \t\ttechnical: false,\n\t// \t\tpersistent: true,\n\t// \t\tvalidation: true,\n\t// \t\tgetType: function () {\n\t// \t\t\treturn \"Error\";\n\t// \t\t},\n\t// \t\ttarget: ''\n\t// \t}];\n\n\t// \t//Message Manager stub\n\t// \tvar MessageStub = getMessageManager(Message);\n\t// \tvar oUICore = sap.ui.getCore(),\n\t// \t\tfGetMessageManager = oUICore.getMessageManager;\n\t// \toUICore.getMessageManager = sinon.stub().returns(MessageStub);\n\n\t// \t//Stubbing the MessageView\n\t// \tvar oMessageViewStub = {\n\t// \t\tsetModel: sinon.stub(),\n\t// \t\tdestroy: sinon.stub(),\n\t// \t\tclose: sinon.stub()\n\t// \t};\n\n\t// \tvar fnGetMessageViewControl = UI5ControlFactory.getMessageView;\n\t// \tUI5ControlFactory.getMessageView = function () {\n\t// \t\treturn oMessageViewStub;\n\t// \t};\n\n\t// \t//Stubbing the oDialog\n\t// \tvar dialogArgs;\n\t// \tvar oDialogStub = {\n\t// \t\topen: function () {\n\t// \t\t\tassert.ok(true, \"UI5ControlFactory.getDialogControl\");\n\t// \t\t\tassert.ok(typeof dialogArgs.afterClose === \"function\", \"afterClose property in the configuration passed as function\");\n\t// \t\t\tif (dialogArgs && dialogArgs.afterClose) {\n\t// \t\t\t\tdialogArgs.afterClose();\n\t// \t\t\t}\n\t// \t\t},\n\t// \t\tdestroy: sinon.stub(),\n\t// \t\tclose: sinon.stub()\n\t// \t};\n\n\t// \tvar fnGetDialogControl = UI5ControlFactory.getDialogControl;\n\t// \tUI5ControlFactory.getDialogControl = function (args) {\n\t// \t\tdialogArgs = args;\n\t// \t\treturn oDialogStub;\n\t// \t};\n\t// \t//INVOKE\n\t// \tvar oPromise = MessageHandling.showUnboundMessages();\n\n\t// \t//CHECK\n\t// \toPromise.then(function () {\n\t// \t\tassert.ok(true, \"Promise successfully resolved on calling afterClose\");\n\t// \t\tUI5ControlFactory.getDialogControl = fnGetDialogControl;\n\t// \t\tUI5ControlFactory.getMessageView = fnGetMessageViewControl;\n\t// \t\tfDone();\n\t// \t});\n\t// });\n});\ndescribe(\"getRetryAfter\", () => {\n\tconst oMockMessage = {\n\t\tgetTechnicalDetails: jest.fn()\n\t};\n\n\ttest(\"for different year\", async () => {\n\t\tconst dRetryAfter = new Date();\n\t\tdRetryAfter.setFullYear(dRetryAfter.getFullYear() + 1);\n\n\t\toMockMessage.getTechnicalDetails.mockReturnValueOnce({\n\t\t\thttpStatus: 503,\n\t\t\toriginalMessage: {\n\t\t\t\t\"@Common.numericSeverity\": 4,\n\t\t\t\tcode: \"503\"\n\t\t\t},\n\t\t\tretryAfter: dRetryAfter\n\t\t});\n\t\tconst oResourceBundle = sap.ui.getCore().getLibraryResourceBundle(\"sap.fe.core\") as ResourceBundle;\n\t\tconst sMessage = oResourceBundle.getText(\"C_MESSAGE_HANDLING_SAPFE_503_ERROR\", [\n\t\t\tDateFormat.getDateTimeInstance({ pattern: \"MMMM dd, yyyy 'at' hh:mm a\" }).format(dRetryAfter)\n\t\t]);\n\t\texpect((MessageHandling as any).getRetryAfterMessage(oMockMessage)).toBe(sMessage);\n\t});\n\n\ttest(\"for different day\", async () => {\n\t\tconst dRetryAfter = new Date();\n\t\tdRetryAfter.setDate(dRetryAfter.getDate() + 1);\n\n\t\toMockMessage.getTechnicalDetails.mockReturnValueOnce({\n\t\t\thttpStatus: 503,\n\t\t\toriginalMessage: {\n\t\t\t\t\"@Common.numericSeverity\": 4,\n\t\t\t\tcode: \"503\"\n\t\t\t},\n\t\t\tretryAfter: dRetryAfter\n\t\t});\n\t\tconst oResourceBundle = sap.ui.getCore().getLibraryResourceBundle(\"sap.fe.core\") as ResourceBundle;\n\t\tconst sMessage = oResourceBundle.getText(\"C_MESSAGE_HANDLING_SAPFE_503_ERROR\", [\n\t\t\tDateFormat.getDateTimeInstance({ pattern: \"MMMM dd 'at' hh:mm a\" }).format(dRetryAfter)\n\t\t]);\n\t\tconsole.log(sMessage);\n\t\texpect((MessageHandling as any).getRetryAfterMessage(oMockMessage)).toBe(sMessage);\n\t});\n\n\t// Doesn't build after 23h :P\n\ttest(\"for same day\", async () => {\n\t\tconst dRetryAfter = new Date();\n\t\tdRetryAfter.setHours(dRetryAfter.getHours() + 1);\n\t\toMockMessage.getTechnicalDetails.mockReturnValueOnce({\n\t\t\thttpStatus: 503,\n\t\t\toriginalMessage: {\n\t\t\t\t\"@Common.numericSeverity\": 4,\n\t\t\t\tcode: \"503\"\n\t\t\t},\n\t\t\tretryAfter: dRetryAfter\n\t\t});\n\t\tconst oResourceBundle = sap.ui.getCore().getLibraryResourceBundle(\"sap.fe.core\") as ResourceBundle;\n\t\tconst sMessage = oResourceBundle.getText(\"C_MESSAGE_HANDLING_SAPFE_503_ERROR_DAY\", [\n\t\t\tDateFormat.getDateTimeInstance({ pattern: \"hh:mm a\" }).format(dRetryAfter)\n\t\t]);\n\t\tconsole.log(sMessage);\n\t\texpect((MessageHandling as any).getRetryAfterMessage(oMockMessage)).toBe(sMessage);\n\t});\n\n\ttest(\"no retry after\", async () => {\n\t\toMockMessage.getTechnicalDetails.mockReturnValueOnce({\n\t\t\thttpStatus: 503,\n\t\t\toriginalMessage: {\n\t\t\t\t\"@Common.numericSeverity\": 4,\n\t\t\t\tcode: \"503\"\n\t\t\t}\n\t\t});\n\t\tconst oResourceBundle = sap.ui.getCore().getLibraryResourceBundle(\"sap.fe.core\") as ResourceBundle;\n\t\tconst sMessage = oResourceBundle.getText(\"C_MESSAGE_HANDLING_SAPFE_503_ERROR_NO_RETRY_AFTER\");\n\t\texpect((MessageHandling as any).getRetryAfterMessage(oMockMessage)).toBe(sMessage);\n\t});\n\n\ttest(\"Error code is not 503\", async () => {\n\t\toMockMessage.getTechnicalDetails.mockReturnValueOnce({\n\t\t\thttpStatus: 404,\n\t\t\toriginalMessage: {\n\t\t\t\t\"@Common.numericSeverity\": 4,\n\t\t\t\tcode: \"404\"\n\t\t\t}\n\t\t});\n\t\texpect((MessageHandling as any).getRetryAfterMessage(oMockMessage)).toBeUndefined();\n\t});\n});\n"]}