@sap/open.fe 1.97.0 → 1.98.0

package/packages/sap.fe.macros/test/sap/fe/macros/jest/field/FieldRuntime.spec.js

@@ -2,115 +2,306 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2021 SAP SE. All rights reserved
  */
-sap.ui.define(["sap/fe/macros/field/FieldRuntime", "sap/m/MessageBox", "sap/fe/macros/ResourceModel"], function (FieldRuntime, MessageBox, ResourceModel) {
+sap.ui.define(["sap/base/Log", "sap/m/MessageBox", "sap/ui/core/Control", "sap/fe/macros/field/FieldRuntime", "sap/fe/macros/ResourceModel", "sap/fe/macros/DelegateUtil", "sap/fe/core/BusyLocker", "sap/fe/core/CommonUtils", "sap/fe/core/helpers/ModelHelper", "sap/fe/test/UI5MockHelper"], function (Log, MessageBox, Control, FieldRuntime, ResourceModel, DelegateUtil, BusyLocker, CommonUtils, ModelHelper, UI5MockHelper) {
   "use strict";
 
+  var mockMVC = UI5MockHelper.mockMVC;
+  var MockEvent = UI5MockHelper.MockEvent;
+  var MockUI5Element = UI5MockHelper.MockUI5Element;
+
   describe("FieldRuntime", function () {
-    // replacing the relevant functions with a mock
-    var messageBoxErrorMock = jest.fn();
-    MessageBox.error = messageBoxErrorMock;
-    var resourceBundleText = "The message text";
-    var resourceModelGetTextMock = jest.fn(function () {
-      return resourceBundleText;
+    var messageBoxErrorMock = jest.fn(); // mocked MVC for testing
+
+    var _mockMVC = mockMVC(),
+        model = _mockMVC.model,
+        view = _mockMVC.view,
+        controller = _mockMVC.controller;
+
+    beforeAll(function () {
+      // replace static functions with mocks
+      ResourceModel.getText = jest.fn(function (key) {
+        return key;
+      });
+      Log.error = jest.fn();
+      MessageBox.error = messageBoxErrorMock;
+      CommonUtils.getTargetView = jest.fn(function (oSource) {
+        return oSource.getView();
+      });
+      CommonUtils.fnProcessDataLossOrDraftDiscardConfirmation = jest.fn(function (processCB, cancelCB, context) {
+        processCB(context);
+      });
+      ModelHelper.isStickySessionSupported = jest.fn().mockReturnValue(false);
     });
-    ResourceModel.getText = resourceModelGetTextMock;
-    describe("handleUploadComplete", function () {
-      // generate a MockEvent as input for the tests
-      function getMockEvent(parameters) {
-        return {
-          getParameter: jest.fn(function (name) {
-            return parameters[name];
-          }),
-          getSource: jest.fn(function () {
-            return mockFileUploader;
-          })
+    afterAll(function () {
+      // reset all counters
+      jest.resetAllMocks();
+    });
+    afterEach(function () {
+      // remove all mocks
+      jest.clearAllMocks();
+    });
+    describe("formatDraftOwnerTextInPopover", function () {
+      var pUser = "~processUser";
+      var cUser = "~changeUser";
+      var pDesc = "~processUserDescription";
+      var cDesc = "~changeUserDescription";
+      it("No draft", function () {
+        var text = FieldRuntime.formatDraftOwnerTextInPopover(false, "", "", "", "");
+        expect(text).toBe("M_FIELD_RUNTIME_DRAFT_POPOVER_NO_DATA_TEXT");
+      });
+      it("Unsaved changes by unknown user", function () {
+        var text = FieldRuntime.formatDraftOwnerTextInPopover(true, "", "", "", "");
+        expect(text).toBe("M_FIELD_RUNTIME_DRAFT_POPOVER_UNSAVED_CHANGES_BY_UNKNOWN");
+      });
+      it("Unsaved changes by known user", function () {
+        var text = FieldRuntime.formatDraftOwnerTextInPopover(true, "", cUser, "", cDesc);
+        expect(text).toBe("M_FIELD_RUNTIME_DRAFT_POPOVER_UNSAVED_CHANGES_BY_KNOWN");
+      });
+      it("Locked by known user", function () {
+        var text = FieldRuntime.formatDraftOwnerTextInPopover(true, pUser, cUser, pDesc, cDesc);
+        expect(text).toBe("M_FIELD_RUNTIME_DRAFT_POPOVER_LOCKED_BY_KNOWN");
+      });
+    });
+    describe("onDataFieldWithNavigationPath", function () {
+      var mockSource = new MockUI5Element();
+      mockSource.getView = jest.fn().mockReturnValue(view);
+      mockSource.bindingContext.getModel.mockReturnValue(model);
+      it("Routing not defined", function () {
+        FieldRuntime.onDataFieldWithNavigationPath({}, {}, "");
+        expect(Log.error).toBeCalled();
+      });
+      it("StandardRouting", function () {
+        view.getViewData.mockReturnValueOnce({});
+        FieldRuntime.onDataFieldWithNavigationPath(mockSource, controller, "~semanticObject");
+        expect(controller._routing.navigateToTarget).toBeCalled();
+      });
+      it("Special case ObjectPage", function () {
+        view.getViewData.mockReturnValueOnce({
+          converterType: "ObjectPage"
+        });
+        FieldRuntime.onDataFieldWithNavigationPath(mockSource, controller, "~semanticObject");
+        expect(controller._routing.navigateToTarget).toBeCalled();
+        expect(CommonUtils.fnProcessDataLossOrDraftDiscardConfirmation).toBeCalled();
+      });
+    });
+    describe("hasTargets", function () {
+      // For the records: FieldRuntime.hasTargets seems to be rather useless
+      it("", function () {
+        expect(FieldRuntime.hasTargets(true, "")).toBe(true);
+        expect(FieldRuntime.hasTargets(false, "")).toBe(false);
+      });
+    });
+    describe("handleChange", function () {
+      var event = new MockEvent();
+      it("minimal input", function () {
+        FieldRuntime.handleChange(controller, event);
+        expect(controller._editFlow.syncTask).toBeCalled();
+        expect(controller._sideEffects.handleFieldChange).toBeCalled();
+      });
+      it("ExtensionAPI", function () {
+        var controllerExtension = {
+          _controller: controller,
+          isA: function () {
+            return true;
+          }
         };
-      }
-
-      var mockFileUploader = {
-        getBindingContext: jest.fn(function () {
-          return mockContext;
-        }),
-        getValue: jest.fn(function () {
-          return "filename";
-        })
+        FieldRuntime.handleChange(controllerExtension, event);
+        expect(controller._editFlow.syncTask).toBeCalled();
+        expect(controller._sideEffects.handleFieldChange).toBeCalled();
+      });
+      it("transient change", function () {
+        var mockSource = new MockUI5Element();
+        mockSource.bindingContext.isTransient.mockReturnValueOnce(true);
+        event.getSource.mockReturnValueOnce(mockSource);
+        FieldRuntime.handleChange(controller, event);
+        expect(controller._editFlow.syncTask).toBeCalled();
+        expect(controller._sideEffects.handleFieldChange).not.toBeCalled();
+      });
+    });
+    describe("handleUploadComplete", function () {
+      var field = {
+        invalidate: jest.fn()
       };
+      var fieldRuntimeGetControlByIdOriginal = FieldRuntime.getControlById;
+      var fieldRuntimeGetControlByIdMock = jest.fn(function () {
+        return field;
+      });
+      var fieldRuntimeLockControlOriginal = FieldRuntime.lockControl;
+      var fieldRuntimeLockControlMock = jest.fn(); // generate a MockEvent as input for the tests
+
       var mockContext = {
         requestSideEffects: jest.fn(),
-        setProperty: jest.fn()
+        setProperty: jest.fn(),
+        isTransient: jest.fn(function () {
+          return false;
+        })
       };
-      afterEach(function () {
-        messageBoxErrorMock.mockClear();
+      var mockFileUploader = new MockUI5Element();
+      mockFileUploader.getBindingContext.mockReturnValue(mockContext);
+      mockFileUploader.getValue = jest.fn().mockReturnValue("filename");
+      var delegateUtilGetCustomDataMock = jest.fn(function () {
+        return "fieldWrapperId";
+      });
+      DelegateUtil.getCustomData = delegateUtilGetCustomDataMock;
+      mockFileUploader.getId = jest.fn().mockReturnValue("id");
+      beforeEach(function () {
+        var fieldRuntimeUploadPromisesMock = {
+          "id": {
+            resolve: jest.fn(function () {
+              return true;
+            }),
+            reject: jest.fn(function () {
+              return false;
+            })
+          }
+        };
+        FieldRuntime.uploadPromises = fieldRuntimeUploadPromisesMock;
+      });
+      beforeAll(function () {
+        // replacing the relevant functions with a mock
+        FieldRuntime.getControlById = fieldRuntimeGetControlByIdMock;
+        FieldRuntime.lockControl = fieldRuntimeLockControlMock;
+      });
+      afterAll(function () {
+        // clean up and restore original functions
+        FieldRuntime.getControlById = fieldRuntimeGetControlByIdOriginal;
+        FieldRuntime.lockControl = fieldRuntimeLockControlOriginal;
       });
       it("test for successful upload and calling setProperty and requestSideEffects", function () {
-        var event = getMockEvent({
-          status: 204
-        });
-        FieldRuntime.handleUploadComplete(event, "propertyName");
+        var event = new MockEvent({
+          status: 204,
+          headers: {
+            etag: undefined
+          }
+        }, mockFileUploader);
+        FieldRuntime.handleUploadComplete(event, "propertyName", controller);
         expect(messageBoxErrorMock).toBeCalledTimes(0);
-        expect(event.getSource).toBeCalledTimes(1);
-        expect(mockFileUploader.getBindingContext).toBeCalledTimes(1);
-        expect(mockContext.setProperty).toBeCalledTimes(1);
+        expect(event.getSource).toBeCalledTimes(2);
+        expect(mockFileUploader.getBindingContext).toBeCalledTimes(2);
         expect(mockContext.setProperty).toBeCalledWith("propertyName", "filename");
         expect(mockFileUploader.getValue).toBeCalledTimes(1);
-        expect(mockContext.requestSideEffects).toBeCalledTimes(1);
+        expect(fieldRuntimeLockControlMock).toBeCalledTimes(1);
+        expect(controller._sideEffects.handleFieldChange).toBeCalledTimes(1);
+      });
+      it("test for successful upload with etag", function () {
+        var event = new MockEvent({
+          status: 204,
+          headers: {
+            etag: "XYZ"
+          }
+        }, mockFileUploader);
+        FieldRuntime.handleUploadComplete(event, "propertyName", controller);
+        expect(mockContext.setProperty).toBeCalledWith("@odata.etag", "XYZ", null);
       });
       it("test handling for error 423 with JSON response", function () {
         var message = "The error text";
-        var event = getMockEvent({
+        var event = new MockEvent({
           status: 423,
           responseRaw: JSON.stringify({
             error: {
               message: message
             }
           })
-        });
-        FieldRuntime.handleUploadComplete(event, "");
+        }, mockFileUploader);
+        FieldRuntime.handleUploadComplete(event, "propertyName", controller);
         expect(messageBoxErrorMock).toBeCalledTimes(1);
         expect(messageBoxErrorMock).toBeCalledWith(message);
-        expect(event.getSource).not.toBeCalled();
+        expect(mockContext.setProperty).not.toBeCalled();
+        expect(mockFileUploader.getValue).not.toBeCalled();
+        expect(mockContext.requestSideEffects).not.toBeCalled();
+        expect(fieldRuntimeLockControlMock).toBeCalledTimes(1);
       });
       it("test handling for error 500 with HTML response", function () {
         var message = '<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="utf-8">\n<title>Error</title>\n</head>\n<body>\n<pre>Error: read ECONNRESET<br> &nbsp; &nbsp;at TLSWrap.onStreamRead (internal/stream_base_commons.js:209:20)</pre>\n</body>\n</html>\n';
-        var event = getMockEvent({
+        var event = new MockEvent({
           status: 500,
           responseRaw: message
-        });
-        FieldRuntime.handleUploadComplete(event, "");
+        }, mockFileUploader);
+        FieldRuntime.handleUploadComplete(event, "", controller);
         expect(messageBoxErrorMock).toBeCalledTimes(1);
         expect(messageBoxErrorMock).toBeCalledWith(message);
-        expect(event.getSource).not.toBeCalled();
+        expect(mockContext.setProperty).not.toBeCalled();
+        expect(mockFileUploader.getValue).not.toBeCalled();
+        expect(mockContext.requestSideEffects).not.toBeCalled();
+        expect(fieldRuntimeLockControlMock).toBeCalledTimes(1);
       });
       it("test handling for error 403 with String response", function () {
         var message = "CSRF token is invalid";
-        var event = getMockEvent({
+        var event = new MockEvent({
           status: 403,
           responseRaw: message
-        });
-        FieldRuntime.handleUploadComplete(event, "");
+        }, mockFileUploader);
+        FieldRuntime.handleUploadComplete(event, "", controller);
         expect(messageBoxErrorMock).toBeCalledTimes(1);
         expect(messageBoxErrorMock).toBeCalledWith(message);
-        expect(event.getSource).not.toBeCalled();
+        expect(mockContext.setProperty).not.toBeCalled();
+        expect(mockFileUploader.getValue).not.toBeCalled();
+        expect(mockContext.requestSideEffects).not.toBeCalled();
+        expect(fieldRuntimeLockControlMock).toBeCalledTimes(1);
       });
       it("test handling for error 0 with no response", function () {
         var message = "";
-        var event = getMockEvent({
+        var event = new MockEvent({
           status: 0,
           responseRaw: message
-        });
-        FieldRuntime.handleUploadComplete(event, "");
+        }, mockFileUploader);
+        FieldRuntime.handleUploadComplete(event, "", controller);
         expect(messageBoxErrorMock).toBeCalledTimes(1);
-        expect(messageBoxErrorMock).toBeCalledWith(resourceBundleText);
-        expect(event.getSource).not.toBeCalled();
+        expect(messageBoxErrorMock).toBeCalledWith("M_FIELD_FILEUPLOADER_ABORTED_TEXT");
+        expect(mockContext.setProperty).not.toBeCalled();
+        expect(mockFileUploader.getValue).not.toBeCalled();
+        expect(mockContext.requestSideEffects).not.toBeCalled();
+        expect(fieldRuntimeLockControlMock).toBeCalledTimes(1);
       });
     });
-    describe("handleUploadAborted", function () {
-      it("test handling for aborted upload", function () {
-        FieldRuntime.handleUploadAborted();
-        expect(messageBoxErrorMock).toBeCalledTimes(1);
-        expect(messageBoxErrorMock).toBeCalledWith(resourceBundleText);
+    describe("lockControl", function () {
+      var control = new Control();
+      it("unlock busy control", function () {
+        BusyLocker.lock(control);
+        FieldRuntime.lockControl(control, false);
+        expect(control.getBusy()).toEqual(false);
+      });
+      it("lock busy control", function () {
+        BusyLocker.lock(control);
+        FieldRuntime.lockControl(control, true);
+        expect(control.getBusy()).toEqual(true);
+        BusyLocker.unlock(control);
+      });
+      it("lock not-busy control", function () {
+        FieldRuntime.lockControl(control, true);
+        expect(control.getBusy()).toEqual(true);
+        BusyLocker.unlock(control);
+      });
+      it("unlock not-busy control", function () {
+        FieldRuntime.lockControl(control, false);
+        expect(control.getBusy()).toEqual(false);
+      });
+    });
+    describe("removeStream", function () {
+      var source = new MockUI5Element();
+      source.getParent.mockReturnValue({
+        getItems: jest.fn(function () {
+          return [{
+            isA: jest.fn(function () {
+              return false;
+            })
+          }, {
+            isA: jest.fn(function () {
+              return true;
+            })
+          }, {
+            isA: jest.fn(function () {
+              return false;
+            })
+          }];
+        })
+      });
+      var mockEvent = new MockEvent({}, source);
+      it("test handling for delete file", function () {
+        FieldRuntime.removeStream(mockEvent, "propertyName", controller);
+        expect(controller._sideEffects.handleFieldChange).toBeCalledTimes(1);
       });
     });
   });
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["FieldRuntime.spec.ts"],"names":["describe","messageBoxErrorMock","jest","fn","MessageBox","error","resourceBundleText","resourceModelGetTextMock","ResourceModel","getText","getMockEvent","parameters","getParameter","name","getSource","mockFileUploader","getBindingContext","mockContext","getValue","requestSideEffects","setProperty","afterEach","mockClear","it","event","status","FieldRuntime","handleUploadComplete","expect","toBeCalledTimes","toBeCalledWith","message","responseRaw","JSON","stringify","not","toBeCalled","handleUploadAborted"],"mappings":"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","sourceRoot":".","sourcesContent":["import { FieldRuntime } from \"sap/fe/macros/field\";\nimport { MessageBox } from \"sap/m\";\nimport { Event } from \"sap/ui/base\";\nimport { ResourceModel } from \"sap/fe/macros\";\n\ndescribe(\"FieldRuntime\", () => {\n\t// replacing the relevant functions with a mock\n\tconst messageBoxErrorMock = jest.fn();\n\tMessageBox.error = messageBoxErrorMock;\n\n\tconst resourceBundleText = \"The message text\";\n\tconst resourceModelGetTextMock = jest.fn(() => resourceBundleText);\n\tResourceModel.getText = resourceModelGetTextMock;\n\n\tdescribe(\"handleUploadComplete\", () => {\n\t\t// generate a MockEvent as input for the tests\n\t\tfunction getMockEvent(parameters: any): Partial<Event> {\n\t\t\treturn {\n\t\t\t\tgetParameter: jest.fn(name => parameters[name]),\n\t\t\t\tgetSource: jest.fn((): any => {\n\t\t\t\t\treturn mockFileUploader;\n\t\t\t\t})\n\t\t\t};\n\t\t}\n\t\tconst mockFileUploader = {\n\t\t\tgetBindingContext: jest.fn((): any => {\n\t\t\t\treturn mockContext;\n\t\t\t}),\n\t\t\tgetValue: jest.fn(() => \"filename\")\n\t\t};\n\t\tconst mockContext = {\n\t\t\trequestSideEffects: jest.fn(),\n\t\t\tsetProperty: jest.fn()\n\t\t};\n\n\t\tafterEach(() => {\n\t\t\tmessageBoxErrorMock.mockClear();\n\t\t});\n\n\t\tit(\"test for successful upload and calling setProperty and requestSideEffects\", () => {\n\t\t\tconst event = getMockEvent({\n\t\t\t\tstatus: 204\n\t\t\t});\n\t\t\tFieldRuntime.handleUploadComplete(event, \"propertyName\");\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(0);\n\t\t\texpect(event.getSource).toBeCalledTimes(1);\n\t\t\texpect(mockFileUploader.getBindingContext).toBeCalledTimes(1);\n\t\t\texpect(mockContext.setProperty).toBeCalledTimes(1);\n\t\t\texpect(mockContext.setProperty).toBeCalledWith(\"propertyName\", \"filename\");\n\t\t\texpect(mockFileUploader.getValue).toBeCalledTimes(1);\n\t\t\texpect(mockContext.requestSideEffects).toBeCalledTimes(1);\n\t\t});\n\n\t\tit(\"test handling for error 423 with JSON response\", () => {\n\t\t\tconst message = \"The error text\";\n\t\t\tconst event = getMockEvent({\n\t\t\t\tstatus: 423,\n\t\t\t\tresponseRaw: JSON.stringify({\n\t\t\t\t\terror: {\n\t\t\t\t\t\tmessage\n\t\t\t\t\t}\n\t\t\t\t})\n\t\t\t});\n\t\t\tFieldRuntime.handleUploadComplete(event, \"\");\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(1);\n\t\t\texpect(messageBoxErrorMock).toBeCalledWith(message);\n\t\t\texpect(event.getSource).not.toBeCalled();\n\t\t});\n\n\t\tit(\"test handling for error 500 with HTML response\", () => {\n\t\t\tconst message =\n\t\t\t\t'<!DOCTYPE html>\\n<html lang=\"en\">\\n<head>\\n<meta charset=\"utf-8\">\\n<title>Error</title>\\n</head>\\n<body>\\n<pre>Error: read ECONNRESET<br> &nbsp; &nbsp;at TLSWrap.onStreamRead (internal/stream_base_commons.js:209:20)</pre>\\n</body>\\n</html>\\n';\n\t\t\tconst event = getMockEvent({\n\t\t\t\tstatus: 500,\n\t\t\t\tresponseRaw: message\n\t\t\t});\n\t\t\tFieldRuntime.handleUploadComplete(event, \"\");\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(1);\n\t\t\texpect(messageBoxErrorMock).toBeCalledWith(message);\n\t\t\texpect(event.getSource).not.toBeCalled();\n\t\t});\n\n\t\tit(\"test handling for error 403 with String response\", () => {\n\t\t\tconst message = \"CSRF token is invalid\";\n\t\t\tconst event = getMockEvent({\n\t\t\t\tstatus: 403,\n\t\t\t\tresponseRaw: message\n\t\t\t});\n\t\t\tFieldRuntime.handleUploadComplete(event, \"\");\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(1);\n\t\t\texpect(messageBoxErrorMock).toBeCalledWith(message);\n\t\t\texpect(event.getSource).not.toBeCalled();\n\t\t});\n\n\t\tit(\"test handling for error 0 with no response\", () => {\n\t\t\tconst message = \"\";\n\t\t\tconst event = getMockEvent({\n\t\t\t\tstatus: 0,\n\t\t\t\tresponseRaw: message\n\t\t\t});\n\t\t\tFieldRuntime.handleUploadComplete(event, \"\");\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(1);\n\t\t\texpect(messageBoxErrorMock).toBeCalledWith(resourceBundleText);\n\t\t\texpect(event.getSource).not.toBeCalled();\n\t\t});\n\t});\n\n\tdescribe(\"handleUploadAborted\", () => {\n\t\tit(\"test handling for aborted upload\", () => {\n\t\t\tFieldRuntime.handleUploadAborted();\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(1);\n\t\t\texpect(messageBoxErrorMock).toBeCalledWith(resourceBundleText);\n\t\t});\n\t});\n});\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["FieldRuntime.spec.ts"],"names":["describe","messageBoxErrorMock","jest","fn","mockMVC","model","view","controller","beforeAll","ResourceModel","getText","key","Log","error","MessageBox","CommonUtils","getTargetView","oSource","getView","fnProcessDataLossOrDraftDiscardConfirmation","processCB","cancelCB","context","ModelHelper","isStickySessionSupported","mockReturnValue","afterAll","resetAllMocks","afterEach","clearAllMocks","pUser","cUser","pDesc","cDesc","it","text","FieldRuntime","formatDraftOwnerTextInPopover","expect","toBe","mockSource","MockUI5Element","bindingContext","getModel","onDataFieldWithNavigationPath","toBeCalled","getViewData","mockReturnValueOnce","_routing","navigateToTarget","converterType","hasTargets","event","MockEvent","handleChange","_editFlow","syncTask","_sideEffects","handleFieldChange","controllerExtension","_controller","isA","isTransient","getSource","not","field","invalidate","fieldRuntimeGetControlByIdOriginal","getControlById","fieldRuntimeGetControlByIdMock","fieldRuntimeLockControlOriginal","lockControl","fieldRuntimeLockControlMock","mockContext","requestSideEffects","setProperty","mockFileUploader","getBindingContext","getValue","delegateUtilGetCustomDataMock","DelegateUtil","getCustomData","getId","beforeEach","fieldRuntimeUploadPromisesMock","resolve","reject","uploadPromises","status","headers","etag","undefined","handleUploadComplete","toBeCalledTimes","toBeCalledWith","message","responseRaw","JSON","stringify","control","Control","BusyLocker","lock","getBusy","toEqual","unlock","source","getParent","getItems","mockEvent","removeStream"],"mappings":"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","sourceRoot":".","sourcesContent":["import { Log } from \"sap/base\";\nimport { MessageBox } from \"sap/m\";\nimport { Control } from \"sap/ui/core\";\n\nimport { FieldRuntime } from \"sap/fe/macros/field\";\nimport { ResourceModel, DelegateUtil } from \"sap/fe/macros\";\nimport { BusyLocker, CommonUtils } from \"sap/fe/core\";\nimport { ModelHelper } from \"sap/fe/core/helpers\";\nimport { MockUI5Element, MockEvent, mockMVC } from \"sap/fe/test/UI5MockHelper\";\nimport { ODataModel } from \"sap/ui/model/odata/v4\";\n\ndescribe(\"FieldRuntime\", () => {\n\tconst messageBoxErrorMock = jest.fn();\n\n\t// mocked MVC for testing\n\tconst { model, view, controller } = mockMVC();\n\n\tbeforeAll(() => {\n\t\t// replace static functions with mocks\n\t\tResourceModel.getText = jest.fn((key: string) => key);\n\t\tLog.error = jest.fn();\n\t\tMessageBox.error = messageBoxErrorMock;\n\t\tCommonUtils.getTargetView = jest.fn(oSource => {\n\t\t\treturn oSource.getView();\n\t\t});\n\t\tCommonUtils.fnProcessDataLossOrDraftDiscardConfirmation = jest.fn((processCB, cancelCB, context) => {\n\t\t\tprocessCB(context);\n\t\t});\n\t\tModelHelper.isStickySessionSupported = jest.fn().mockReturnValue(false);\n\t});\n\n\tafterAll(() => {\n\t\t// reset all counters\n\t\tjest.resetAllMocks();\n\t});\n\n\tafterEach(() => {\n\t\t// remove all mocks\n\t\tjest.clearAllMocks();\n\t});\n\n\tdescribe(\"formatDraftOwnerTextInPopover\", () => {\n\t\tconst pUser = \"~processUser\";\n\t\tconst cUser = \"~changeUser\";\n\t\tconst pDesc = \"~processUserDescription\";\n\t\tconst cDesc = \"~changeUserDescription\";\n\n\t\tit(\"No draft\", () => {\n\t\t\tconst text = FieldRuntime.formatDraftOwnerTextInPopover(false, \"\", \"\", \"\", \"\");\n\t\t\texpect(text).toBe(\"M_FIELD_RUNTIME_DRAFT_POPOVER_NO_DATA_TEXT\");\n\t\t});\n\n\t\tit(\"Unsaved changes by unknown user\", () => {\n\t\t\tconst text = FieldRuntime.formatDraftOwnerTextInPopover(true, \"\", \"\", \"\", \"\");\n\t\t\texpect(text).toBe(\"M_FIELD_RUNTIME_DRAFT_POPOVER_UNSAVED_CHANGES_BY_UNKNOWN\");\n\t\t});\n\n\t\tit(\"Unsaved changes by known user\", () => {\n\t\t\tconst text = FieldRuntime.formatDraftOwnerTextInPopover(true, \"\", cUser, \"\", cDesc);\n\t\t\texpect(text).toBe(\"M_FIELD_RUNTIME_DRAFT_POPOVER_UNSAVED_CHANGES_BY_KNOWN\");\n\t\t});\n\n\t\tit(\"Locked by known user\", () => {\n\t\t\tconst text = FieldRuntime.formatDraftOwnerTextInPopover(true, pUser, cUser, pDesc, cDesc);\n\t\t\texpect(text).toBe(\"M_FIELD_RUNTIME_DRAFT_POPOVER_LOCKED_BY_KNOWN\");\n\t\t});\n\t});\n\n\tdescribe(\"onDataFieldWithNavigationPath\", () => {\n\t\tconst mockSource = new MockUI5Element();\n\t\tmockSource.getView = jest.fn().mockReturnValue(view);\n\t\tmockSource.bindingContext.getModel.mockReturnValue((model as any) as ODataModel);\n\n\t\tit(\"Routing not defined\", () => {\n\t\t\tFieldRuntime.onDataFieldWithNavigationPath({}, {}, \"\");\n\t\t\texpect(Log.error).toBeCalled();\n\t\t});\n\n\t\tit(\"StandardRouting\", () => {\n\t\t\tview.getViewData.mockReturnValueOnce({});\n\t\t\tFieldRuntime.onDataFieldWithNavigationPath(mockSource, controller, \"~semanticObject\");\n\t\t\texpect(controller._routing.navigateToTarget).toBeCalled();\n\t\t});\n\n\t\tit(\"Special case ObjectPage\", () => {\n\t\t\tview.getViewData.mockReturnValueOnce({ converterType: \"ObjectPage\" });\n\t\t\tFieldRuntime.onDataFieldWithNavigationPath(mockSource, controller, \"~semanticObject\");\n\t\t\texpect(controller._routing.navigateToTarget).toBeCalled();\n\t\t\texpect(CommonUtils.fnProcessDataLossOrDraftDiscardConfirmation).toBeCalled();\n\t\t});\n\t});\n\n\tdescribe(\"hasTargets\", () => {\n\t\t// For the records: FieldRuntime.hasTargets seems to be rather useless\n\t\tit(\"\", () => {\n\t\t\texpect(FieldRuntime.hasTargets(true, \"\")).toBe(true);\n\t\t\texpect(FieldRuntime.hasTargets(false, \"\")).toBe(false);\n\t\t});\n\t});\n\n\tdescribe(\"handleChange\", () => {\n\t\tconst event = new MockEvent();\n\n\t\tit(\"minimal input\", () => {\n\t\t\tFieldRuntime.handleChange(controller, event);\n\t\t\texpect(controller._editFlow.syncTask).toBeCalled();\n\t\t\texpect(controller._sideEffects.handleFieldChange).toBeCalled();\n\t\t});\n\n\t\tit(\"ExtensionAPI\", () => {\n\t\t\tconst controllerExtension = {\n\t\t\t\t_controller: controller,\n\t\t\t\tisA: () => true\n\t\t\t};\n\t\t\tFieldRuntime.handleChange(controllerExtension, event);\n\t\t\texpect(controller._editFlow.syncTask).toBeCalled();\n\t\t\texpect(controller._sideEffects.handleFieldChange).toBeCalled();\n\t\t});\n\n\t\tit(\"transient change\", () => {\n\t\t\tconst mockSource = new MockUI5Element();\n\t\t\tmockSource.bindingContext.isTransient.mockReturnValueOnce(true);\n\t\t\tevent.getSource.mockReturnValueOnce(mockSource);\n\n\t\t\tFieldRuntime.handleChange(controller, event);\n\t\t\texpect(controller._editFlow.syncTask).toBeCalled();\n\t\t\texpect(controller._sideEffects.handleFieldChange).not.toBeCalled();\n\t\t});\n\t});\n\n\tdescribe(\"handleUploadComplete\", () => {\n\t\tconst field = {\n\t\t\tinvalidate: jest.fn()\n\t\t};\n\t\tconst fieldRuntimeGetControlByIdOriginal = FieldRuntime.getControlById;\n\t\tconst fieldRuntimeGetControlByIdMock = jest.fn(() => field);\n\t\tconst fieldRuntimeLockControlOriginal = FieldRuntime.lockControl;\n\t\tconst fieldRuntimeLockControlMock = jest.fn();\n\t\t// generate a MockEvent as input for the tests\n\t\tconst mockContext = {\n\t\t\trequestSideEffects: jest.fn(),\n\t\t\tsetProperty: jest.fn(),\n\t\t\tisTransient: jest.fn(() => false)\n\t\t};\n\t\tconst mockFileUploader = new MockUI5Element();\n\t\tmockFileUploader.getBindingContext.mockReturnValue(mockContext);\n\t\tmockFileUploader.getValue = jest.fn().mockReturnValue(\"filename\");\n\t\tconst delegateUtilGetCustomDataMock = jest.fn(() => \"fieldWrapperId\");\n\t\tDelegateUtil.getCustomData = delegateUtilGetCustomDataMock;\n\t\tmockFileUploader.getId = jest.fn().mockReturnValue(\"id\");\n\n\t\tbeforeEach(() => {\n\t\t\tconst fieldRuntimeUploadPromisesMock: object = {\n\t\t\t\t\"id\": {\n\t\t\t\t\tresolve: jest.fn(() => true),\n\t\t\t\t\treject: jest.fn(() => false)\n\t\t\t\t}\n\t\t\t};\n\t\t\tFieldRuntime.uploadPromises = fieldRuntimeUploadPromisesMock;\n\t\t});\n\n\t\tbeforeAll(() => {\n\t\t\t// replacing the relevant functions with a mock\n\t\t\tFieldRuntime.getControlById = fieldRuntimeGetControlByIdMock;\n\t\t\tFieldRuntime.lockControl = fieldRuntimeLockControlMock;\n\t\t});\n\n\t\tafterAll(() => {\n\t\t\t// clean up and restore original functions\n\t\t\tFieldRuntime.getControlById = fieldRuntimeGetControlByIdOriginal;\n\t\t\tFieldRuntime.lockControl = fieldRuntimeLockControlOriginal;\n\t\t});\n\n\t\tit(\"test for successful upload and calling setProperty and requestSideEffects\", () => {\n\t\t\tconst event = new MockEvent(\n\t\t\t\t{\n\t\t\t\t\tstatus: 204,\n\t\t\t\t\theaders: {\n\t\t\t\t\t\tetag: undefined\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tmockFileUploader\n\t\t\t);\n\t\t\tFieldRuntime.handleUploadComplete(event, \"propertyName\", controller);\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(0);\n\t\t\texpect(event.getSource).toBeCalledTimes(2);\n\t\t\texpect(mockFileUploader.getBindingContext).toBeCalledTimes(2);\n\t\t\texpect(mockContext.setProperty).toBeCalledWith(\"propertyName\", \"filename\");\n\t\t\texpect(mockFileUploader.getValue).toBeCalledTimes(1);\n\t\t\texpect(fieldRuntimeLockControlMock).toBeCalledTimes(1);\n\t\t\texpect(controller._sideEffects.handleFieldChange).toBeCalledTimes(1);\n\t\t});\n\n\t\tit(\"test for successful upload with etag\", () => {\n\t\t\tconst event = new MockEvent(\n\t\t\t\t{\n\t\t\t\t\tstatus: 204,\n\t\t\t\t\theaders: {\n\t\t\t\t\t\tetag: \"XYZ\"\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tmockFileUploader\n\t\t\t);\n\t\t\tFieldRuntime.handleUploadComplete(event, \"propertyName\", controller);\n\t\t\texpect(mockContext.setProperty).toBeCalledWith(\"@odata.etag\", \"XYZ\", null);\n\t\t});\n\n\t\tit(\"test handling for error 423 with JSON response\", () => {\n\t\t\tconst message = \"The error text\";\n\t\t\tconst event = new MockEvent(\n\t\t\t\t{\n\t\t\t\t\tstatus: 423,\n\t\t\t\t\tresponseRaw: JSON.stringify({\n\t\t\t\t\t\terror: {\n\t\t\t\t\t\t\tmessage\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t},\n\t\t\t\tmockFileUploader\n\t\t\t);\n\t\t\tFieldRuntime.handleUploadComplete(event, \"propertyName\", controller);\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(1);\n\t\t\texpect(messageBoxErrorMock).toBeCalledWith(message);\n\t\t\texpect(mockContext.setProperty).not.toBeCalled();\n\t\t\texpect(mockFileUploader.getValue).not.toBeCalled();\n\t\t\texpect(mockContext.requestSideEffects).not.toBeCalled();\n\t\t\texpect(fieldRuntimeLockControlMock).toBeCalledTimes(1);\n\t\t});\n\n\t\tit(\"test handling for error 500 with HTML response\", () => {\n\t\t\tconst message =\n\t\t\t\t'<!DOCTYPE html>\\n<html lang=\"en\">\\n<head>\\n<meta charset=\"utf-8\">\\n<title>Error</title>\\n</head>\\n<body>\\n<pre>Error: read ECONNRESET<br> &nbsp; &nbsp;at TLSWrap.onStreamRead (internal/stream_base_commons.js:209:20)</pre>\\n</body>\\n</html>\\n';\n\t\t\tconst event = new MockEvent(\n\t\t\t\t{\n\t\t\t\t\tstatus: 500,\n\t\t\t\t\tresponseRaw: message\n\t\t\t\t},\n\t\t\t\tmockFileUploader\n\t\t\t);\n\t\t\tFieldRuntime.handleUploadComplete(event, \"\", controller);\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(1);\n\t\t\texpect(messageBoxErrorMock).toBeCalledWith(message);\n\t\t\texpect(mockContext.setProperty).not.toBeCalled();\n\t\t\texpect(mockFileUploader.getValue).not.toBeCalled();\n\t\t\texpect(mockContext.requestSideEffects).not.toBeCalled();\n\t\t\texpect(fieldRuntimeLockControlMock).toBeCalledTimes(1);\n\t\t});\n\n\t\tit(\"test handling for error 403 with String response\", () => {\n\t\t\tconst message = \"CSRF token is invalid\";\n\t\t\tconst event = new MockEvent(\n\t\t\t\t{\n\t\t\t\t\tstatus: 403,\n\t\t\t\t\tresponseRaw: message\n\t\t\t\t},\n\t\t\t\tmockFileUploader\n\t\t\t);\n\t\t\tFieldRuntime.handleUploadComplete(event, \"\", controller);\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(1);\n\t\t\texpect(messageBoxErrorMock).toBeCalledWith(message);\n\t\t\texpect(mockContext.setProperty).not.toBeCalled();\n\t\t\texpect(mockFileUploader.getValue).not.toBeCalled();\n\t\t\texpect(mockContext.requestSideEffects).not.toBeCalled();\n\t\t\texpect(fieldRuntimeLockControlMock).toBeCalledTimes(1);\n\t\t});\n\n\t\tit(\"test handling for error 0 with no response\", () => {\n\t\t\tconst message = \"\";\n\t\t\tconst event = new MockEvent(\n\t\t\t\t{\n\t\t\t\t\tstatus: 0,\n\t\t\t\t\tresponseRaw: message\n\t\t\t\t},\n\t\t\t\tmockFileUploader\n\t\t\t);\n\t\t\tFieldRuntime.handleUploadComplete(event, \"\", controller);\n\t\t\texpect(messageBoxErrorMock).toBeCalledTimes(1);\n\t\t\texpect(messageBoxErrorMock).toBeCalledWith(\"M_FIELD_FILEUPLOADER_ABORTED_TEXT\");\n\t\t\texpect(mockContext.setProperty).not.toBeCalled();\n\t\t\texpect(mockFileUploader.getValue).not.toBeCalled();\n\t\t\texpect(mockContext.requestSideEffects).not.toBeCalled();\n\t\t\texpect(fieldRuntimeLockControlMock).toBeCalledTimes(1);\n\t\t});\n\t});\n\n\tdescribe(\"lockControl\", () => {\n\t\tconst control = new Control();\n\n\t\tit(\"unlock busy control\", () => {\n\t\t\tBusyLocker.lock(control);\n\t\t\tFieldRuntime.lockControl(control, false);\n\t\t\texpect(control.getBusy()).toEqual(false);\n\t\t});\n\n\t\tit(\"lock busy control\", () => {\n\t\t\tBusyLocker.lock(control);\n\t\t\tFieldRuntime.lockControl(control, true);\n\t\t\texpect(control.getBusy()).toEqual(true);\n\t\t\tBusyLocker.unlock(control);\n\t\t});\n\n\t\tit(\"lock not-busy control\", () => {\n\t\t\tFieldRuntime.lockControl(control, true);\n\t\t\texpect(control.getBusy()).toEqual(true);\n\t\t\tBusyLocker.unlock(control);\n\t\t});\n\t\tit(\"unlock not-busy control\", () => {\n\t\t\tFieldRuntime.lockControl(control, false);\n\t\t\texpect(control.getBusy()).toEqual(false);\n\t\t});\n\t});\n\n\tdescribe(\"removeStream\", () => {\n\t\tconst source = new MockUI5Element();\n\t\tsource.getParent.mockReturnValue({\n\t\t\tgetItems: jest.fn(() => [{ isA: jest.fn(() => false) }, { isA: jest.fn(() => true) }, { isA: jest.fn(() => false) }])\n\t\t});\n\t\tconst mockEvent = new MockEvent({}, source);\n\n\t\tit(\"test handling for delete file\", () => {\n\t\t\tFieldRuntime.removeStream(mockEvent, \"propertyName\", controller);\n\t\t\texpect(controller._sideEffects.handleFieldChange).toBeCalledTimes(1);\n\t\t});\n\t});\n});\n"]}