@sap/open.fe 1.96.0 → 1.97.0

package/packages/sap.fe.core/test/sap/fe/core/jest/formatters/TableFormatters.spec.js

@@ -0,0 +1,68 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/formatters/TableFormatter", "sap/fe/core/formatters/TableFormatterTypes"], function (TableFormatter, TableFormatterTypes) {
+  "use strict";
+
+  var MessageType = TableFormatterTypes.MessageType;
+
+  var oRow;
+  beforeAll(function () {
+    try {
+      oRow = {
+        getBindingContext: function () {
+          return {
+            getPath: function () {
+              return "/rowBindingPath";
+            }
+          };
+        }
+      };
+      return Promise.resolve();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  });
+  describe("Table Formatters", function () {
+    it("rowHighlighting : 1 Error Message", function () {
+      var aMessage = [{
+        message: "mesg1",
+        type: MessageType.Error,
+        aTargets: ["/rowBindingPath/prop1"]
+      }];
+      expect(TableFormatter.rowHighlighting.call(oRow, MessageType.None, aMessage)).toEqual("Error");
+    });
+    it("rowHighlighting : 1 Warning Message", function () {
+      var aMessage = [{
+        message: "mesg1",
+        type: MessageType.Warning,
+        aTargets: ["/rowBindingPath/prop1"]
+      }];
+      expect(TableFormatter.rowHighlighting.call(oRow, MessageType.None, aMessage)).toEqual("Warning");
+    });
+    it("rowHighlighting: 2 Error + Warning Message", function () {
+      var aMessage = [{
+        message: "mesg2",
+        type: MessageType.Warning,
+        aTargets: ["/rowBindingPath/prop2"]
+      }, {
+        message: "mesg1",
+        type: MessageType.Error,
+        aTargets: ["/rowBindingPath/prop1"]
+      }];
+      expect(TableFormatter.rowHighlighting.call(oRow, MessageType.None, aMessage)).toEqual("Error");
+      aMessage = [{
+        message: "mesg1",
+        type: MessageType.Error,
+        aTargets: ["/rowBindingPath/prop1"]
+      }, {
+        message: "mesg2",
+        type: MessageType.Warning,
+        aTargets: ["/rowBindingPath/prop2"]
+      }];
+      expect(TableFormatter.rowHighlighting.call(oRow, MessageType.None, aMessage)).toEqual("Error");
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/packages/sap.fe.core/test/sap/fe/core/jest/formatters/TableFormatters.spec.ts

@@ -0,0 +1,38 @@
+import TableFormatter from "sap/fe/core/formatters/TableFormatter";
+import { MessageType } from "sap/fe/core/formatters/TableFormatterTypes";
+import { ManagedObject } from "sap/ui/base";
+
+let oRow: any;
+beforeAll(async function() {
+	oRow = {
+		getBindingContext: () => {
+			return {
+				getPath: () => "/rowBindingPath"
+			};
+		}
+	};
+});
+describe("Table Formatters", () => {
+	it("rowHighlighting : 1 Error Message", () => {
+		let aMessage = [{ message: "mesg1", type: MessageType.Error, aTargets: ["/rowBindingPath/prop1"] }];
+		expect(TableFormatter.rowHighlighting.call(oRow, MessageType.None, aMessage)).toEqual("Error");
+	});
+
+	it("rowHighlighting : 1 Warning Message", () => {
+		let aMessage = [{ message: "mesg1", type: MessageType.Warning, aTargets: ["/rowBindingPath/prop1"] }];
+		expect(TableFormatter.rowHighlighting.call(oRow, MessageType.None, aMessage)).toEqual("Warning");
+	});
+
+	it("rowHighlighting: 2 Error + Warning Message", () => {
+		let aMessage = [
+			{ message: "mesg2", type: MessageType.Warning, aTargets: ["/rowBindingPath/prop2"] },
+			{ message: "mesg1", type: MessageType.Error, aTargets: ["/rowBindingPath/prop1"] }
+		];
+		expect(TableFormatter.rowHighlighting.call(oRow, MessageType.None, aMessage)).toEqual("Error");
+		aMessage = [
+			{ message: "mesg1", type: MessageType.Error, aTargets: ["/rowBindingPath/prop1"] },
+			{ message: "mesg2", type: MessageType.Warning, aTargets: ["/rowBindingPath/prop2"] }
+		];
+		expect(TableFormatter.rowHighlighting.call(oRow, MessageType.None, aMessage)).toEqual("Error");
+	});
+});

package/packages/sap.fe.core/test/sap/fe/core/jest/helpers/KeepAliveHelper.spec.js

@@ -0,0 +1,483 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/helpers/KeepAliveHelper", "sap/fe/core/helpers/KeepAliveRefreshTypes", "sap/ui/core/mvc/View", "sap/base/Log", "./KeepAliveHelperTestData/StoreStrategyTests", "./KeepAliveHelperTestData/RefreshStrategyForIntentTests", "./KeepAliveHelperTestData/ControlRefreshStrategyTests", "./KeepAliveHelperTestData/ControlsForRefreshTests", "sap/fe/test/UI5MockHelper"], function (KeepAliveHelper, KeepAliveRefreshTypes, View, Log, StoreStrategyTests, RefreshStrategyForIntentTests, ControlRefreshStrategyTests, ControlsForRefreshTests, UI5MockHelper) {
+  "use strict";
+
+  var MockContext = UI5MockHelper.MockContext;
+  var MockControl = UI5MockHelper.MockControl;
+  var MockMetaModel = UI5MockHelper.MockMetaModel;
+  var MockModel = UI5MockHelper.MockModel;
+  var PATH_TO_STORE = KeepAliveRefreshTypes.PATH_TO_STORE;
+
+  describe("Keep Alive Helper Testing - #storeControlRefreshStrategyForHash", function () {
+    var internal;
+    var viewData;
+    var control;
+    var oMockGetModel;
+    var oMockInternalSetProperty;
+    var oMockViewDataGetProperty;
+    var refreshStrategyToTest;
+    beforeAll(function () {
+      try {
+        internal = new MockModel();
+        viewData = new MockModel();
+        control = new MockControl(); // mock model
+
+        oMockGetModel = jest.spyOn(control, "getModel");
+        oMockGetModel.mockImplementation(function (name) {
+          if (name === "internal") {
+            return internal;
+          } else if (name === "viewData") {
+            return viewData;
+          }
+        });
+        oMockInternalSetProperty = jest.spyOn(internal, "setProperty");
+        oMockViewDataGetProperty = jest.spyOn(viewData, "getProperty");
+        oMockViewDataGetProperty.mockImplementation(function (sPath) {
+          return sPath === PATH_TO_STORE ? refreshStrategyToTest : undefined;
+        });
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    beforeEach(function () {
+      // Clean JSON
+      refreshStrategyToTest = {};
+      return Promise.resolve();
+    });
+    afterAll(function () {
+      try {
+        jest.restoreAllMocks();
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    StoreStrategyTests.forEach(function (oTestData) {
+      it(oTestData.title, function () {
+        try {
+          // Cases to consider
+          refreshStrategyToTest = oTestData.refreshStrategies;
+          KeepAliveHelper.storeControlRefreshStrategyForHash(control, oTestData.hash);
+          expect(oMockInternalSetProperty).toHaveBeenLastCalledWith(PATH_TO_STORE, oTestData.result);
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+  });
+  describe("Keep Alive Helper Testing - #getRefreshStrategyForIntent", function () {
+    var refreshStrategies;
+    var semanticObject;
+    var action;
+    beforeEach(function () {
+      // Clean JSON
+      refreshStrategies = {};
+      semanticObject = undefined;
+      action = undefined;
+      return Promise.resolve();
+    });
+    afterAll(function () {
+      try {
+        jest.restoreAllMocks();
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    RefreshStrategyForIntentTests.forEach(function (oTestData) {
+      it(oTestData.title, function () {
+        try {
+          // Cases to consider
+          expect(KeepAliveHelper.getRefreshStrategyForIntent(oTestData.refreshStrategies, oTestData.semanticObject, oTestData.action)).toEqual(oTestData.result);
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+  });
+  describe("Keep Alive Helper Testing - #getViewRefreshInfo", function () {
+    var viewData;
+    var view;
+    var oMockGetStrategy;
+    beforeAll(function () {
+      try {
+        viewData = {};
+        oMockGetStrategy = jest.spyOn(KeepAliveHelper, "getControlRefreshStrategyForContextPath");
+        oMockGetStrategy.mockReturnValue(jest.fn());
+        view = {
+          getViewData: function () {
+            return viewData;
+          }
+        };
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    afterAll(function () {
+      try {
+        viewData = {};
+        jest.restoreAllMocks();
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("With context Path", function () {
+      try {
+        var _viewData;
+
+        // Cases to consider
+        viewData.contextPath = "/SO";
+        KeepAliveHelper.getViewRefreshInfo(view);
+        expect(oMockGetStrategy).toHaveBeenCalledTimes(1);
+        expect(oMockGetStrategy).toHaveBeenLastCalledWith(view, (_viewData = viewData) === null || _viewData === void 0 ? void 0 : _viewData.contextPath);
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("With entitySet", function () {
+      try {
+        var _viewData2;
+
+        // Cases to consider
+        viewData.entitySet = "SO";
+        KeepAliveHelper.getViewRefreshInfo(view);
+        expect(oMockGetStrategy).toHaveBeenCalledTimes(2);
+        expect(oMockGetStrategy).toHaveBeenLastCalledWith(view, "/" + ((_viewData2 = viewData) === null || _viewData2 === void 0 ? void 0 : _viewData2.entitySet));
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+  });
+  describe("Keep Alive Helper Testing - #getControlRefreshStrategyForContextPath", function () {
+    var internal;
+    var control;
+    var defaultModel;
+    var metaModel;
+    var oMockInternalGetProperty;
+    var oMockGetModel;
+    var oMockGetMetaModel;
+    var oMockGetObject;
+    var entitySet;
+    var refreshStrategyToTest;
+    beforeAll(function () {
+      try {
+        internal = new MockModel();
+        control = new MockControl();
+        defaultModel = new MockModel();
+        metaModel = new MockMetaModel(); // mock model
+
+        oMockGetModel = jest.spyOn(control, "getModel");
+        oMockGetModel.mockImplementation(function (name) {
+          if (name === "internal") {
+            return internal;
+          }
+
+          return defaultModel;
+        }); // mock internal model and refresh strategy
+
+        oMockInternalGetProperty = jest.spyOn(internal, "getProperty");
+        oMockInternalGetProperty.mockImplementation(function (sPath) {
+          return sPath === PATH_TO_STORE ? refreshStrategyToTest : undefined;
+        }); // mock metaModel and getObject
+
+        defaultModel.setMetaModel(metaModel);
+        oMockGetObject = jest.spyOn(metaModel, "getObject");
+        oMockGetObject.mockImplementation(function () {
+          return entitySet;
+        });
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    beforeEach(function () {
+      // Clean JSON
+      refreshStrategyToTest = undefined;
+      entitySet = "";
+      return Promise.resolve();
+    });
+    afterAll(function () {
+      try {
+        jest.restoreAllMocks();
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    ControlRefreshStrategyTests.forEach(function (oTestData) {
+      it(oTestData.title, function () {
+        try {
+          // Cases to consider
+          refreshStrategyToTest = oTestData.refreshStrategy;
+          entitySet = oTestData.entitySet;
+          expect(KeepAliveHelper.getControlRefreshStrategyForContextPath(control, oTestData.contextPath)).toEqual(oTestData.result);
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+  });
+  describe("Keep Alive Helper Testing - #getControlsForRefresh", function () {
+    var internal;
+    var aControls;
+    var view;
+    var defaultModel;
+    var metaModel;
+    var oMockInternalGetProperty;
+    var oMockGetModel;
+    var oMockGetMetaModel;
+    var oMockGetObject;
+    var entitySet;
+    var refreshStrategyToTest;
+    beforeAll(function () {
+      try {
+        internal = new MockModel();
+        view = new View();
+        defaultModel = new MockModel();
+        metaModel = new MockMetaModel(); // control mocks
+
+        var control1 = new MockControl();
+        var control2 = new MockControl();
+        var oMockControl1Data = jest.spyOn(control1, "data");
+        oMockControl1Data.mockImplementation(function (sKey) {
+          return sKey === "targetCollectionPath" ? "/SO" : undefined;
+        });
+        var oMockControl2Data = jest.spyOn(control2, "data");
+        oMockControl2Data.mockImplementation(function (sKey) {
+          return sKey === "targetCollectionPath" ? "/SO/_Item" : undefined;
+        });
+        aControls = [control1, control2]; // mock model
+
+        oMockGetModel = jest.spyOn(view, "getModel");
+        oMockGetModel.mockImplementation(function (name) {
+          if (name === "internal") {
+            return internal;
+          }
+
+          return defaultModel;
+        }); // mock internal model and refresh strategy
+
+        oMockInternalGetProperty = jest.spyOn(internal, "getProperty");
+        oMockInternalGetProperty.mockImplementation(function (sPath) {
+          return sPath === PATH_TO_STORE ? refreshStrategyToTest : undefined;
+        }); // mock metaModel and getObject
+
+        defaultModel.setMetaModel(metaModel);
+        oMockGetObject = jest.spyOn(metaModel, "getObject");
+        oMockGetObject.mockImplementation(function () {
+          return entitySet;
+        });
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    beforeEach(function () {
+      // Clean JSON
+      refreshStrategyToTest = undefined;
+      entitySet = "";
+      return Promise.resolve();
+    });
+    afterAll(function () {
+      try {
+        jest.restoreAllMocks();
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    ControlsForRefreshTests.forEach(function (oTestData) {
+      it(oTestData.title, function () {
+        try {
+          // Cases to consider
+          var result = oTestData.resultControlIndices.map(function (idx) {
+            return aControls[idx];
+          });
+          entitySet = oTestData.entitySet;
+          refreshStrategyToTest = oTestData.refreshStrategy;
+          expect(KeepAliveHelper.getControlsForRefresh(view, aControls)).toEqual(result);
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+  });
+  describe("Keep Alive Helper Testing - #restoreView", function () {
+    var internal;
+    var view;
+    var oMockInternalGetProperty;
+    var oMockInternalSetProperty;
+    var oMockBindingContext;
+    var oMockController;
+    var oMockGetId;
+    var oMockInfoLog;
+    var restoreStatus;
+    var spyRefreshResolve = jest.fn();
+    var spyRefreshReject = jest.fn();
+    var spyRestore = jest.fn();
+    var viewState = {};
+    beforeAll(function () {
+      try {
+        internal = new MockContext({});
+        view = new View();
+        spyRefreshResolve.mockResolvedValue({});
+        spyRefreshReject.mockRejectedValue({}); // mock view
+
+        oMockBindingContext = jest.spyOn(view, "getBindingContext");
+        oMockGetId = jest.spyOn(view, "getId");
+        oMockGetId.mockReturnValue("");
+        oMockBindingContext.mockReturnValue(internal);
+        oMockController = jest.spyOn(view, "getController");
+        viewState = {
+          onRestore: spyRestore
+        };
+        oMockController.mockImplementation(function () {
+          return {
+            viewState: viewState
+          };
+        });
+        oMockInternalGetProperty = jest.spyOn(internal, "getProperty");
+        oMockInternalSetProperty = jest.spyOn(internal, "setProperty");
+        oMockInternalGetProperty.mockImplementation(function (prop) {
+          return prop === "restoreStatus" ? restoreStatus : undefined;
+        }); // mock logs
+
+        oMockInfoLog = jest.spyOn(Log, "info");
+        oMockInfoLog.mockImplementation(function (msg) {
+          return msg;
+        });
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    beforeEach(function () {
+      try {
+        // Clean JSON
+        restoreStatus = "";
+        viewState["refreshViewBindings"] = undefined;
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    afterAll(function () {
+      try {
+        jest.restoreAllMocks();
+        return Promise.resolve();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("Refresh not pending", function () {
+      try {
+        restoreStatus = "done";
+        viewState["refreshViewBindings"] = spyRefreshResolve;
+        return Promise.resolve(KeepAliveHelper.restoreView(view)).then(function () {
+          expect(spyRefreshResolve).toHaveBeenCalledTimes(0);
+          expect(spyRestore).toHaveBeenCalledTimes(0);
+          expect(oMockInternalSetProperty).toHaveBeenCalledTimes(0);
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("Refresh pending(no handler) and refresh, restore successfull", function () {
+      try {
+        restoreStatus = "pending";
+        viewState["refreshViewBindings"] = undefined;
+        return Promise.resolve(KeepAliveHelper.restoreView(view)).then(function () {
+          expect(spyRefreshResolve).toHaveBeenCalledTimes(0);
+          expect(spyRefreshReject).toHaveBeenCalledTimes(0);
+          expect(oMockInfoLog).toHaveBeenCalledTimes(0);
+          expect(spyRestore).toHaveBeenCalledTimes(1);
+          expect(oMockInternalSetProperty).toHaveBeenCalledTimes(1);
+          expect(oMockInternalSetProperty).toHaveBeenLastCalledWith("restoreStatus", "done");
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("Refresh pending and refresh, restore successfull", function () {
+      try {
+        restoreStatus = "pending";
+        viewState["refreshViewBindings"] = spyRefreshResolve;
+        return Promise.resolve(KeepAliveHelper.restoreView(view)).then(function () {
+          expect(spyRefreshResolve).toHaveBeenCalledTimes(1);
+          expect(spyRefreshReject).toHaveBeenCalledTimes(0);
+          expect(oMockInfoLog).toHaveBeenCalledTimes(1);
+          expect(spyRestore).toHaveBeenCalledTimes(2);
+          expect(oMockInternalSetProperty).toHaveBeenCalledTimes(2);
+          expect(oMockInternalSetProperty).toHaveBeenLastCalledWith("restoreStatus", "done");
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("Refresh pending and refresh unsuccessfull, restore successfull", function () {
+      try {
+        restoreStatus = "pending";
+        viewState["refreshViewBindings"] = spyRefreshReject;
+        return Promise.resolve(KeepAliveHelper.restoreView(view)).then(function () {
+          expect(spyRefreshResolve).toHaveBeenCalledTimes(1);
+          expect(spyRefreshReject).toHaveBeenCalledTimes(1);
+          expect(oMockInfoLog).toHaveBeenCalledTimes(1);
+          expect(oMockInternalSetProperty).toHaveBeenLastCalledWith("restoreStatus", "done");
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("Refresh pending and refresh successfull, restore unsuccessfull", function () {
+      try {
+        restoreStatus = "pending";
+        viewState["refreshViewBindings"] = spyRefreshResolve;
+        spyRestore.mockImplementation(function () {
+          var error = new Error("restore error");
+          throw error;
+        });
+        return Promise.resolve(KeepAliveHelper.restoreView(view)).then(function () {
+          expect(spyRefreshResolve).toHaveBeenCalledTimes(2);
+          expect(spyRefreshReject).toHaveBeenCalledTimes(1);
+          expect(oMockInfoLog).toHaveBeenCalledTimes(2);
+          expect(spyRestore).toHaveBeenCalledTimes(3);
+          expect(oMockInternalSetProperty).toHaveBeenCalledTimes(2);
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("Refresh pending and refresh and restore unsuccessfull", function () {
+      try {
+        restoreStatus = "pending";
+        viewState["refreshViewBindings"] = spyRefreshReject;
+        spyRestore.mockImplementation(function () {
+          var error = new Error("restore error");
+          throw error;
+        });
+        return Promise.resolve(KeepAliveHelper.restoreView(view)).then(function () {
+          expect(spyRefreshResolve).toHaveBeenCalledTimes(2);
+          expect(spyRefreshReject).toHaveBeenCalledTimes(2);
+          expect(oMockInfoLog).toHaveBeenCalledTimes(2);
+          expect(spyRestore).toHaveBeenCalledTimes(3);
+          expect(oMockInternalSetProperty).toHaveBeenCalledTimes(2);
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["KeepAliveHelper.spec.ts"],"names":["describe","internal","viewData","control","oMockGetModel","oMockInternalSetProperty","oMockViewDataGetProperty","refreshStrategyToTest","beforeAll","MockModel","MockControl","jest","spyOn","mockImplementation","name","sPath","PATH_TO_STORE","undefined","beforeEach","afterAll","restoreAllMocks","StoreStrategyTests","forEach","oTestData","it","title","refreshStrategies","KeepAliveHelper","storeControlRefreshStrategyForHash","hash","expect","toHaveBeenLastCalledWith","result","semanticObject","action","RefreshStrategyForIntentTests","getRefreshStrategyForIntent","toEqual","view","oMockGetStrategy","mockReturnValue","fn","getViewData","contextPath","getViewRefreshInfo","toHaveBeenCalledTimes","entitySet","defaultModel","metaModel","oMockInternalGetProperty","oMockGetMetaModel","oMockGetObject","MockMetaModel","setMetaModel","ControlRefreshStrategyTests","refreshStrategy","getControlRefreshStrategyForContextPath","aControls","View","control1","control2","oMockControl1Data","sKey","oMockControl2Data","ControlsForRefreshTests","resultControlIndices","map","idx","getControlsForRefresh","oMockBindingContext","oMockController","oMockGetId","oMockInfoLog","restoreStatus","spyRefreshResolve","spyRefreshReject","spyRestore","viewState","MockContext","mockResolvedValue","mockRejectedValue","onRestore","prop","Log","msg","restoreView","error","Error"],"mappings":"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","sourceRoot":".","sourcesContent":["import KeepAliveHelper from \"sap/fe/core/helpers/KeepAliveHelper\";\nimport { SORefreshStrategy, RefreshStrategies, PATH_TO_STORE } from \"sap/fe/core/helpers/KeepAliveRefreshTypes\";\nimport { Control } from \"sap/ui/core\";\nimport { View } from \"sap/ui/core/mvc\";\nimport { Log } from \"sap/base\";\nimport { BaseManifestSettings } from \"sap/fe/core/converters/ManifestSettings\";\nimport StoreStrategyTests from \"./KeepAliveHelperTestData/StoreStrategyTests\";\nimport RefreshStrategyForIntentTests from \"./KeepAliveHelperTestData/RefreshStrategyForIntentTests\";\nimport ControlRefreshStrategyTests from \"./KeepAliveHelperTestData/ControlRefreshStrategyTests\";\nimport ControlsForRefreshTests from \"./KeepAliveHelperTestData/ControlsForRefreshTests\";\nimport { MockModel, MockMetaModel, MockControl, MockContext } from \"sap/fe/test/UI5MockHelper\";\n\ndescribe(\"Keep Alive Helper Testing - #storeControlRefreshStrategyForHash\", () => {\n\tlet internal!: MockModel;\n\tlet viewData!: MockModel;\n\tlet control!: MockControl;\n\tlet oMockGetModel!: jest.SpyInstance;\n\tlet oMockInternalSetProperty!: jest.SpyInstance;\n\tlet oMockViewDataGetProperty!: jest.SpyInstance;\n\tlet refreshStrategyToTest!: RefreshStrategies | undefined;\n\n\tbeforeAll(async function() {\n\t\tinternal = new MockModel();\n\t\tviewData = new MockModel();\n\n\t\tcontrol = new MockControl();\n\n\t\t// mock model\n\t\toMockGetModel = jest.spyOn(control, \"getModel\");\n\t\toMockGetModel.mockImplementation(name => {\n\t\t\tif (name === \"internal\") {\n\t\t\t\treturn internal;\n\t\t\t} else if (name === \"viewData\") {\n\t\t\t\treturn viewData;\n\t\t\t}\n\t\t});\n\n\t\toMockInternalSetProperty = jest.spyOn(internal, \"setProperty\");\n\t\toMockViewDataGetProperty = jest.spyOn(viewData, \"getProperty\");\n\t\toMockViewDataGetProperty.mockImplementation(sPath => (sPath === PATH_TO_STORE ? refreshStrategyToTest : undefined));\n\t});\n\tbeforeEach(async function() {\n\t\t// Clean JSON\n\t\trefreshStrategyToTest = {};\n\t});\n\n\tafterAll(async function() {\n\t\tjest.restoreAllMocks();\n\t});\n\n\tStoreStrategyTests.forEach(oTestData => {\n\t\tit(oTestData.title, async () => {\n\t\t\t// Cases to consider\n\t\t\trefreshStrategyToTest = oTestData.refreshStrategies;\n\t\t\tKeepAliveHelper.storeControlRefreshStrategyForHash((control as unknown) as Control, oTestData.hash);\n\t\t\texpect(oMockInternalSetProperty).toHaveBeenLastCalledWith(PATH_TO_STORE, oTestData.result);\n\t\t});\n\t});\n});\n\ndescribe(\"Keep Alive Helper Testing - #getRefreshStrategyForIntent\", () => {\n\tlet refreshStrategies!: RefreshStrategies;\n\tlet semanticObject!: string | undefined;\n\tlet action!: string | undefined;\n\tbeforeEach(async function() {\n\t\t// Clean JSON\n\t\trefreshStrategies = {};\n\t\tsemanticObject = undefined;\n\t\taction = undefined;\n\t});\n\n\tafterAll(async function() {\n\t\tjest.restoreAllMocks();\n\t});\n\n\tRefreshStrategyForIntentTests.forEach(oTestData => {\n\t\tit(oTestData.title, async () => {\n\t\t\t// Cases to consider\n\t\t\texpect(\n\t\t\t\tKeepAliveHelper.getRefreshStrategyForIntent(oTestData.refreshStrategies, oTestData.semanticObject, oTestData.action)\n\t\t\t).toEqual(oTestData.result);\n\t\t});\n\t});\n});\n\ndescribe(\"Keep Alive Helper Testing - #getViewRefreshInfo\", () => {\n\tlet viewData!: BaseManifestSettings;\n\tlet view!: object;\n\tlet oMockGetStrategy!: jest.SpyInstance;\n\tbeforeAll(async function() {\n\t\tviewData = {} as BaseManifestSettings;\n\t\toMockGetStrategy = jest.spyOn(KeepAliveHelper, \"getControlRefreshStrategyForContextPath\");\n\t\toMockGetStrategy.mockReturnValue(jest.fn());\n\n\t\tview = {\n\t\t\tgetViewData: () => viewData\n\t\t};\n\t});\n\n\tafterAll(async function() {\n\t\tviewData = {} as BaseManifestSettings;\n\t\tjest.restoreAllMocks();\n\t});\n\n\tit(\"With context Path\", async () => {\n\t\t// Cases to consider\n\t\tviewData.contextPath = \"/SO\";\n\t\tKeepAliveHelper.getViewRefreshInfo(view as View);\n\t\texpect(oMockGetStrategy).toHaveBeenCalledTimes(1);\n\t\texpect(oMockGetStrategy).toHaveBeenLastCalledWith(view, viewData?.contextPath);\n\t});\n\n\tit(\"With entitySet\", async () => {\n\t\t// Cases to consider\n\t\tviewData.entitySet = \"SO\";\n\t\tKeepAliveHelper.getViewRefreshInfo(view as View);\n\t\texpect(oMockGetStrategy).toHaveBeenCalledTimes(2);\n\t\texpect(oMockGetStrategy).toHaveBeenLastCalledWith(view, \"/\" + viewData?.entitySet);\n\t});\n});\n\ndescribe(\"Keep Alive Helper Testing - #getControlRefreshStrategyForContextPath\", () => {\n\tlet internal!: MockModel;\n\tlet control!: MockControl;\n\tlet defaultModel!: MockModel;\n\tlet metaModel!: MockMetaModel;\n\tlet oMockInternalGetProperty!: jest.SpyInstance;\n\tlet oMockGetModel!: jest.SpyInstance;\n\tlet oMockGetMetaModel!: jest.SpyInstance;\n\tlet oMockGetObject!: jest.SpyInstance;\n\tlet entitySet!: string | undefined;\n\n\tlet refreshStrategyToTest!: SORefreshStrategy | undefined;\n\n\tbeforeAll(async function() {\n\t\tinternal = new MockModel();\n\t\tcontrol = new MockControl();\n\n\t\tdefaultModel = new MockModel();\n\t\tmetaModel = new MockMetaModel();\n\n\t\t// mock model\n\t\toMockGetModel = jest.spyOn(control, \"getModel\");\n\t\toMockGetModel.mockImplementation(name => {\n\t\t\tif (name === \"internal\") {\n\t\t\t\treturn internal;\n\t\t\t}\n\t\t\treturn defaultModel;\n\t\t});\n\n\t\t// mock internal model and refresh strategy\n\t\toMockInternalGetProperty = jest.spyOn(internal, \"getProperty\");\n\t\toMockInternalGetProperty.mockImplementation(sPath => (sPath === PATH_TO_STORE ? refreshStrategyToTest : undefined));\n\n\t\t// mock metaModel and getObject\n\t\tdefaultModel.setMetaModel(metaModel);\n\t\toMockGetObject = jest.spyOn(metaModel, \"getObject\");\n\t\toMockGetObject.mockImplementation(() => entitySet);\n\t});\n\tbeforeEach(async function() {\n\t\t// Clean JSON\n\t\trefreshStrategyToTest = undefined;\n\t\tentitySet = \"\";\n\t});\n\n\tafterAll(async function() {\n\t\tjest.restoreAllMocks();\n\t});\n\n\tControlRefreshStrategyTests.forEach(oTestData => {\n\t\tit(oTestData.title, async () => {\n\t\t\t// Cases to consider\n\t\t\trefreshStrategyToTest = oTestData.refreshStrategy;\n\t\t\tentitySet = oTestData.entitySet;\n\t\t\texpect(KeepAliveHelper.getControlRefreshStrategyForContextPath((control as unknown) as Control, oTestData.contextPath)).toEqual(\n\t\t\t\toTestData.result\n\t\t\t);\n\t\t});\n\t});\n});\n\ndescribe(\"Keep Alive Helper Testing - #getControlsForRefresh\", () => {\n\tlet internal!: MockModel;\n\tlet aControls!: MockControl[];\n\tlet view!: View;\n\tlet defaultModel!: MockModel;\n\tlet metaModel!: MockMetaModel;\n\tlet oMockInternalGetProperty!: jest.SpyInstance;\n\tlet oMockGetModel!: jest.SpyInstance;\n\tlet oMockGetMetaModel!: jest.SpyInstance;\n\tlet oMockGetObject!: jest.SpyInstance;\n\tlet entitySet!: string | undefined;\n\tlet refreshStrategyToTest!: SORefreshStrategy | undefined;\n\n\tbeforeAll(async function() {\n\t\tinternal = new MockModel();\n\t\tview = new View();\n\t\tdefaultModel = new MockModel();\n\t\tmetaModel = new MockMetaModel();\n\n\t\t// control mocks\n\t\tconst control1 = new MockControl();\n\t\tconst control2 = new MockControl();\n\t\tconst oMockControl1Data = jest.spyOn(control1, \"data\");\n\t\toMockControl1Data.mockImplementation(sKey => (sKey === \"targetCollectionPath\" ? \"/SO\" : undefined));\n\t\tconst oMockControl2Data = jest.spyOn(control2, \"data\");\n\t\toMockControl2Data.mockImplementation(sKey => (sKey === \"targetCollectionPath\" ? \"/SO/_Item\" : undefined));\n\t\taControls = [control1, control2];\n\n\t\t// mock model\n\t\toMockGetModel = jest.spyOn(view, \"getModel\");\n\t\toMockGetModel.mockImplementation(name => {\n\t\t\tif (name === \"internal\") {\n\t\t\t\treturn internal;\n\t\t\t}\n\t\t\treturn defaultModel;\n\t\t});\n\n\t\t// mock internal model and refresh strategy\n\t\toMockInternalGetProperty = jest.spyOn(internal, \"getProperty\");\n\t\toMockInternalGetProperty.mockImplementation(sPath => (sPath === PATH_TO_STORE ? refreshStrategyToTest : undefined));\n\n\t\t// mock metaModel and getObject\n\t\tdefaultModel.setMetaModel(metaModel);\n\t\toMockGetObject = jest.spyOn(metaModel, \"getObject\");\n\t\toMockGetObject.mockImplementation(() => entitySet);\n\t});\n\tbeforeEach(async function() {\n\t\t// Clean JSON\n\t\trefreshStrategyToTest = undefined;\n\t\tentitySet = \"\";\n\t});\n\n\tafterAll(async function() {\n\t\tjest.restoreAllMocks();\n\t});\n\n\tControlsForRefreshTests.forEach(oTestData => {\n\t\tit(oTestData.title, async () => {\n\t\t\t// Cases to consider\n\t\t\tconst result: MockControl[] = oTestData.resultControlIndices.map(idx => aControls[idx]);\n\n\t\t\tentitySet = oTestData.entitySet;\n\t\t\trefreshStrategyToTest = oTestData.refreshStrategy;\n\t\t\texpect(KeepAliveHelper.getControlsForRefresh(view, (aControls as unknown) as Control[])).toEqual(result);\n\t\t});\n\t});\n});\n\ndescribe(\"Keep Alive Helper Testing - #restoreView\", () => {\n\tlet internal!: MockContext;\n\tlet view!: View;\n\tlet oMockInternalGetProperty!: jest.SpyInstance;\n\tlet oMockInternalSetProperty!: jest.SpyInstance;\n\tlet oMockBindingContext!: jest.SpyInstance;\n\tlet oMockController!: jest.SpyInstance;\n\tlet oMockGetId!: jest.SpyInstance;\n\tlet oMockInfoLog!: jest.SpyInstance;\n\tlet restoreStatus!: string;\n\tconst spyRefreshResolve: jest.Mock = jest.fn();\n\tconst spyRefreshReject: jest.Mock = jest.fn();\n\tconst spyRestore: jest.Mock = jest.fn();\n\tlet viewState: any = {};\n\tbeforeAll(async function() {\n\t\tinternal = new MockContext({});\n\t\tview = new View();\n\t\tspyRefreshResolve.mockResolvedValue({});\n\t\tspyRefreshReject.mockRejectedValue({});\n\n\t\t// mock view\n\t\toMockBindingContext = jest.spyOn(view, \"getBindingContext\");\n\t\toMockGetId = jest.spyOn(view, \"getId\");\n\t\toMockGetId.mockReturnValue(\"\");\n\t\toMockBindingContext.mockReturnValue(internal);\n\t\toMockController = jest.spyOn(view, \"getController\");\n\t\tviewState = {\n\t\t\tonRestore: spyRestore\n\t\t};\n\t\toMockController.mockImplementation(() => ({\n\t\t\tviewState: viewState\n\t\t}));\n\n\t\toMockInternalGetProperty = jest.spyOn(internal, \"getProperty\");\n\t\toMockInternalSetProperty = jest.spyOn(internal, \"setProperty\");\n\t\toMockInternalGetProperty.mockImplementation(prop => (prop === \"restoreStatus\" ? restoreStatus : undefined));\n\n\t\t// mock logs\n\t\toMockInfoLog = jest.spyOn(Log, \"info\");\n\t\toMockInfoLog.mockImplementation(msg => msg);\n\t});\n\tbeforeEach(async function() {\n\t\t// Clean JSON\n\t\trestoreStatus = \"\";\n\t\tviewState[\"refreshViewBindings\"] = undefined;\n\t});\n\n\tafterAll(async function() {\n\t\tjest.restoreAllMocks();\n\t});\n\tit(\"Refresh not pending\", async () => {\n\t\trestoreStatus = \"done\";\n\t\tviewState[\"refreshViewBindings\"] = spyRefreshResolve;\n\n\t\tawait KeepAliveHelper.restoreView(view);\n\t\texpect(spyRefreshResolve).toHaveBeenCalledTimes(0);\n\t\texpect(spyRestore).toHaveBeenCalledTimes(0);\n\t\texpect(oMockInternalSetProperty).toHaveBeenCalledTimes(0);\n\t});\n\tit(\"Refresh pending(no handler) and refresh, restore successfull\", async () => {\n\t\trestoreStatus = \"pending\";\n\t\tviewState[\"refreshViewBindings\"] = undefined;\n\t\tawait KeepAliveHelper.restoreView(view);\n\n\t\texpect(spyRefreshResolve).toHaveBeenCalledTimes(0);\n\t\texpect(spyRefreshReject).toHaveBeenCalledTimes(0);\n\t\texpect(oMockInfoLog).toHaveBeenCalledTimes(0);\n\t\texpect(spyRestore).toHaveBeenCalledTimes(1);\n\t\texpect(oMockInternalSetProperty).toHaveBeenCalledTimes(1);\n\t\texpect(oMockInternalSetProperty).toHaveBeenLastCalledWith(\"restoreStatus\", \"done\");\n\t});\n\tit(\"Refresh pending and refresh, restore successfull\", async () => {\n\t\trestoreStatus = \"pending\";\n\t\tviewState[\"refreshViewBindings\"] = spyRefreshResolve;\n\t\tawait KeepAliveHelper.restoreView(view);\n\n\t\texpect(spyRefreshResolve).toHaveBeenCalledTimes(1);\n\t\texpect(spyRefreshReject).toHaveBeenCalledTimes(0);\n\t\texpect(oMockInfoLog).toHaveBeenCalledTimes(1);\n\t\texpect(spyRestore).toHaveBeenCalledTimes(2);\n\t\texpect(oMockInternalSetProperty).toHaveBeenCalledTimes(2);\n\t\texpect(oMockInternalSetProperty).toHaveBeenLastCalledWith(\"restoreStatus\", \"done\");\n\t});\n\n\tit(\"Refresh pending and refresh unsuccessfull, restore successfull\", async () => {\n\t\trestoreStatus = \"pending\";\n\t\tviewState[\"refreshViewBindings\"] = spyRefreshReject;\n\t\tawait KeepAliveHelper.restoreView(view);\n\n\t\texpect(spyRefreshResolve).toHaveBeenCalledTimes(1);\n\t\texpect(spyRefreshReject).toHaveBeenCalledTimes(1);\n\t\texpect(oMockInfoLog).toHaveBeenCalledTimes(1);\n\t\texpect(oMockInternalSetProperty).toHaveBeenLastCalledWith(\"restoreStatus\", \"done\");\n\t});\n\n\tit(\"Refresh pending and refresh successfull, restore unsuccessfull\", async () => {\n\t\trestoreStatus = \"pending\";\n\t\tviewState[\"refreshViewBindings\"] = spyRefreshResolve;\n\t\tspyRestore.mockImplementation(() => {\n\t\t\tconst error = new Error(\"restore error\");\n\t\t\tthrow error;\n\t\t});\n\t\tawait KeepAliveHelper.restoreView(view);\n\n\t\texpect(spyRefreshResolve).toHaveBeenCalledTimes(2);\n\t\texpect(spyRefreshReject).toHaveBeenCalledTimes(1);\n\t\texpect(oMockInfoLog).toHaveBeenCalledTimes(2);\n\t\texpect(spyRestore).toHaveBeenCalledTimes(3);\n\t\texpect(oMockInternalSetProperty).toHaveBeenCalledTimes(2);\n\t});\n\n\tit(\"Refresh pending and refresh and restore unsuccessfull\", async () => {\n\t\trestoreStatus = \"pending\";\n\t\tviewState[\"refreshViewBindings\"] = spyRefreshReject;\n\t\tspyRestore.mockImplementation(() => {\n\t\t\tconst error = new Error(\"restore error\");\n\t\t\tthrow error;\n\t\t});\n\t\tawait KeepAliveHelper.restoreView(view);\n\n\t\texpect(spyRefreshResolve).toHaveBeenCalledTimes(2);\n\t\texpect(spyRefreshReject).toHaveBeenCalledTimes(2);\n\t\texpect(oMockInfoLog).toHaveBeenCalledTimes(2);\n\t\texpect(spyRestore).toHaveBeenCalledTimes(3);\n\t\texpect(oMockInternalSetProperty).toHaveBeenCalledTimes(2);\n\t});\n});\n"]}