@sap/open.fe 1.99.0 → 1.100.0

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

@@ -503,6 +503,302 @@ sap.ui.define(["sap/fe/test/UI5MockHelper", "sap/fe/core/controllerextensions/In
         }
       });
     });
+    describe("testing fnDirtyStateProvider()", function () {
+      var oInternalEditFlow, mockHashTracker, spyGetRouterProxy, spyIsNavigationFinalized, spyCheckHashWithGuard, spyIsGuardCrossAllowedByUser, spySetDirtyFlag;
+      var mockoNavigationContext = {
+        innerAppRoute: ""
+      };
+      var mockGetShellServices = {
+        setDirtyFlag: jest.fn().mockReturnValue(undefined)
+      };
+      var mockGetRouterProxy = {
+        isNavigationFinalized: jest.fn(),
+        checkHashWithGuard: jest.fn(),
+        isGuardCrossAllowedByUser: jest.fn()
+      };
+      var mockAppComponent = {
+        getRouterProxy: jest.fn().mockReturnValue(mockGetRouterProxy),
+        getShellServices: jest.fn().mockReturnValue(mockGetShellServices)
+      };
+      var mockInternalModel = {
+        getProperty: jest.fn()
+      };
+      beforeAll(function () {
+        oInternalEditFlow = new InternalEditFlow();
+        spyGetRouterProxy = jest.spyOn(mockAppComponent, "getRouterProxy");
+        spyIsNavigationFinalized = jest.spyOn(mockGetRouterProxy, "isNavigationFinalized");
+        spyCheckHashWithGuard = jest.spyOn(mockGetRouterProxy, "checkHashWithGuard");
+        spyIsGuardCrossAllowedByUser = jest.spyOn(mockGetRouterProxy, "isGuardCrossAllowedByUser");
+        spySetDirtyFlag = jest.spyOn(mockGetShellServices, "setDirtyFlag");
+      });
+      afterEach(function () {
+        jest.clearAllMocks();
+      });
+      it("fnDirtyStateProvider: input paramater oNavigationContext is undefined", oTestReferences, function () {
+        try {
+          mockHashTracker = "abc";
+          mockInternalModel.getProperty.mockReturnValue(undefined);
+
+          var fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(mockAppComponent, mockInternalModel, mockHashTracker);
+
+          return Promise.resolve(fnDirtyStateProvider(undefined)).then(function (bResponse) {
+            expect(bResponse).toEqual(undefined);
+            expect(spyGetRouterProxy).toHaveBeenCalledTimes(0);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("fnDirtyStateProvider: missing property of internalModel", oTestReferences, function () {
+        try {
+          mockHashTracker = "abc";
+          mockInternalModel.getProperty.mockReturnValue(undefined);
+
+          var fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(mockAppComponent, mockInternalModel, mockHashTracker);
+
+          return Promise.resolve(fnDirtyStateProvider(mockoNavigationContext)).then(function (bResponse) {
+            expect(bResponse).toEqual(undefined);
+            expect(spyGetRouterProxy).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("fnDirtyStateProvider: isNavigationFinalized() returns false", oTestReferences, function () {
+        try {
+          mockHashTracker = "abc";
+          mockInternalModel.getProperty.mockReturnValue(true);
+          mockGetRouterProxy.isNavigationFinalized.mockReturnValue(false);
+
+          var fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(mockAppComponent, mockInternalModel, mockHashTracker);
+
+          return Promise.resolve(fnDirtyStateProvider(mockoNavigationContext)).then(function (bResponse) {
+            expect(bResponse).toEqual(false);
+            expect(spyGetRouterProxy).toHaveBeenCalledTimes(1);
+            expect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);
+            expect(spyCheckHashWithGuard).toHaveBeenCalledTimes(0);
+            expect(spySetDirtyFlag).toHaveBeenCalledTimes(0);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("fnDirtyStateProvider: isNavigationFinalized() returns true, HashTracker=TargetHash", oTestReferences, function () {
+        try {
+          mockHashTracker = "abc";
+          mockoNavigationContext.innerAppRoute = "abc";
+          mockInternalModel.getProperty.mockReturnValue(true);
+          mockGetRouterProxy.isNavigationFinalized.mockReturnValue(true);
+
+          var fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(mockAppComponent, mockInternalModel, mockHashTracker);
+
+          return Promise.resolve(fnDirtyStateProvider(mockoNavigationContext)).then(function (bResponse) {
+            expect(bResponse).toEqual(true);
+            expect(spyGetRouterProxy).toHaveBeenCalledTimes(1);
+            expect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);
+            expect(spyCheckHashWithGuard).toHaveBeenCalledTimes(0);
+            expect(spySetDirtyFlag).toHaveBeenCalledTimes(0);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("fnDirtyStateProvider: isNavigationFinalized() returns true, HashTracker<>TargetHash, checkHashWithGuard()=true", oTestReferences, function () {
+        try {
+          mockHashTracker = "abc";
+          mockoNavigationContext.innerAppRoute = "xyz";
+          mockInternalModel.getProperty.mockReturnValue(true);
+          mockGetRouterProxy.isNavigationFinalized.mockReturnValue(true);
+          mockGetRouterProxy.checkHashWithGuard.mockReturnValue(true);
+
+          var fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(mockAppComponent, mockInternalModel, mockHashTracker);
+
+          return Promise.resolve(fnDirtyStateProvider(mockoNavigationContext)).then(function (bResponse) {
+            expect(bResponse).toEqual(false);
+            expect(spyGetRouterProxy).toHaveBeenCalledTimes(1);
+            expect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);
+            expect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);
+            expect(spyIsGuardCrossAllowedByUser).toHaveBeenCalledTimes(0);
+            expect(spySetDirtyFlag).toHaveBeenCalledTimes(0);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("fnDirtyStateProvider: isNavigationFinalized() returns true, HashTracker<>TargetHash, checkHashWithGuard()=false, isGuardCrossAllowedByUser()=true", oTestReferences, function () {
+        try {
+          mockHashTracker = "abc";
+          mockoNavigationContext.innerAppRoute = "xyz";
+          mockInternalModel.getProperty.mockReturnValue(true);
+          mockGetRouterProxy.isNavigationFinalized.mockReturnValue(true);
+          mockGetRouterProxy.checkHashWithGuard.mockReturnValue(false);
+          mockGetRouterProxy.isGuardCrossAllowedByUser.mockReturnValue(true);
+
+          var fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(mockAppComponent, mockInternalModel, mockHashTracker);
+
+          return Promise.resolve(fnDirtyStateProvider(mockoNavigationContext)).then(function (bResponse) {
+            expect(bResponse).toEqual(false);
+            expect(spyGetRouterProxy).toHaveBeenCalledTimes(1);
+            expect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);
+            expect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);
+            expect(spyIsGuardCrossAllowedByUser).toHaveBeenCalledTimes(1);
+            expect(spySetDirtyFlag).toHaveBeenCalledTimes(0);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("fnDirtyStateProvider: isNavigationFinalized() returns true, HashTracker<>TargetHash, checkHashWithGuard()=false, isGuardCrossAllowedByUser()=false", oTestReferences, function () {
+        try {
+          mockHashTracker = "abc";
+          mockoNavigationContext.innerAppRoute = "xyz";
+          mockInternalModel.getProperty.mockReturnValue(true);
+          mockGetRouterProxy.isNavigationFinalized.mockReturnValue(true);
+          mockGetRouterProxy.checkHashWithGuard.mockReturnValue(false);
+          mockGetRouterProxy.isGuardCrossAllowedByUser.mockReturnValue(false);
+
+          var fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(mockAppComponent, mockInternalModel, mockHashTracker);
+
+          return Promise.resolve(fnDirtyStateProvider(mockoNavigationContext)).then(function (bResponse) {
+            expect(bResponse).toEqual(true);
+            expect(spyGetRouterProxy).toHaveBeenCalledTimes(1);
+            expect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);
+            expect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);
+            expect(spyIsGuardCrossAllowedByUser).toHaveBeenCalledTimes(1);
+            expect(spySetDirtyFlag).toHaveBeenCalledTimes(0);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+    describe("testing fnHandleSessionTimeout()", function () {
+      var oInternalEditFlow, spyRemoveTransitionMessages, spyAddDependent;
+      var mockGetRouterProxy = {
+        getHash: jest.fn(),
+        checkHashWithGuard: jest.fn()
+      };
+      var mockAppComponent = {
+        getRouterProxy: jest.fn().mockReturnValue(mockGetRouterProxy)
+      };
+      var mockGetMessageHandler = {
+        removeTransitionMessages: jest.fn().mockReturnValue(false)
+      };
+      var mockGetRoutingListener = {
+        navigateBackFromContext: jest.fn().mockReturnValue(false)
+      };
+      var mockGetView = {
+        addDependent: jest.fn().mockReturnValue(false)
+      };
+      var mockContext = {
+        getMessageHandler: jest.fn().mockReturnValue(mockGetMessageHandler),
+        handleStickyOff: jest.fn(),
+        getRoutingListener: jest.fn().mockReturnValue(mockGetRoutingListener),
+        getView: jest.fn().mockReturnValue(mockGetView)
+      };
+      beforeAll(function () {
+        oInternalEditFlow = new InternalEditFlow();
+        spyRemoveTransitionMessages = jest.spyOn(mockGetMessageHandler, "removeTransitionMessages");
+        spyAddDependent = jest.spyOn(mockGetView, "addDependent");
+      });
+      afterEach(function () {
+        jest.clearAllMocks();
+      });
+      it("fnHandleSessionTimeout: calling with valid input", oTestReferences, function () {
+        try {
+          var fnHandleSessionTimeout = oInternalEditFlow._attachSessionTimeout(mockContext, undefined);
+
+          return Promise.resolve(fnHandleSessionTimeout()).then(function () {
+            expect(spyRemoveTransitionMessages).toHaveBeenCalledTimes(1);
+            expect(spyAddDependent).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("fnHandleSessionTimeout: context is invalid", oTestReferences, function () {
+        try {
+          var fnHandleSessionTimeout = oInternalEditFlow._attachSessionTimeout(undefined, undefined);
+
+          return Promise.resolve(fnHandleSessionTimeout()).then(function (bResponse) {
+            expect(bResponse).toEqual(undefined);
+            expect(spyRemoveTransitionMessages).toHaveBeenCalledTimes(0);
+            expect(spyAddDependent).toHaveBeenCalledTimes(0);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+    describe("testing fnStickyDiscardAfterNavigation()", function () {
+      var oInternalEditFlow, spyGetHash, spyCheckHashWithGuard, spyDiscardStickySession;
+      var mockGetRouterProxy = {
+        getHash: jest.fn(),
+        checkHashWithGuard: jest.fn()
+      };
+      var mockAppComponent = {
+        getRouterProxy: jest.fn().mockReturnValue(mockGetRouterProxy)
+      };
+      var mockFnContext = {
+        discardStickySession: jest.fn().mockReturnValue(false)
+      };
+      beforeAll(function () {
+        oInternalEditFlow = new InternalEditFlow();
+        spyGetHash = jest.spyOn(mockGetRouterProxy, "getHash");
+        spyCheckHashWithGuard = jest.spyOn(mockGetRouterProxy, "checkHashWithGuard");
+        spyDiscardStickySession = jest.spyOn(mockFnContext, "discardStickySession");
+      });
+      afterEach(function () {
+        jest.clearAllMocks();
+      });
+      it("fnStickyDiscardAfterNavigation: Hash undefined", oTestReferences, function () {
+        try {
+          mockGetRouterProxy.getHash.mockReturnValue(undefined);
+
+          var fnStickyDiscardAfterNavigation = oInternalEditFlow._attachRouteMatched(mockFnContext, undefined, mockAppComponent);
+
+          return Promise.resolve(fnStickyDiscardAfterNavigation()).then(function () {
+            expect(spyGetHash).toHaveBeenCalledTimes(1);
+            expect(spyCheckHashWithGuard).toHaveBeenCalledTimes(0);
+            expect(spyDiscardStickySession).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("fnStickyDiscardAfterNavigation: checkHashWithGuard()=false", oTestReferences, function () {
+        try {
+          mockGetRouterProxy.getHash.mockReturnValue("abc");
+          mockGetRouterProxy.checkHashWithGuard.mockReturnValue(false);
+
+          var fnStickyDiscardAfterNavigation = oInternalEditFlow._attachRouteMatched(mockFnContext, undefined, mockAppComponent);
+
+          return Promise.resolve(fnStickyDiscardAfterNavigation()).then(function () {
+            expect(spyGetHash).toHaveBeenCalledTimes(1);
+            expect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);
+            expect(spyDiscardStickySession).toHaveBeenCalledTimes(1);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("fnStickyDiscardAfterNavigation: checkHashWithGuard()=true", oTestReferences, function () {
+        try {
+          mockGetRouterProxy.getHash.mockReturnValue("abc");
+          mockGetRouterProxy.checkHashWithGuard.mockReturnValue(true);
+
+          var fnStickyDiscardAfterNavigation = oInternalEditFlow._attachRouteMatched(mockFnContext, undefined, mockAppComponent);
+
+          return Promise.resolve(fnStickyDiscardAfterNavigation()).then(function () {
+            expect(spyGetHash).toHaveBeenCalledTimes(1);
+            expect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);
+            expect(spyDiscardStickySession).toHaveBeenCalledTimes(0);
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
   });
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["InternalEditFlow.spec.ts"],"names":["body","recover","result","e","then","describe","oTestReferences","afterAll","jest","resetAllMocks","oTransactionHelper","oInternalEditFlow","oGetTransactionHelperMock","oGetGlobalUIModellMock","oGetViewMock","oBusyLockMock","oSyncTaskMock","oHandleCreateEventsMock","oGetMessageHandlerMock","oHasTransientContextMock","oBusyUnlockMock","oOnBeforeCreateMock","oListBinding","oCreateDocumentMock","oMockModel","MockModel","oMockMetaModel","MockMetaModel","oMockContext","MockContext","$path","setMetaModel","beforeEach","InternalEditFlow","TransactionHelper","spyOn","mockImplementation","undefined","getController","oResourceBundle","getBindingContext","BusyLocker","mockReturnValue","mockResolvedValue","CommonUtils","getModel","getContext","getPath","created","afterEach","restoreAllMocks","it","aData","fn","Promise","resolve","createMultipleDocuments","expect","toHaveBeenCalledWith","contextPath","toHaveBeenCalledTimes","reject","spyGetModel","spyGetMetaModel","spyContextGetPath","sCustomAction","mockContext","mockView","mockModel","getMetaModel","mockMetaModel","getObject","beforeAll","clearAllMocks","_hasNewActionForSticky","bResponse","toEqual","NewAction","DiscardAction","EditAction","SaveAction","AdditionalNewActions","spyGetView","spyGetAppComponent","spyGetRouterProxy","spyHasNavigationGuard","spySetNavigationGuard","spyGetHash","spyGetInternalModel","spySetBackNavigation","spyRegisterDirtyStateProvider","spyAttachSessionTimeout","spyAttachRouteMatched","mockGetShellServices","setBackNavigation","registerDirtyStateProvider","mockGetRouterProxy","hasNavigationGuard","setNavigationGuard","getHash","mockGetRoutingService","attachRouteMatched","mockGetAppComponent","getRouterProxy","getShellServices","getRoutingService","mockGetModel","attachSessionTimeout","mockGetView","handleStickyOn","spySetEditMode","spyGetTransactionHelper","spyDiscardNavigationGuard","spyDeregisterDirtyStateProvider","mockDiscardNavigationGuard","discardNavigationGuard","deregisterDirtyStateProvider","detachRouteMatched","mockDetachSessionTimeout","detachSessionTimeout","fnHandleSessionTimeout","fnStickyDiscardAfterNavigation","fnDirtyStateProvider","handleStickyOff"],"mappings":"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","sourceRoot":".","sourcesContent":["import { MockContext, MockMetaModel, MockModel } from \"sap/fe/test/UI5MockHelper\";\n\nimport { InternalEditFlow } from \"sap/fe/core/controllerextensions\";\nimport TransactionHelper from \"sap/fe/core/TransactionHelper\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport BusyLocker from \"sap/fe/core/BusyLocker\";\n\ndescribe(\"InternalEditFlow ControllerExtension\", function() {\n\tconst oTestReferences = {\n\t\t\"references\": [\n\t\t\t{\n\t\t\t\t\"type\": \"JIRA\",\n\t\t\t\t\"ID\": \"FIORITECHP1-22294\"\n\t\t\t}\n\t\t]\n\t};\n\tafterAll(() => {\n\t\tjest.resetAllMocks();\n\t});\n\tdescribe(\"createMultipleDocuments - onBeforeCreate\", () => {\n\t\tlet oTransactionHelper: any, oInternalEditFlow: any;\n\t\tlet oGetTransactionHelperMock,\n\t\t\toGetGlobalUIModellMock,\n\t\t\toGetViewMock,\n\t\t\toBusyLockMock,\n\t\t\toSyncTaskMock,\n\t\t\toHandleCreateEventsMock,\n\t\t\toGetMessageHandlerMock,\n\t\t\toHasTransientContextMock,\n\t\t\toBusyUnlockMock,\n\t\t\toOnBeforeCreateMock,\n\t\t\toListBinding: any,\n\t\t\toCreateDocumentMock: any;\n\t\tlet oMockModel = new MockModel();\n\t\tlet oMockMetaModel = new MockMetaModel();\n\t\tlet oMockContext = new MockContext({ $path: \"SalesOrderItem\" });\n\t\toMockModel.setMetaModel(oMockMetaModel);\n\t\tbeforeEach(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\toTransactionHelper = new TransactionHelper(null, null);\n\t\t\toGetTransactionHelperMock = jest.spyOn(oInternalEditFlow as any, \"getTransactionHelper\");\n\t\t\toGetTransactionHelperMock.mockImplementation(() => {\n\t\t\t\treturn oTransactionHelper;\n\t\t\t});\n\t\t\toGetGlobalUIModellMock = jest.spyOn(oInternalEditFlow as any, \"getGlobalUIModel\");\n\t\t\toGetGlobalUIModellMock.mockImplementation(() => undefined);\n\t\t\toGetViewMock = jest.spyOn(oInternalEditFlow as any, \"getView\");\n\t\t\toGetViewMock.mockImplementation(() => {\n\t\t\t\treturn {\n\t\t\t\t\tgetController: function() {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\toResourceBundle: null\n\t\t\t\t\t\t};\n\t\t\t\t\t},\n\t\t\t\t\tgetBindingContext: function() {\n\t\t\t\t\t\treturn null;\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t});\n\t\t\toBusyLockMock = jest.spyOn(BusyLocker, \"lock\");\n\t\t\toBusyLockMock.mockReturnValue(true);\n\t\t\toBusyUnlockMock = jest.spyOn(BusyLocker, \"unlock\");\n\t\t\toBusyUnlockMock.mockReturnValue(true);\n\t\t\toSyncTaskMock = jest.spyOn(oInternalEditFlow as any, \"syncTask\");\n\t\t\toSyncTaskMock.mockResolvedValue(null);\n\t\t\toHandleCreateEventsMock = jest.spyOn(oInternalEditFlow as any, \"handleCreateEvents\");\n\t\t\toHandleCreateEventsMock.mockReturnValue(true);\n\t\t\toGetMessageHandlerMock = jest.spyOn(oInternalEditFlow as any, \"getMessageHandler\");\n\t\t\toGetMessageHandlerMock.mockReturnValue(true);\n\t\t\toHasTransientContextMock = jest.spyOn(CommonUtils, \"hasTransientContext\");\n\t\t\toHasTransientContextMock.mockReturnValue(true);\n\t\t\toHasTransientContextMock.mockReturnValue(true);\n\t\t\toListBinding = {\n\t\t\t\tgetModel: function() {\n\t\t\t\t\treturn oMockModel;\n\t\t\t\t},\n\t\t\t\tgetContext: function() {\n\t\t\t\t\treturn oMockContext;\n\t\t\t\t},\n\t\t\t\tgetPath: function() {\n\t\t\t\t\treturn \"/SalesOrderItem\";\n\t\t\t\t}\n\t\t\t};\n\t\t\toCreateDocumentMock = jest.spyOn(oTransactionHelper, \"createDocument\");\n\t\t\toCreateDocumentMock.mockResolvedValue({\n\t\t\t\tcreated: function() {\n\t\t\t\t\treturn null;\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t\tafterEach(() => {\n\t\t\tjest.restoreAllMocks();\n\t\t});\n\n\t\tit(\"onBeforeCreate is resolved\", async () => {\n\t\t\tconst aData = [\n\t\t\t\t{\n\t\t\t\t\t\"SalesOrder\": 6437\n\t\t\t\t}\n\t\t\t];\n\n\t\t\toOnBeforeCreateMock = jest.fn(() => {\n\t\t\t\treturn Promise.resolve();\n\t\t\t});\n\t\t\tawait (oInternalEditFlow as any).createMultipleDocuments(oListBinding, aData, true, true, oOnBeforeCreateMock);\n\t\t\texpect(oOnBeforeCreateMock).toHaveBeenCalledWith({ contextPath: oListBinding.getPath() });\n\t\t\texpect(oCreateDocumentMock).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"onBeforeCreate is rejected\", async () => {\n\t\t\tconst aData = [\n\t\t\t\t{\n\t\t\t\t\t\"SalesOrder\": 6437\n\t\t\t\t}\n\t\t\t];\n\n\t\t\toOnBeforeCreateMock = jest.fn(() => {\n\t\t\t\treturn Promise.reject();\n\t\t\t});\n\t\t\ttry {\n\t\t\t\tawait (oInternalEditFlow as any).createMultipleDocuments(oListBinding, aData, true, true, oOnBeforeCreateMock);\n\t\t\t} catch {\n\t\t\t\texpect(oOnBeforeCreateMock).toHaveBeenCalledWith({ contextPath: oListBinding.getPath() });\n\t\t\t\texpect(oCreateDocumentMock).toHaveBeenCalledTimes(0);\n\t\t\t}\n\t\t});\n\t});\n\n\tdescribe(\"testing - _hasNewActionForSticky\", () => {\n\t\tlet oInternalEditFlow: any, spyGetModel: any, spyGetMetaModel: any, spyContextGetPath: any, sCustomAction: string;\n\t\tconst mockContext = {\n\t\t\tgetPath: jest.fn(() => \"\")\n\t\t};\n\t\tconst mockView = {\n\t\t\tgetModel: jest.fn()\n\t\t};\n\t\tconst mockModel = {\n\t\t\tgetMetaModel: jest.fn()\n\t\t};\n\t\tconst mockMetaModel = {\n\t\t\tgetObject: jest.fn()\n\t\t};\n\t\tbeforeAll(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\tmockModel.getMetaModel.mockReturnValue(mockMetaModel);\n\t\t\tmockView.getModel.mockReturnValue(mockModel);\n\t\t\tspyGetModel = jest.spyOn(mockView, \"getModel\");\n\t\t\tspyGetMetaModel = jest.spyOn(mockModel, \"getMetaModel\");\n\t\t\tspyContextGetPath = jest.spyOn(mockContext, \"getPath\");\n\t\t});\n\t\tbeforeEach(() => {});\n\t\tafterEach(() => {\n\t\t\tjest.clearAllMocks();\n\t\t});\n\t\tit(\"_hasNewActionForSticky: invalid input parameters\", oTestReferences, async () => {\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(undefined, undefined);\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyGetModel).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyGetMetaModel).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyContextGetPath).toHaveBeenCalledTimes(0);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: empty input parameters\", oTestReferences, async () => {\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView);\n\t\t\texpect(bResponse).toEqual(false);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: missing context\", oTestReferences, async () => {\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tNewAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView);\n\t\t\texpect(bResponse).toEqual(false);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: missing NewAction/AdditionalNewAction\", oTestReferences, async () => {\n\t\t\tmockContext.getPath.mockReturnValue(\"/SalesQuotationManage('')\");\n\t\t\tsCustomAction = \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\";\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tDiscardAction: \"DiscardChanges\",\n\t\t\t\tEditAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit\",\n\t\t\t\tSaveAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);\n\t\t\texpect(bResponse).toEqual(false);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: NewAction available\", oTestReferences, async () => {\n\t\t\tmockContext.getPath.mockReturnValue(\"/SalesQuotationManage('')\");\n\t\t\tsCustomAction = \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\";\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tDiscardAction: \"DiscardChanges\",\n\t\t\t\tEditAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit\",\n\t\t\t\tSaveAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges\",\n\t\t\t\tNewAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);\n\t\t\texpect(bResponse).toEqual(true);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: AdditionalNewAction available\", oTestReferences, async () => {\n\t\t\tmockContext.getPath.mockReturnValue(\"/SalesQuotationManage('')\");\n\t\t\tsCustomAction = \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\";\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tAdditionalNewActions: [\n\t\t\t\t\t\"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithRefFromSlsInquiry\",\n\t\t\t\t\t\"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\"\n\t\t\t\t],\n\t\t\t\tDiscardAction: \"DiscardChanges\",\n\t\t\t\tEditAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit\",\n\t\t\t\tSaveAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spyGetModel).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetMetaModel).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyContextGetPath).toHaveBeenCalledTimes(2);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: AdditionalNewAction available but not the relevant one\", oTestReferences, async () => {\n\t\t\tmockContext.getPath.mockReturnValue(\"/SalesQuotationManage('')\");\n\t\t\tsCustomAction = \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\";\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tAdditionalNewActions: [\n\t\t\t\t\t\"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithRefFromSlsInquiry\",\n\t\t\t\t\t\"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesOrderType\"\n\t\t\t\t],\n\t\t\t\tDiscardAction: \"DiscardChanges\",\n\t\t\t\tEditAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit\",\n\t\t\t\tSaveAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);\n\t\t\texpect(bResponse).toEqual(false);\n\t\t\texpect(spyGetModel).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetMetaModel).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyContextGetPath).toHaveBeenCalledTimes(2);\n\t\t});\n\t});\n\n\tdescribe(\"testing handleStickyOn()\", () => {\n\t\tlet oInternalEditFlow: any,\n\t\t\tspyGetView: any,\n\t\t\tspyGetAppComponent: any,\n\t\t\tspyGetRouterProxy: any,\n\t\t\tspyHasNavigationGuard: any,\n\t\t\tspySetNavigationGuard: any,\n\t\t\tspyGetHash: any,\n\t\t\tspyGetInternalModel: any,\n\t\t\tspySetBackNavigation: any,\n\t\t\tspyRegisterDirtyStateProvider: any,\n\t\t\tspyGetModel: any,\n\t\t\tspyAttachSessionTimeout: any,\n\t\t\tspyAttachRouteMatched: any;\n\t\tconst mockGetShellServices = {\n\t\t\tsetBackNavigation: jest.fn().mockReturnValue(undefined),\n\t\t\tregisterDirtyStateProvider: jest.fn()\n\t\t};\n\t\tconst mockGetRouterProxy = {\n\t\t\thasNavigationGuard: jest.fn(),\n\t\t\tsetNavigationGuard: jest.fn(),\n\t\t\tgetHash: jest.fn().mockReturnValue(\"\")\n\t\t};\n\t\tconst mockGetRoutingService = {\n\t\t\tattachRouteMatched: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetAppComponent = {\n\t\t\tgetRouterProxy: jest.fn().mockReturnValue(mockGetRouterProxy),\n\t\t\tgetShellServices: jest.fn().mockReturnValue(mockGetShellServices),\n\t\t\tgetRoutingService: jest.fn().mockReturnValue(mockGetRoutingService)\n\t\t};\n\t\tconst mockContext = {};\n\t\tconst mockGetModel = {\n\t\t\tattachSessionTimeout: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetView = {\n\t\t\tgetModel: jest.fn().mockReturnValue(mockGetModel)\n\t\t};\n\t\tbeforeAll(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\tspyGetView = jest.spyOn(oInternalEditFlow, \"getView\");\n\t\t\tspyGetView.mockImplementation(() => mockGetView);\n\t\t\tspyGetModel = jest.spyOn(mockGetView, \"getModel\");\n\t\t\tspyAttachSessionTimeout = jest.spyOn(mockGetModel, \"attachSessionTimeout\");\n\t\t\tspyGetAppComponent = jest.spyOn(CommonUtils, \"getAppComponent\");\n\t\t\tspyGetRouterProxy = jest.spyOn(mockGetAppComponent, \"getRouterProxy\");\n\t\t\tspyHasNavigationGuard = jest.spyOn(mockGetRouterProxy, \"hasNavigationGuard\");\n\t\t\tspySetNavigationGuard = jest.spyOn(mockGetRouterProxy, \"setNavigationGuard\");\n\t\t\tspyGetHash = jest.spyOn(mockGetRouterProxy, \"getHash\");\n\t\t\tspyGetInternalModel = jest.spyOn(oInternalEditFlow, \"getInternalModel\");\n\t\t\tspyGetInternalModel.mockImplementation(() => {\n\t\t\t\treturn {};\n\t\t\t});\n\t\t\tspySetBackNavigation = jest.spyOn(mockGetShellServices, \"setBackNavigation\");\n\t\t\tspyRegisterDirtyStateProvider = jest.spyOn(mockGetShellServices, \"registerDirtyStateProvider\");\n\t\t\tspyAttachRouteMatched = jest.spyOn(mockGetRoutingService, \"attachRouteMatched\");\n\t\t});\n\t\tafterEach(() => {\n\t\t\tjest.clearAllMocks();\n\t\t});\n\t\tit(\"handleStickyOn: input paramater oContext is undefined\", oTestReferences, async () => {\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn undefined;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOn(undefined);\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"handleStickyOn: input paramater oContext is empty\", oTestReferences, async () => {\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn {};\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOn(mockContext);\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"handleStickyOn: check valid input\", oTestReferences, async () => {\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn mockGetAppComponent;\n\t\t\t});\n\t\t\tspyHasNavigationGuard.mockImplementation(() => {\n\t\t\t\treturn false;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOn(mockContext);\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(2);\n\t\t\texpect(spyHasNavigationGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetHash).toHaveBeenCalledTimes(1);\n\t\t\texpect(spySetNavigationGuard).toHaveBeenCalledTimes(0);\n\t\t\texpect(spySetBackNavigation).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyRegisterDirtyStateProvider).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyAttachSessionTimeout).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyAttachRouteMatched).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"handleStickyOn: navigation guard already set\", oTestReferences, async () => {\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn mockGetAppComponent;\n\t\t\t});\n\t\t\tspyHasNavigationGuard.mockImplementation(() => {\n\t\t\t\treturn true;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOn(mockContext);\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyHasNavigationGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetHash).toHaveBeenCalledTimes(0);\n\t\t\texpect(spySetNavigationGuard).toHaveBeenCalledTimes(0);\n\t\t\texpect(spySetBackNavigation).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyRegisterDirtyStateProvider).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyAttachSessionTimeout).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyAttachRouteMatched).toHaveBeenCalledTimes(0);\n\t\t});\n\t});\n\n\tdescribe(\"testing handleStickyOff()\", () => {\n\t\tlet oInternalEditFlow: any,\n\t\t\toTransactionHelper: any,\n\t\t\tspyGetView: any,\n\t\t\tspySetEditMode: any,\n\t\t\tspyGetAppComponent: any,\n\t\t\tspyGetTransactionHelper: any,\n\t\t\tspyDiscardNavigationGuard: any,\n\t\t\tspyDeregisterDirtyStateProvider: any;\n\t\tconst mockGetAppComponent = {\n\t\t\tgetRouterProxy: jest.fn(),\n\t\t\tgetShellServices: jest.fn(),\n\t\t\tgetRoutingService: jest.fn()\n\t\t};\n\t\tconst mockDiscardNavigationGuard = {\n\t\t\tdiscardNavigationGuard: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetShellServices = {\n\t\t\tderegisterDirtyStateProvider: jest.fn().mockReturnValue(undefined),\n\t\t\tsetBackNavigation: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetRoutingService = {\n\t\t\tdetachRouteMatched: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetModel = {\n\t\t\tgetModel: jest.fn()\n\t\t};\n\t\tconst mockDetachSessionTimeout = {\n\t\t\tdetachSessionTimeout: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tbeforeAll(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\toTransactionHelper = new TransactionHelper(null, null);\n\t\t\tmockGetAppComponent.getRouterProxy.mockReturnValue(mockDiscardNavigationGuard);\n\t\t\tmockGetAppComponent.getShellServices.mockReturnValue(mockGetShellServices);\n\t\t\tmockGetAppComponent.getRoutingService.mockReturnValue(mockGetRoutingService);\n\t\t\tmockGetModel.getModel.mockReturnValue(mockDetachSessionTimeout);\n\t\t\tspyGetAppComponent = jest.spyOn(CommonUtils, \"getAppComponent\");\n\t\t\tspyDiscardNavigationGuard = jest.spyOn(mockDiscardNavigationGuard, \"discardNavigationGuard\");\n\t\t\tspyDeregisterDirtyStateProvider = jest.spyOn(mockGetShellServices, \"deregisterDirtyStateProvider\");\n\t\t\tspyGetTransactionHelper = jest.spyOn(oInternalEditFlow, \"getTransactionHelper\");\n\t\t\tspyGetTransactionHelper.mockImplementation(() => {\n\t\t\t\treturn oTransactionHelper;\n\t\t\t});\n\t\t\tspySetEditMode = jest.spyOn(oInternalEditFlow, \"setEditMode\");\n\t\t\tspySetEditMode.mockImplementation(() => undefined);\n\t\t\tspyGetView = jest.spyOn(oInternalEditFlow, \"getView\");\n\t\t\tspyGetView.mockImplementation(() => {\n\t\t\t\treturn mockGetModel;\n\t\t\t});\n\t\t\toInternalEditFlow.fnHandleSessionTimeout = true;\n\t\t\toInternalEditFlow.fnStickyDiscardAfterNavigation = undefined;\n\t\t});\n\t\tbeforeEach(() => {});\n\t\tafterEach(() => {\n\t\t\tjest.clearAllMocks();\n\t\t});\n\t\tit(\"handleStickyOff: appComponent is undefined\", oTestReferences, async () => {\n\t\t\toInternalEditFlow.fnDirtyStateProvider = true;\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn undefined;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOff();\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyDiscardNavigationGuard).toHaveBeenCalledTimes(0);\n\t\t});\n\t\tit(\"handleStickyOff: valid function call, all set correctly\", oTestReferences, async () => {\n\t\t\toInternalEditFlow.fnDirtyStateProvider = true;\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn mockGetAppComponent;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOff();\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spySetEditMode).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDiscardNavigationGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDeregisterDirtyStateProvider).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"handleStickyOff: fnDirtyStateProvider not set\", oTestReferences, async () => {\n\t\t\toInternalEditFlow.fnDirtyStateProvider = false;\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn mockGetAppComponent;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOff();\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spySetEditMode).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDiscardNavigationGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDeregisterDirtyStateProvider).toHaveBeenCalledTimes(0);\n\t\t});\n\t});\n});\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["InternalEditFlow.spec.ts"],"names":["body","recover","result","e","then","describe","oTestReferences","afterAll","jest","resetAllMocks","oTransactionHelper","oInternalEditFlow","oGetTransactionHelperMock","oGetGlobalUIModellMock","oGetViewMock","oBusyLockMock","oSyncTaskMock","oHandleCreateEventsMock","oGetMessageHandlerMock","oHasTransientContextMock","oBusyUnlockMock","oOnBeforeCreateMock","oListBinding","oCreateDocumentMock","oMockModel","MockModel","oMockMetaModel","MockMetaModel","oMockContext","MockContext","$path","setMetaModel","beforeEach","InternalEditFlow","TransactionHelper","spyOn","mockImplementation","undefined","getController","oResourceBundle","getBindingContext","BusyLocker","mockReturnValue","mockResolvedValue","CommonUtils","getModel","getContext","getPath","created","afterEach","restoreAllMocks","it","aData","fn","Promise","resolve","createMultipleDocuments","expect","toHaveBeenCalledWith","contextPath","toHaveBeenCalledTimes","reject","spyGetModel","spyGetMetaModel","spyContextGetPath","sCustomAction","mockContext","mockView","mockModel","getMetaModel","mockMetaModel","getObject","beforeAll","clearAllMocks","_hasNewActionForSticky","bResponse","toEqual","NewAction","DiscardAction","EditAction","SaveAction","AdditionalNewActions","spyGetView","spyGetAppComponent","spyGetRouterProxy","spyHasNavigationGuard","spySetNavigationGuard","spyGetHash","spyGetInternalModel","spySetBackNavigation","spyRegisterDirtyStateProvider","spyAttachSessionTimeout","spyAttachRouteMatched","mockGetShellServices","setBackNavigation","registerDirtyStateProvider","mockGetRouterProxy","hasNavigationGuard","setNavigationGuard","getHash","mockGetRoutingService","attachRouteMatched","mockGetAppComponent","getRouterProxy","getShellServices","getRoutingService","mockGetModel","attachSessionTimeout","mockGetView","handleStickyOn","spySetEditMode","spyGetTransactionHelper","spyDiscardNavigationGuard","spyDeregisterDirtyStateProvider","mockDiscardNavigationGuard","discardNavigationGuard","deregisterDirtyStateProvider","detachRouteMatched","mockDetachSessionTimeout","detachSessionTimeout","fnHandleSessionTimeout","fnStickyDiscardAfterNavigation","fnDirtyStateProvider","handleStickyOff","mockHashTracker","spyIsNavigationFinalized","spyCheckHashWithGuard","spyIsGuardCrossAllowedByUser","spySetDirtyFlag","mockoNavigationContext","innerAppRoute","setDirtyFlag","isNavigationFinalized","checkHashWithGuard","isGuardCrossAllowedByUser","mockAppComponent","mockInternalModel","getProperty","_registerDirtyStateProvider","spyRemoveTransitionMessages","spyAddDependent","mockGetMessageHandler","removeTransitionMessages","mockGetRoutingListener","navigateBackFromContext","addDependent","getMessageHandler","getRoutingListener","getView","_attachSessionTimeout","spyDiscardStickySession","mockFnContext","discardStickySession","_attachRouteMatched"],"mappings":"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","sourceRoot":".","sourcesContent":["import { MockContext, MockMetaModel, MockModel } from \"sap/fe/test/UI5MockHelper\";\n\nimport InternalEditFlow from \"sap/fe/core/controllerextensions/InternalEditFlow\";\nimport TransactionHelper from \"sap/fe/core/TransactionHelper\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport BusyLocker from \"sap/fe/core/BusyLocker\";\n\ndescribe(\"InternalEditFlow ControllerExtension\", function() {\n\tconst oTestReferences = {\n\t\t\"references\": [\n\t\t\t{\n\t\t\t\t\"type\": \"JIRA\",\n\t\t\t\t\"ID\": \"FIORITECHP1-22294\"\n\t\t\t}\n\t\t]\n\t};\n\tafterAll(() => {\n\t\tjest.resetAllMocks();\n\t});\n\tdescribe(\"createMultipleDocuments - onBeforeCreate\", () => {\n\t\tlet oTransactionHelper: any, oInternalEditFlow: any;\n\t\tlet oGetTransactionHelperMock,\n\t\t\toGetGlobalUIModellMock,\n\t\t\toGetViewMock,\n\t\t\toBusyLockMock,\n\t\t\toSyncTaskMock,\n\t\t\toHandleCreateEventsMock,\n\t\t\toGetMessageHandlerMock,\n\t\t\toHasTransientContextMock,\n\t\t\toBusyUnlockMock,\n\t\t\toOnBeforeCreateMock,\n\t\t\toListBinding: any,\n\t\t\toCreateDocumentMock: any;\n\t\tconst oMockModel = new MockModel();\n\t\tconst oMockMetaModel = new MockMetaModel();\n\t\tconst oMockContext = new MockContext({ $path: \"SalesOrderItem\" });\n\t\toMockModel.setMetaModel(oMockMetaModel);\n\t\tbeforeEach(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\toTransactionHelper = new TransactionHelper(null as any, null);\n\t\t\toGetTransactionHelperMock = jest.spyOn(oInternalEditFlow as any, \"getTransactionHelper\");\n\t\t\toGetTransactionHelperMock.mockImplementation(() => {\n\t\t\t\treturn oTransactionHelper;\n\t\t\t});\n\t\t\toGetGlobalUIModellMock = jest.spyOn(oInternalEditFlow as any, \"getGlobalUIModel\");\n\t\t\toGetGlobalUIModellMock.mockImplementation(() => undefined);\n\t\t\toGetViewMock = jest.spyOn(oInternalEditFlow as any, \"getView\");\n\t\t\toGetViewMock.mockImplementation(() => {\n\t\t\t\treturn {\n\t\t\t\t\tgetController: function() {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\toResourceBundle: null\n\t\t\t\t\t\t};\n\t\t\t\t\t},\n\t\t\t\t\tgetBindingContext: function() {\n\t\t\t\t\t\treturn null;\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t});\n\t\t\toBusyLockMock = jest.spyOn(BusyLocker, \"lock\");\n\t\t\toBusyLockMock.mockReturnValue(true);\n\t\t\toBusyUnlockMock = jest.spyOn(BusyLocker, \"unlock\");\n\t\t\toBusyUnlockMock.mockReturnValue(true);\n\t\t\toSyncTaskMock = jest.spyOn(oInternalEditFlow as any, \"syncTask\");\n\t\t\toSyncTaskMock.mockResolvedValue(null);\n\t\t\toHandleCreateEventsMock = jest.spyOn(oInternalEditFlow as any, \"handleCreateEvents\");\n\t\t\toHandleCreateEventsMock.mockReturnValue(true);\n\t\t\toGetMessageHandlerMock = jest.spyOn(oInternalEditFlow as any, \"getMessageHandler\");\n\t\t\toGetMessageHandlerMock.mockReturnValue(true);\n\t\t\toHasTransientContextMock = jest.spyOn(CommonUtils, \"hasTransientContext\");\n\t\t\toHasTransientContextMock.mockReturnValue(true);\n\t\t\toHasTransientContextMock.mockReturnValue(true);\n\t\t\toListBinding = {\n\t\t\t\tgetModel: function() {\n\t\t\t\t\treturn oMockModel;\n\t\t\t\t},\n\t\t\t\tgetContext: function() {\n\t\t\t\t\treturn oMockContext;\n\t\t\t\t},\n\t\t\t\tgetPath: function() {\n\t\t\t\t\treturn \"/SalesOrderItem\";\n\t\t\t\t}\n\t\t\t};\n\t\t\toCreateDocumentMock = jest.spyOn(oTransactionHelper, \"createDocument\");\n\t\t\toCreateDocumentMock.mockResolvedValue({\n\t\t\t\tcreated: function() {\n\t\t\t\t\treturn null;\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t\tafterEach(() => {\n\t\t\tjest.restoreAllMocks();\n\t\t});\n\n\t\tit(\"onBeforeCreate is resolved\", async () => {\n\t\t\tconst aData = [\n\t\t\t\t{\n\t\t\t\t\t\"SalesOrder\": 6437\n\t\t\t\t}\n\t\t\t];\n\n\t\t\toOnBeforeCreateMock = jest.fn(() => {\n\t\t\t\treturn Promise.resolve();\n\t\t\t});\n\t\t\tawait (oInternalEditFlow as any).createMultipleDocuments(oListBinding, aData, true, true, oOnBeforeCreateMock);\n\t\t\texpect(oOnBeforeCreateMock).toHaveBeenCalledWith({ contextPath: oListBinding.getPath() });\n\t\t\texpect(oCreateDocumentMock).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"onBeforeCreate is rejected\", async () => {\n\t\t\tconst aData = [\n\t\t\t\t{\n\t\t\t\t\t\"SalesOrder\": 6437\n\t\t\t\t}\n\t\t\t];\n\n\t\t\toOnBeforeCreateMock = jest.fn(() => {\n\t\t\t\treturn Promise.reject();\n\t\t\t});\n\t\t\ttry {\n\t\t\t\tawait (oInternalEditFlow as any).createMultipleDocuments(oListBinding, aData, true, true, oOnBeforeCreateMock);\n\t\t\t} catch {\n\t\t\t\texpect(oOnBeforeCreateMock).toHaveBeenCalledWith({ contextPath: oListBinding.getPath() });\n\t\t\t\texpect(oCreateDocumentMock).toHaveBeenCalledTimes(0);\n\t\t\t}\n\t\t});\n\t});\n\n\tdescribe(\"testing - _hasNewActionForSticky\", () => {\n\t\tlet oInternalEditFlow: any, spyGetModel: any, spyGetMetaModel: any, spyContextGetPath: any, sCustomAction: string;\n\t\tconst mockContext = {\n\t\t\tgetPath: jest.fn(() => \"\")\n\t\t};\n\t\tconst mockView = {\n\t\t\tgetModel: jest.fn()\n\t\t};\n\t\tconst mockModel = {\n\t\t\tgetMetaModel: jest.fn()\n\t\t};\n\t\tconst mockMetaModel = {\n\t\t\tgetObject: jest.fn()\n\t\t};\n\t\tbeforeAll(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\tmockModel.getMetaModel.mockReturnValue(mockMetaModel);\n\t\t\tmockView.getModel.mockReturnValue(mockModel);\n\t\t\tspyGetModel = jest.spyOn(mockView, \"getModel\");\n\t\t\tspyGetMetaModel = jest.spyOn(mockModel, \"getMetaModel\");\n\t\t\tspyContextGetPath = jest.spyOn(mockContext, \"getPath\");\n\t\t});\n\t\tbeforeEach(() => {});\n\t\tafterEach(() => {\n\t\t\tjest.clearAllMocks();\n\t\t});\n\t\tit(\"_hasNewActionForSticky: invalid input parameters\", oTestReferences, async () => {\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(undefined, undefined);\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyGetModel).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyGetMetaModel).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyContextGetPath).toHaveBeenCalledTimes(0);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: empty input parameters\", oTestReferences, async () => {\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView);\n\t\t\texpect(bResponse).toEqual(false);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: missing context\", oTestReferences, async () => {\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tNewAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView);\n\t\t\texpect(bResponse).toEqual(false);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: missing NewAction/AdditionalNewAction\", oTestReferences, async () => {\n\t\t\tmockContext.getPath.mockReturnValue(\"/SalesQuotationManage('')\");\n\t\t\tsCustomAction = \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\";\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tDiscardAction: \"DiscardChanges\",\n\t\t\t\tEditAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit\",\n\t\t\t\tSaveAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);\n\t\t\texpect(bResponse).toEqual(false);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: NewAction available\", oTestReferences, async () => {\n\t\t\tmockContext.getPath.mockReturnValue(\"/SalesQuotationManage('')\");\n\t\t\tsCustomAction = \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\";\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tDiscardAction: \"DiscardChanges\",\n\t\t\t\tEditAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit\",\n\t\t\t\tSaveAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges\",\n\t\t\t\tNewAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);\n\t\t\texpect(bResponse).toEqual(true);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: AdditionalNewAction available\", oTestReferences, async () => {\n\t\t\tmockContext.getPath.mockReturnValue(\"/SalesQuotationManage('')\");\n\t\t\tsCustomAction = \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\";\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tAdditionalNewActions: [\n\t\t\t\t\t\"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithRefFromSlsInquiry\",\n\t\t\t\t\t\"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\"\n\t\t\t\t],\n\t\t\t\tDiscardAction: \"DiscardChanges\",\n\t\t\t\tEditAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit\",\n\t\t\t\tSaveAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spyGetModel).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetMetaModel).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyContextGetPath).toHaveBeenCalledTimes(2);\n\t\t});\n\t\tit(\"_hasNewActionForSticky: AdditionalNewAction available but not the relevant one\", oTestReferences, async () => {\n\t\t\tmockContext.getPath.mockReturnValue(\"/SalesQuotationManage('')\");\n\t\t\tsCustomAction = \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType\";\n\t\t\tmockMetaModel.getObject.mockReturnValue({\n\t\t\t\tAdditionalNewActions: [\n\t\t\t\t\t\"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithRefFromSlsInquiry\",\n\t\t\t\t\t\"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesOrderType\"\n\t\t\t\t],\n\t\t\t\tDiscardAction: \"DiscardChanges\",\n\t\t\t\tEditAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit\",\n\t\t\t\tSaveAction: \"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges\"\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);\n\t\t\texpect(bResponse).toEqual(false);\n\t\t\texpect(spyGetModel).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetMetaModel).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyContextGetPath).toHaveBeenCalledTimes(2);\n\t\t});\n\t});\n\n\tdescribe(\"testing handleStickyOn()\", () => {\n\t\tlet oInternalEditFlow: any,\n\t\t\tspyGetView: any,\n\t\t\tspyGetAppComponent: any,\n\t\t\tspyGetRouterProxy: any,\n\t\t\tspyHasNavigationGuard: any,\n\t\t\tspySetNavigationGuard: any,\n\t\t\tspyGetHash: any,\n\t\t\tspyGetInternalModel: any,\n\t\t\tspySetBackNavigation: any,\n\t\t\tspyRegisterDirtyStateProvider: any,\n\t\t\tspyGetModel: any,\n\t\t\tspyAttachSessionTimeout: any,\n\t\t\tspyAttachRouteMatched: any;\n\t\tconst mockGetShellServices = {\n\t\t\tsetBackNavigation: jest.fn().mockReturnValue(undefined),\n\t\t\tregisterDirtyStateProvider: jest.fn()\n\t\t};\n\t\tconst mockGetRouterProxy = {\n\t\t\thasNavigationGuard: jest.fn(),\n\t\t\tsetNavigationGuard: jest.fn(),\n\t\t\tgetHash: jest.fn().mockReturnValue(\"\")\n\t\t};\n\t\tconst mockGetRoutingService = {\n\t\t\tattachRouteMatched: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetAppComponent = {\n\t\t\tgetRouterProxy: jest.fn().mockReturnValue(mockGetRouterProxy),\n\t\t\tgetShellServices: jest.fn().mockReturnValue(mockGetShellServices),\n\t\t\tgetRoutingService: jest.fn().mockReturnValue(mockGetRoutingService)\n\t\t};\n\t\tconst mockContext = {};\n\t\tconst mockGetModel = {\n\t\t\tattachSessionTimeout: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetView = {\n\t\t\tgetModel: jest.fn().mockReturnValue(mockGetModel)\n\t\t};\n\t\tbeforeAll(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\tspyGetView = jest.spyOn(oInternalEditFlow, \"getView\");\n\t\t\tspyGetView.mockImplementation(() => mockGetView);\n\t\t\tspyGetModel = jest.spyOn(mockGetView, \"getModel\");\n\t\t\tspyAttachSessionTimeout = jest.spyOn(mockGetModel, \"attachSessionTimeout\");\n\t\t\tspyGetAppComponent = jest.spyOn(CommonUtils, \"getAppComponent\");\n\t\t\tspyGetRouterProxy = jest.spyOn(mockGetAppComponent, \"getRouterProxy\");\n\t\t\tspyHasNavigationGuard = jest.spyOn(mockGetRouterProxy, \"hasNavigationGuard\");\n\t\t\tspySetNavigationGuard = jest.spyOn(mockGetRouterProxy, \"setNavigationGuard\");\n\t\t\tspyGetHash = jest.spyOn(mockGetRouterProxy, \"getHash\");\n\t\t\tspyGetInternalModel = jest.spyOn(oInternalEditFlow, \"getInternalModel\");\n\t\t\tspyGetInternalModel.mockImplementation(() => {\n\t\t\t\treturn {};\n\t\t\t});\n\t\t\tspySetBackNavigation = jest.spyOn(mockGetShellServices, \"setBackNavigation\");\n\t\t\tspyRegisterDirtyStateProvider = jest.spyOn(mockGetShellServices, \"registerDirtyStateProvider\");\n\t\t\tspyAttachRouteMatched = jest.spyOn(mockGetRoutingService, \"attachRouteMatched\");\n\t\t});\n\t\tafterEach(() => {\n\t\t\tjest.clearAllMocks();\n\t\t});\n\t\tit(\"handleStickyOn: input paramater oContext is undefined\", oTestReferences, async () => {\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn undefined;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOn(undefined);\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"handleStickyOn: input paramater oContext is empty\", oTestReferences, async () => {\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn {};\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOn(mockContext);\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"handleStickyOn: check valid input\", oTestReferences, async () => {\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn mockGetAppComponent;\n\t\t\t});\n\t\t\tspyHasNavigationGuard.mockImplementation(() => {\n\t\t\t\treturn false;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOn(mockContext);\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(2);\n\t\t\texpect(spyHasNavigationGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetHash).toHaveBeenCalledTimes(1);\n\t\t\texpect(spySetNavigationGuard).toHaveBeenCalledTimes(0);\n\t\t\texpect(spySetBackNavigation).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyRegisterDirtyStateProvider).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyAttachSessionTimeout).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyAttachRouteMatched).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"handleStickyOn: navigation guard already set\", oTestReferences, async () => {\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn mockGetAppComponent;\n\t\t\t});\n\t\t\tspyHasNavigationGuard.mockImplementation(() => {\n\t\t\t\treturn true;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOn(mockContext);\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyHasNavigationGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetHash).toHaveBeenCalledTimes(0);\n\t\t\texpect(spySetNavigationGuard).toHaveBeenCalledTimes(0);\n\t\t\texpect(spySetBackNavigation).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyRegisterDirtyStateProvider).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyAttachSessionTimeout).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyAttachRouteMatched).toHaveBeenCalledTimes(0);\n\t\t});\n\t});\n\n\tdescribe(\"testing handleStickyOff()\", () => {\n\t\tlet oInternalEditFlow: any,\n\t\t\toTransactionHelper: any,\n\t\t\tspyGetView: any,\n\t\t\tspySetEditMode: any,\n\t\t\tspyGetAppComponent: any,\n\t\t\tspyGetTransactionHelper: any,\n\t\t\tspyDiscardNavigationGuard: any,\n\t\t\tspyDeregisterDirtyStateProvider: any;\n\t\tconst mockGetAppComponent = {\n\t\t\tgetRouterProxy: jest.fn(),\n\t\t\tgetShellServices: jest.fn(),\n\t\t\tgetRoutingService: jest.fn()\n\t\t};\n\t\tconst mockDiscardNavigationGuard = {\n\t\t\tdiscardNavigationGuard: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetShellServices = {\n\t\t\tderegisterDirtyStateProvider: jest.fn().mockReturnValue(undefined),\n\t\t\tsetBackNavigation: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetRoutingService = {\n\t\t\tdetachRouteMatched: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetModel = {\n\t\t\tgetModel: jest.fn()\n\t\t};\n\t\tconst mockDetachSessionTimeout = {\n\t\t\tdetachSessionTimeout: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tbeforeAll(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\toTransactionHelper = new TransactionHelper(null as any, null);\n\t\t\tmockGetAppComponent.getRouterProxy.mockReturnValue(mockDiscardNavigationGuard);\n\t\t\tmockGetAppComponent.getShellServices.mockReturnValue(mockGetShellServices);\n\t\t\tmockGetAppComponent.getRoutingService.mockReturnValue(mockGetRoutingService);\n\t\t\tmockGetModel.getModel.mockReturnValue(mockDetachSessionTimeout);\n\t\t\tspyGetAppComponent = jest.spyOn(CommonUtils, \"getAppComponent\");\n\t\t\tspyDiscardNavigationGuard = jest.spyOn(mockDiscardNavigationGuard, \"discardNavigationGuard\");\n\t\t\tspyDeregisterDirtyStateProvider = jest.spyOn(mockGetShellServices, \"deregisterDirtyStateProvider\");\n\t\t\tspyGetTransactionHelper = jest.spyOn(oInternalEditFlow, \"getTransactionHelper\");\n\t\t\tspyGetTransactionHelper.mockImplementation(() => {\n\t\t\t\treturn oTransactionHelper;\n\t\t\t});\n\t\t\tspySetEditMode = jest.spyOn(oInternalEditFlow, \"setEditMode\");\n\t\t\tspySetEditMode.mockImplementation(() => undefined);\n\t\t\tspyGetView = jest.spyOn(oInternalEditFlow, \"getView\");\n\t\t\tspyGetView.mockImplementation(() => {\n\t\t\t\treturn mockGetModel;\n\t\t\t});\n\t\t\toInternalEditFlow.fnHandleSessionTimeout = true;\n\t\t\toInternalEditFlow.fnStickyDiscardAfterNavigation = undefined;\n\t\t});\n\t\tbeforeEach(() => {});\n\t\tafterEach(() => {\n\t\t\tjest.clearAllMocks();\n\t\t});\n\t\tit(\"handleStickyOff: appComponent is undefined\", oTestReferences, async () => {\n\t\t\toInternalEditFlow.fnDirtyStateProvider = true;\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn undefined;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOff();\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyDiscardNavigationGuard).toHaveBeenCalledTimes(0);\n\t\t});\n\t\tit(\"handleStickyOff: valid function call, all set correctly\", oTestReferences, async () => {\n\t\t\toInternalEditFlow.fnDirtyStateProvider = true;\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn mockGetAppComponent;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOff();\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spySetEditMode).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDiscardNavigationGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDeregisterDirtyStateProvider).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"handleStickyOff: fnDirtyStateProvider not set\", oTestReferences, async () => {\n\t\t\toInternalEditFlow.fnDirtyStateProvider = false;\n\t\t\tspyGetAppComponent.mockImplementation(() => {\n\t\t\t\treturn mockGetAppComponent;\n\t\t\t});\n\t\t\tconst bResponse = await oInternalEditFlow.handleStickyOff();\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spySetEditMode).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyGetAppComponent).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDiscardNavigationGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDeregisterDirtyStateProvider).toHaveBeenCalledTimes(0);\n\t\t});\n\t});\n\n\tdescribe(\"testing fnDirtyStateProvider()\", () => {\n\t\tlet oInternalEditFlow: any,\n\t\t\tmockHashTracker: string,\n\t\t\tspyGetRouterProxy: any,\n\t\t\tspyIsNavigationFinalized: any,\n\t\t\tspyCheckHashWithGuard: any,\n\t\t\tspyIsGuardCrossAllowedByUser: any,\n\t\t\tspySetDirtyFlag: any;\n\n\t\tconst mockoNavigationContext = {\n\t\t\tinnerAppRoute: \"\"\n\t\t};\n\t\tconst mockGetShellServices = {\n\t\t\tsetDirtyFlag: jest.fn().mockReturnValue(undefined)\n\t\t};\n\t\tconst mockGetRouterProxy = {\n\t\t\tisNavigationFinalized: jest.fn(),\n\t\t\tcheckHashWithGuard: jest.fn(),\n\t\t\tisGuardCrossAllowedByUser: jest.fn()\n\t\t};\n\t\tconst mockAppComponent = {\n\t\t\tgetRouterProxy: jest.fn().mockReturnValue(mockGetRouterProxy),\n\t\t\tgetShellServices: jest.fn().mockReturnValue(mockGetShellServices)\n\t\t};\n\t\tconst mockInternalModel = {\n\t\t\tgetProperty: jest.fn()\n\t\t};\n\n\t\tbeforeAll(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\tspyGetRouterProxy = jest.spyOn(mockAppComponent, \"getRouterProxy\");\n\t\t\tspyIsNavigationFinalized = jest.spyOn(mockGetRouterProxy, \"isNavigationFinalized\");\n\t\t\tspyCheckHashWithGuard = jest.spyOn(mockGetRouterProxy, \"checkHashWithGuard\");\n\t\t\tspyIsGuardCrossAllowedByUser = jest.spyOn(mockGetRouterProxy, \"isGuardCrossAllowedByUser\");\n\t\t\tspySetDirtyFlag = jest.spyOn(mockGetShellServices, \"setDirtyFlag\");\n\t\t});\n\t\tafterEach(() => {\n\t\t\tjest.clearAllMocks();\n\t\t});\n\t\tit(\"fnDirtyStateProvider: input paramater oNavigationContext is undefined\", oTestReferences, async () => {\n\t\t\tmockHashTracker = \"abc\";\n\t\t\tmockInternalModel.getProperty.mockReturnValue(undefined);\n\t\t\tconst fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(\n\t\t\t\tmockAppComponent,\n\t\t\t\tmockInternalModel,\n\t\t\t\tmockHashTracker\n\t\t\t);\n\t\t\tconst bResponse = await fnDirtyStateProvider(undefined);\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(0);\n\t\t});\n\t\tit(\"fnDirtyStateProvider: missing property of internalModel\", oTestReferences, async () => {\n\t\t\tmockHashTracker = \"abc\";\n\t\t\tmockInternalModel.getProperty.mockReturnValue(undefined);\n\t\t\tconst fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(\n\t\t\t\tmockAppComponent,\n\t\t\t\tmockInternalModel,\n\t\t\t\tmockHashTracker\n\t\t\t);\n\t\t\tconst bResponse = await fnDirtyStateProvider(mockoNavigationContext);\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"fnDirtyStateProvider: isNavigationFinalized() returns false\", oTestReferences, async () => {\n\t\t\tmockHashTracker = \"abc\";\n\t\t\tmockInternalModel.getProperty.mockReturnValue(true);\n\t\t\tmockGetRouterProxy.isNavigationFinalized.mockReturnValue(false);\n\t\t\tconst fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(\n\t\t\t\tmockAppComponent,\n\t\t\t\tmockInternalModel,\n\t\t\t\tmockHashTracker\n\t\t\t);\n\t\t\tconst bResponse = await fnDirtyStateProvider(mockoNavigationContext);\n\t\t\texpect(bResponse).toEqual(false);\n\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyCheckHashWithGuard).toHaveBeenCalledTimes(0);\n\t\t\texpect(spySetDirtyFlag).toHaveBeenCalledTimes(0);\n\t\t});\n\t\tit(\"fnDirtyStateProvider: isNavigationFinalized() returns true, HashTracker=TargetHash\", oTestReferences, async () => {\n\t\t\tmockHashTracker = \"abc\";\n\t\t\tmockoNavigationContext.innerAppRoute = \"abc\";\n\t\t\tmockInternalModel.getProperty.mockReturnValue(true);\n\t\t\tmockGetRouterProxy.isNavigationFinalized.mockReturnValue(true);\n\t\t\tconst fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(\n\t\t\t\tmockAppComponent,\n\t\t\t\tmockInternalModel,\n\t\t\t\tmockHashTracker\n\t\t\t);\n\t\t\tconst bResponse = await fnDirtyStateProvider(mockoNavigationContext);\n\t\t\texpect(bResponse).toEqual(true);\n\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyCheckHashWithGuard).toHaveBeenCalledTimes(0);\n\t\t\texpect(spySetDirtyFlag).toHaveBeenCalledTimes(0);\n\t\t});\n\t\tit(\n\t\t\t\"fnDirtyStateProvider: isNavigationFinalized() returns true, HashTracker<>TargetHash, checkHashWithGuard()=true\",\n\t\t\toTestReferences,\n\t\t\tasync () => {\n\t\t\t\tmockHashTracker = \"abc\";\n\t\t\t\tmockoNavigationContext.innerAppRoute = \"xyz\";\n\t\t\t\tmockInternalModel.getProperty.mockReturnValue(true);\n\t\t\t\tmockGetRouterProxy.isNavigationFinalized.mockReturnValue(true);\n\t\t\t\tmockGetRouterProxy.checkHashWithGuard.mockReturnValue(true);\n\t\t\t\tconst fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(\n\t\t\t\t\tmockAppComponent,\n\t\t\t\t\tmockInternalModel,\n\t\t\t\t\tmockHashTracker\n\t\t\t\t);\n\t\t\t\tconst bResponse = await fnDirtyStateProvider(mockoNavigationContext);\n\t\t\t\texpect(bResponse).toEqual(false);\n\t\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spyIsGuardCrossAllowedByUser).toHaveBeenCalledTimes(0);\n\t\t\t\texpect(spySetDirtyFlag).toHaveBeenCalledTimes(0);\n\t\t\t}\n\t\t);\n\t\tit(\n\t\t\t\"fnDirtyStateProvider: isNavigationFinalized() returns true, HashTracker<>TargetHash, checkHashWithGuard()=false, isGuardCrossAllowedByUser()=true\",\n\t\t\toTestReferences,\n\t\t\tasync () => {\n\t\t\t\tmockHashTracker = \"abc\";\n\t\t\t\tmockoNavigationContext.innerAppRoute = \"xyz\";\n\t\t\t\tmockInternalModel.getProperty.mockReturnValue(true);\n\t\t\t\tmockGetRouterProxy.isNavigationFinalized.mockReturnValue(true);\n\t\t\t\tmockGetRouterProxy.checkHashWithGuard.mockReturnValue(false);\n\t\t\t\tmockGetRouterProxy.isGuardCrossAllowedByUser.mockReturnValue(true);\n\t\t\t\tconst fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(\n\t\t\t\t\tmockAppComponent,\n\t\t\t\t\tmockInternalModel,\n\t\t\t\t\tmockHashTracker\n\t\t\t\t);\n\t\t\t\tconst bResponse = await fnDirtyStateProvider(mockoNavigationContext);\n\t\t\t\texpect(bResponse).toEqual(false);\n\t\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spyIsGuardCrossAllowedByUser).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spySetDirtyFlag).toHaveBeenCalledTimes(0);\n\t\t\t}\n\t\t);\n\t\tit(\n\t\t\t\"fnDirtyStateProvider: isNavigationFinalized() returns true, HashTracker<>TargetHash, checkHashWithGuard()=false, isGuardCrossAllowedByUser()=false\",\n\t\t\toTestReferences,\n\t\t\tasync () => {\n\t\t\t\tmockHashTracker = \"abc\";\n\t\t\t\tmockoNavigationContext.innerAppRoute = \"xyz\";\n\t\t\t\tmockInternalModel.getProperty.mockReturnValue(true);\n\t\t\t\tmockGetRouterProxy.isNavigationFinalized.mockReturnValue(true);\n\t\t\t\tmockGetRouterProxy.checkHashWithGuard.mockReturnValue(false);\n\t\t\t\tmockGetRouterProxy.isGuardCrossAllowedByUser.mockReturnValue(false);\n\t\t\t\tconst fnDirtyStateProvider = oInternalEditFlow._registerDirtyStateProvider(\n\t\t\t\t\tmockAppComponent,\n\t\t\t\t\tmockInternalModel,\n\t\t\t\t\tmockHashTracker\n\t\t\t\t);\n\t\t\t\tconst bResponse = await fnDirtyStateProvider(mockoNavigationContext);\n\t\t\t\texpect(bResponse).toEqual(true);\n\t\t\t\texpect(spyGetRouterProxy).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spyIsNavigationFinalized).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spyIsGuardCrossAllowedByUser).toHaveBeenCalledTimes(1);\n\t\t\t\texpect(spySetDirtyFlag).toHaveBeenCalledTimes(0);\n\t\t\t}\n\t\t);\n\t});\n\n\tdescribe(\"testing fnHandleSessionTimeout()\", () => {\n\t\tlet oInternalEditFlow: any, spyRemoveTransitionMessages: any, spyAddDependent: any;\n\n\t\tconst mockGetRouterProxy = {\n\t\t\tgetHash: jest.fn(),\n\t\t\tcheckHashWithGuard: jest.fn()\n\t\t};\n\t\tconst mockAppComponent = {\n\t\t\tgetRouterProxy: jest.fn().mockReturnValue(mockGetRouterProxy)\n\t\t};\n\n\t\tconst mockGetMessageHandler = {\n\t\t\tremoveTransitionMessages: jest.fn().mockReturnValue(false)\n\t\t};\n\t\tconst mockGetRoutingListener = {\n\t\t\tnavigateBackFromContext: jest.fn().mockReturnValue(false)\n\t\t};\n\t\tconst mockGetView = {\n\t\t\taddDependent: jest.fn().mockReturnValue(false)\n\t\t};\n\t\tconst mockContext = {\n\t\t\tgetMessageHandler: jest.fn().mockReturnValue(mockGetMessageHandler),\n\t\t\thandleStickyOff: jest.fn(),\n\t\t\tgetRoutingListener: jest.fn().mockReturnValue(mockGetRoutingListener),\n\t\t\tgetView: jest.fn().mockReturnValue(mockGetView)\n\t\t};\n\n\t\tbeforeAll(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\tspyRemoveTransitionMessages = jest.spyOn(mockGetMessageHandler, \"removeTransitionMessages\");\n\t\t\tspyAddDependent = jest.spyOn(mockGetView, \"addDependent\");\n\t\t});\n\t\tafterEach(() => {\n\t\t\tjest.clearAllMocks();\n\t\t});\n\t\tit(\"fnHandleSessionTimeout: calling with valid input\", oTestReferences, async () => {\n\t\t\tconst fnHandleSessionTimeout = oInternalEditFlow._attachSessionTimeout(mockContext, undefined);\n\t\t\tawait fnHandleSessionTimeout();\n\t\t\texpect(spyRemoveTransitionMessages).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyAddDependent).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"fnHandleSessionTimeout: context is invalid\", oTestReferences, async () => {\n\t\t\tconst fnHandleSessionTimeout = oInternalEditFlow._attachSessionTimeout(undefined, undefined);\n\t\t\tconst bResponse = await fnHandleSessionTimeout();\n\t\t\texpect(bResponse).toEqual(undefined);\n\t\t\texpect(spyRemoveTransitionMessages).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyAddDependent).toHaveBeenCalledTimes(0);\n\t\t});\n\t});\n\n\tdescribe(\"testing fnStickyDiscardAfterNavigation()\", () => {\n\t\tlet oInternalEditFlow: any, spyGetHash: any, spyCheckHashWithGuard: any, spyDiscardStickySession: any;\n\n\t\tconst mockGetRouterProxy = {\n\t\t\tgetHash: jest.fn(),\n\t\t\tcheckHashWithGuard: jest.fn()\n\t\t};\n\t\tconst mockAppComponent = {\n\t\t\tgetRouterProxy: jest.fn().mockReturnValue(mockGetRouterProxy)\n\t\t};\n\t\tconst mockFnContext = {\n\t\t\tdiscardStickySession: jest.fn().mockReturnValue(false)\n\t\t};\n\n\t\tbeforeAll(() => {\n\t\t\toInternalEditFlow = new InternalEditFlow();\n\t\t\tspyGetHash = jest.spyOn(mockGetRouterProxy, \"getHash\");\n\t\t\tspyCheckHashWithGuard = jest.spyOn(mockGetRouterProxy, \"checkHashWithGuard\");\n\t\t\tspyDiscardStickySession = jest.spyOn(mockFnContext, \"discardStickySession\");\n\t\t});\n\t\tafterEach(() => {\n\t\t\tjest.clearAllMocks();\n\t\t});\n\t\tit(\"fnStickyDiscardAfterNavigation: Hash undefined\", oTestReferences, async () => {\n\t\t\tmockGetRouterProxy.getHash.mockReturnValue(undefined);\n\t\t\tconst fnStickyDiscardAfterNavigation = oInternalEditFlow._attachRouteMatched(mockFnContext, undefined, mockAppComponent);\n\t\t\tawait fnStickyDiscardAfterNavigation();\n\t\t\texpect(spyGetHash).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyCheckHashWithGuard).toHaveBeenCalledTimes(0);\n\t\t\texpect(spyDiscardStickySession).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"fnStickyDiscardAfterNavigation: checkHashWithGuard()=false\", oTestReferences, async () => {\n\t\t\tmockGetRouterProxy.getHash.mockReturnValue(\"abc\");\n\t\t\tmockGetRouterProxy.checkHashWithGuard.mockReturnValue(false);\n\t\t\tconst fnStickyDiscardAfterNavigation = oInternalEditFlow._attachRouteMatched(mockFnContext, undefined, mockAppComponent);\n\t\t\tawait fnStickyDiscardAfterNavigation();\n\t\t\texpect(spyGetHash).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDiscardStickySession).toHaveBeenCalledTimes(1);\n\t\t});\n\t\tit(\"fnStickyDiscardAfterNavigation: checkHashWithGuard()=true\", oTestReferences, async () => {\n\t\t\tmockGetRouterProxy.getHash.mockReturnValue(\"abc\");\n\t\t\tmockGetRouterProxy.checkHashWithGuard.mockReturnValue(true);\n\t\t\tconst fnStickyDiscardAfterNavigation = oInternalEditFlow._attachRouteMatched(mockFnContext, undefined, mockAppComponent);\n\t\t\tawait fnStickyDiscardAfterNavigation();\n\t\t\texpect(spyGetHash).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyCheckHashWithGuard).toHaveBeenCalledTimes(1);\n\t\t\texpect(spyDiscardStickySession).toHaveBeenCalledTimes(0);\n\t\t});\n\t});\n});\n"]}