@sap/open.fe 1.97.0 → 1.98.0

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

@@ -1,115 +1,325 @@
-import { FieldRuntime } from "sap/fe/macros/field";
+import { Log } from "sap/base";
 import { MessageBox } from "sap/m";
-import { Event } from "sap/ui/base";
-import { ResourceModel } from "sap/fe/macros";
+import { Control } from "sap/ui/core";
+
+import { FieldRuntime } from "sap/fe/macros/field";
+import { ResourceModel, DelegateUtil } from "sap/fe/macros";
+import { BusyLocker, CommonUtils } from "sap/fe/core";
+import { ModelHelper } from "sap/fe/core/helpers";
+import { MockUI5Element, MockEvent, mockMVC } from "sap/fe/test/UI5MockHelper";
+import { ODataModel } from "sap/ui/model/odata/v4";
 
 describe("FieldRuntime", () => {
-	// replacing the relevant functions with a mock
 	const messageBoxErrorMock = jest.fn();
-	MessageBox.error = messageBoxErrorMock;
 
-	const resourceBundleText = "The message text";
-	const resourceModelGetTextMock = jest.fn(() => resourceBundleText);
-	ResourceModel.getText = resourceModelGetTextMock;
+	// mocked MVC for testing
+	const { model, view, controller } = mockMVC();
 
-	describe("handleUploadComplete", () => {
-		// generate a MockEvent as input for the tests
-		function getMockEvent(parameters: any): Partial<Event> {
-			return {
-				getParameter: jest.fn(name => parameters[name]),
-				getSource: jest.fn((): any => {
-					return mockFileUploader;
-				})
+	beforeAll(() => {
+		// replace static functions with mocks
+		ResourceModel.getText = jest.fn((key: string) => key);
+		Log.error = jest.fn();
+		MessageBox.error = messageBoxErrorMock;
+		CommonUtils.getTargetView = jest.fn(oSource => {
+			return oSource.getView();
+		});
+		CommonUtils.fnProcessDataLossOrDraftDiscardConfirmation = jest.fn((processCB, cancelCB, context) => {
+			processCB(context);
+		});
+		ModelHelper.isStickySessionSupported = jest.fn().mockReturnValue(false);
+	});
+
+	afterAll(() => {
+		// reset all counters
+		jest.resetAllMocks();
+	});
+
+	afterEach(() => {
+		// remove all mocks
+		jest.clearAllMocks();
+	});
+
+	describe("formatDraftOwnerTextInPopover", () => {
+		const pUser = "~processUser";
+		const cUser = "~changeUser";
+		const pDesc = "~processUserDescription";
+		const cDesc = "~changeUserDescription";
+
+		it("No draft", () => {
+			const text = FieldRuntime.formatDraftOwnerTextInPopover(false, "", "", "", "");
+			expect(text).toBe("M_FIELD_RUNTIME_DRAFT_POPOVER_NO_DATA_TEXT");
+		});
+
+		it("Unsaved changes by unknown user", () => {
+			const text = FieldRuntime.formatDraftOwnerTextInPopover(true, "", "", "", "");
+			expect(text).toBe("M_FIELD_RUNTIME_DRAFT_POPOVER_UNSAVED_CHANGES_BY_UNKNOWN");
+		});
+
+		it("Unsaved changes by known user", () => {
+			const text = FieldRuntime.formatDraftOwnerTextInPopover(true, "", cUser, "", cDesc);
+			expect(text).toBe("M_FIELD_RUNTIME_DRAFT_POPOVER_UNSAVED_CHANGES_BY_KNOWN");
+		});
+
+		it("Locked by known user", () => {
+			const text = FieldRuntime.formatDraftOwnerTextInPopover(true, pUser, cUser, pDesc, cDesc);
+			expect(text).toBe("M_FIELD_RUNTIME_DRAFT_POPOVER_LOCKED_BY_KNOWN");
+		});
+	});
+
+	describe("onDataFieldWithNavigationPath", () => {
+		const mockSource = new MockUI5Element();
+		mockSource.getView = jest.fn().mockReturnValue(view);
+		mockSource.bindingContext.getModel.mockReturnValue((model as any) as ODataModel);
+
+		it("Routing not defined", () => {
+			FieldRuntime.onDataFieldWithNavigationPath({}, {}, "");
+			expect(Log.error).toBeCalled();
+		});
+
+		it("StandardRouting", () => {
+			view.getViewData.mockReturnValueOnce({});
+			FieldRuntime.onDataFieldWithNavigationPath(mockSource, controller, "~semanticObject");
+			expect(controller._routing.navigateToTarget).toBeCalled();
+		});
+
+		it("Special case ObjectPage", () => {
+			view.getViewData.mockReturnValueOnce({ converterType: "ObjectPage" });
+			FieldRuntime.onDataFieldWithNavigationPath(mockSource, controller, "~semanticObject");
+			expect(controller._routing.navigateToTarget).toBeCalled();
+			expect(CommonUtils.fnProcessDataLossOrDraftDiscardConfirmation).toBeCalled();
+		});
+	});
+
+	describe("hasTargets", () => {
+		// For the records: FieldRuntime.hasTargets seems to be rather useless
+		it("", () => {
+			expect(FieldRuntime.hasTargets(true, "")).toBe(true);
+			expect(FieldRuntime.hasTargets(false, "")).toBe(false);
+		});
+	});
+
+	describe("handleChange", () => {
+		const event = new MockEvent();
+
+		it("minimal input", () => {
+			FieldRuntime.handleChange(controller, event);
+			expect(controller._editFlow.syncTask).toBeCalled();
+			expect(controller._sideEffects.handleFieldChange).toBeCalled();
+		});
+
+		it("ExtensionAPI", () => {
+			const controllerExtension = {
+				_controller: controller,
+				isA: () => true
 			};
-		}
-		const mockFileUploader = {
-			getBindingContext: jest.fn((): any => {
-				return mockContext;
-			}),
-			getValue: jest.fn(() => "filename")
+			FieldRuntime.handleChange(controllerExtension, event);
+			expect(controller._editFlow.syncTask).toBeCalled();
+			expect(controller._sideEffects.handleFieldChange).toBeCalled();
+		});
+
+		it("transient change", () => {
+			const 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", () => {
+		const field = {
+			invalidate: jest.fn()
 		};
+		const fieldRuntimeGetControlByIdOriginal = FieldRuntime.getControlById;
+		const fieldRuntimeGetControlByIdMock = jest.fn(() => field);
+		const fieldRuntimeLockControlOriginal = FieldRuntime.lockControl;
+		const fieldRuntimeLockControlMock = jest.fn();
+		// generate a MockEvent as input for the tests
 		const mockContext = {
 			requestSideEffects: jest.fn(),
-			setProperty: jest.fn()
+			setProperty: jest.fn(),
+			isTransient: jest.fn(() => false)
 		};
+		const mockFileUploader = new MockUI5Element();
+		mockFileUploader.getBindingContext.mockReturnValue(mockContext);
+		mockFileUploader.getValue = jest.fn().mockReturnValue("filename");
+		const delegateUtilGetCustomDataMock = jest.fn(() => "fieldWrapperId");
+		DelegateUtil.getCustomData = delegateUtilGetCustomDataMock;
+		mockFileUploader.getId = jest.fn().mockReturnValue("id");
+
+		beforeEach(() => {
+			const fieldRuntimeUploadPromisesMock: object = {
+				"id": {
+					resolve: jest.fn(() => true),
+					reject: jest.fn(() => false)
+				}
+			};
+			FieldRuntime.uploadPromises = fieldRuntimeUploadPromisesMock;
+		});
+
+		beforeAll(() => {
+			// replacing the relevant functions with a mock
+			FieldRuntime.getControlById = fieldRuntimeGetControlByIdMock;
+			FieldRuntime.lockControl = fieldRuntimeLockControlMock;
+		});
 
-		afterEach(() => {
-			messageBoxErrorMock.mockClear();
+		afterAll(() => {
+			// clean up and restore original functions
+			FieldRuntime.getControlById = fieldRuntimeGetControlByIdOriginal;
+			FieldRuntime.lockControl = fieldRuntimeLockControlOriginal;
 		});
 
 		it("test for successful upload and calling setProperty and requestSideEffects", () => {
-			const event = getMockEvent({
-				status: 204
-			});
-			FieldRuntime.handleUploadComplete(event, "propertyName");
+			const 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", () => {
+			const 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", () => {
 			const message = "The error text";
-			const event = getMockEvent({
-				status: 423,
-				responseRaw: JSON.stringify({
-					error: {
-						message
-					}
-				})
-			});
-			FieldRuntime.handleUploadComplete(event, "");
+			const event = new MockEvent(
+				{
+					status: 423,
+					responseRaw: JSON.stringify({
+						error: {
+							message
+						}
+					})
+				},
+				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", () => {
 			const 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';
-			const event = getMockEvent({
-				status: 500,
-				responseRaw: message
-			});
-			FieldRuntime.handleUploadComplete(event, "");
+			const event = new MockEvent(
+				{
+					status: 500,
+					responseRaw: message
+				},
+				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", () => {
 			const message = "CSRF token is invalid";
-			const event = getMockEvent({
-				status: 403,
-				responseRaw: message
-			});
-			FieldRuntime.handleUploadComplete(event, "");
+			const event = new MockEvent(
+				{
+					status: 403,
+					responseRaw: message
+				},
+				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", () => {
 			const message = "";
-			const event = getMockEvent({
-				status: 0,
-				responseRaw: message
-			});
-			FieldRuntime.handleUploadComplete(event, "");
+			const event = new MockEvent(
+				{
+					status: 0,
+					responseRaw: message
+				},
+				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", () => {
-		it("test handling for aborted upload", () => {
-			FieldRuntime.handleUploadAborted();
-			expect(messageBoxErrorMock).toBeCalledTimes(1);
-			expect(messageBoxErrorMock).toBeCalledWith(resourceBundleText);
+	describe("lockControl", () => {
+		const control = new Control();
+
+		it("unlock busy control", () => {
+			BusyLocker.lock(control);
+			FieldRuntime.lockControl(control, false);
+			expect(control.getBusy()).toEqual(false);
+		});
+
+		it("lock busy control", () => {
+			BusyLocker.lock(control);
+			FieldRuntime.lockControl(control, true);
+			expect(control.getBusy()).toEqual(true);
+			BusyLocker.unlock(control);
+		});
+
+		it("lock not-busy control", () => {
+			FieldRuntime.lockControl(control, true);
+			expect(control.getBusy()).toEqual(true);
+			BusyLocker.unlock(control);
+		});
+		it("unlock not-busy control", () => {
+			FieldRuntime.lockControl(control, false);
+			expect(control.getBusy()).toEqual(false);
+		});
+	});
+
+	describe("removeStream", () => {
+		const source = new MockUI5Element();
+		source.getParent.mockReturnValue({
+			getItems: jest.fn(() => [{ isA: jest.fn(() => false) }, { isA: jest.fn(() => true) }, { isA: jest.fn(() => false) }])
+		});
+		const mockEvent = new MockEvent({}, source);
+
+		it("test handling for delete file", () => {
+			FieldRuntime.removeStream(mockEvent, "propertyName", controller);
+			expect(controller._sideEffects.handleFieldChange).toBeCalledTimes(1);
 		});
 	});
 });

package/packages/sap.fe.macros/test/sap/fe/macros/jest/field/FieldTemplating.cds

@@ -26,6 +26,9 @@ service JestService {
             staticHiddenProp   : String @UI.Hidden : true;
             dynamicHiddenProp  : String @UI.Hidden : isHidden;
             dynamicHiddenProp2 : String @UI.Hidden : isHidden;
+            semanticObjectProp : String @(Common : {
+                SemanticObject : 'v4Freestyle',
+            });
             hiddenWith1NNav    : String @UI.Hidden : _Elements.isHidden;
             hiddenWith11Nav    : String @UI.Hidden : SpecialChild.isHidden;
             isHidden           : Boolean;
@@ -40,10 +43,29 @@ service JestService {
 			emailBinding: String @Communication.IsEmailAddress: true;
 			currency : String;
 			UnitWithCurrencyBinding : Integer @Measures.ISOCurrency : currency;
+
+        propertyNoTextWithVH                : String    @(Common : {
+            Label     : 'Value with Value Help',
+            ValueList : {
+                Label          : 'Value with Value Help',
+                CollectionPath : 'ValueHelpEntity',
+                Parameters     : [
+                    {
+                        $Type             : 'Common.ValueListParameterInOut',
+                        LocalDataProperty : propertyNoTextWithVH,
+                        ValueListProperty : 'VHKey'
+                    },
+                    {
+                        $Type             : 'Common.ValueListParameterDisplayOnly',
+                        ValueListProperty : 'VH_Text'
+                    }
+                ]
+            }
+        });
+
     } actions {
 		action testBound();
 	}
-
     entity SubEntity             @(cds.autoexpose) {
         key ID       : Integer   @Core.Computed;
             Name     : String(20)@(Common : {Label : 'Name'});
@@ -53,6 +75,35 @@ service JestService {
                            on owner.ID = owner_ID;
     }
 
+    annotate SubEntity with @(
+        UI.QuickViewFacets             : [{
+            $Type  : 'UI.ReferenceFacet',
+            Label  : 'SubEntity Form',
+            Target : '@UI.FieldGroup#SubEntityForm'
+        }],
+        UI.FieldGroup #SubEntityForm : {Data : [{
+            $Type : 'UI.DataField',
+            Value : Name
+        }]}
+    );
+
+    entity ValueHelpEntity      @(
+        cds.autoexpose,
+        title : 'Value Help Reference'
+    ) {
+        key VHKey   : String(1) @(
+                Common : {
+                    Text            : VH_Text,
+                    TextArrangement : #TextFirst
+                },
+                title  : 'Value Help Key'
+            );
+            VH_Text : String(20)@(
+                Core.Immutable : true,
+                Common         : {Label : 'Value Help Description'}
+            );
+    }
+
     annotate MainEntity with @(UI : {
         LineItem      : [
             {Value : ID},
@@ -103,6 +154,34 @@ service JestService {
                 Target : '@UI.FieldGroup#A'
             },
         ],
+        HeaderFacets                           : [{
+            $Type             : 'UI.ReferenceFacet',
+            Label             : 'DataPoint with Visualization',
+            ID                : 'DataPointC',
+            Target            : '@UI.DataPoint#C',
+            ![@UI.Importance] : #High
+        },
+        {
+            $Type             : 'UI.ReferenceFacet',
+            Label             : 'DataPoint with SemanticObject',
+            ID                : 'DataPointE',
+            Target            : '@UI.DataPoint#E',
+            ![@UI.Importance] : #High
+        },
+        {
+            $Type             : 'UI.ReferenceFacet',
+            Label             : 'DataPoint with QuickView facets',
+            ID                : 'DataPointD',
+            Target            : '@UI.DataPoint#D',
+            ![@UI.Importance] : #High
+        },
+        {
+            $Type             : 'UI.ReferenceFacet',
+            Label             : 'Simple DataPoint',
+            ID                : 'DataPointB',
+            Target            : '@UI.DataPoint#B',
+            ![@UI.Importance] : #High
+        }],
         FieldGroup #A : {Data : [{
             $Type : 'UI.DataField',
             Value : ID
@@ -115,6 +194,19 @@ service JestService {
             Value : dynamicHiddenProp,
             Title : '2',
         },
+        DataPoint #C  : {
+            Visualization : #Rating,
+            Value : dynamicHiddenProp,
+            Title : '2',
+        },
+        DataPoint #D  : {
+            Value : specialChildID,
+            Title : '2',
+        },
+        DataPoint #E  : {
+            Value : semanticObjectProp,
+            Title : '2',
+        },
     });
 
 }