@sap/open.fe 1.98.0 → 1.99.0

package/packages/sap.fe.core/test/sap/fe/core/jest/helpers/PasteHelper.spec.ts

@@ -0,0 +1,378 @@
+import PasteHelper from "sap/fe/core/helpers/PasteHelper";
+import ResourceBundle from "sap/base/i18n/ResourceBundle";
+import MessageBox from "sap/m/MessageBox";
+import Table from "sap/ui/mdc/Table";
+import ODataModel from "sap/ui/model/odata/v4/ODataModel";
+import ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
+import ODataListBinding from "sap/ui/model/odata/v4/ODataListBinding";
+import Context from "sap/ui/model/Context";
+import CorePasteHelper from "sap/ui/core/util/PasteHelper";
+import { mockListReportController } from "sap/fe/test/FeMocks";
+import { mock } from "@sap-ux/jest-mock-ui5/dist/generic";
+import MDCTable from "sap/ui/mdc/Table";
+
+describe("PasteHelper", () => {
+	const MY_ERROR = "myError";
+	const MY_ERROR_2 = "myError2";
+	const MY_ERROR_MESSAGE = `${MY_ERROR}.`;
+	const MY_ERROR_MESSAGE_2 = `${MY_ERROR_2}.`;
+	const ROWBINDING_PATH = "myRowBindingPath";
+	const DUMMY_ENTITY_INFO = "dataFromInfoForEntityProperty";
+	const DUMMY_OBJECT = { dummy: true };
+	const DUMMY_TYPE = { dummyType: true };
+
+	const simplePropertyWithPath = {
+		name: "simplePropertyWithPath",
+		path: "propertyPath"
+	};
+	const tableProperties = {
+		simplePropertyWithPath,
+		...{
+			incompleteProperty: {
+				name: "incompleteProperty"
+			},
+			simpleProperty: {
+				name: "simpleProperty",
+				propertyInfos: [simplePropertyWithPath.name]
+			},
+			complexProperty: {
+				name: "complexProperty",
+				propertyInfos: [simplePropertyWithPath.name, simplePropertyWithPath.name]
+			},
+			complexPropertyWithNav: {
+				name: "complexPropertyWithNav",
+				propertyInfos: [simplePropertyWithPath.name, "navProperty/TextAssociated"]
+			},
+			complexPropertyWithDataPoint: {
+				name: "complexPropertyWithDataPoint",
+				propertyInfos: [simplePropertyWithPath.name, "dataPoint"]
+			},
+			navProperty: {
+				name: "navProperty/TextAssociated",
+				path: "_myNavigation/myPropertyText"
+			},
+			dataPoint: {
+				name: "dataPoint",
+				path: "dataPoint@com.sap.vocabularies.UI.v1.DataPoint"
+			}
+		}
+	};
+
+	const model = mock(ODataModel);
+	const metaModel = mock(ODataMetaModel);
+	const metaContext = mock(Context);
+	const table = mock(Table);
+	const metaModelUI5TypeMock = jest.fn().mockReturnValue(DUMMY_TYPE);
+	const oResourceBundle = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core") as ResourceBundle;
+
+	model.mock.getMetaModel.mockReturnValue(metaModel);
+	(model.mock as any).resolve.mockReturnValue(ROWBINDING_PATH);
+	(metaModel.mock as any).getMetaContext.mockReturnValue(metaContext);
+	(metaModel.mock as any).getUI5Type.mockImplementation(metaModelUI5TypeMock);
+	metaContext.mock.getProperty.mockImplementation((path: string) => {
+		if ([simplePropertyWithPath.name, tableProperties.simpleProperty.name].indexOf(path) > -1) {
+			return DUMMY_OBJECT;
+		} else if (path === simplePropertyWithPath.name + "@Org.OData.Core.V1.Computed") {
+			return true;
+		}
+		return undefined;
+	});
+
+	describe("Display errors", () => {
+		const messageSingleDetails =
+			"Please correct the values below in your source file.<br>(Note: Row/column refers to the position in the dataset you copied.)<br><br>myError";
+		const aErrors = [MY_ERROR];
+		const messageBoxTitle = oResourceBundle.getText("C_COMMON_SAPFE_ERROR_MESSAGES_PAGE_TITLE_ERROR");
+		const messageBoxErrorMock = jest.fn();
+		MessageBox.error = messageBoxErrorMock;
+
+		beforeEach(() => {
+			messageBoxErrorMock.mockClear();
+		});
+
+		it("Single error", () => {
+			const mockCalls = messageBoxErrorMock.mock.calls;
+			PasteHelper.displayErrorMessages(aErrors);
+			expect(messageBoxErrorMock).toHaveBeenCalledTimes(1);
+			expect(mockCalls[0][0]).toBe(oResourceBundle.getText("C_PASTE_HELPER_SAPFE_PASTE_ERROR_MESSAGE_SINGULAR"));
+			expect(mockCalls[0][1].title).toBe(messageBoxTitle);
+			expect(mockCalls[0][1].details).toBe(messageSingleDetails);
+		});
+
+		it("Multiple errors", () => {
+			const mockCalls = messageBoxErrorMock.mock.calls;
+			PasteHelper.displayErrorMessages(aErrors.concat([MY_ERROR_2]));
+			expect(messageBoxErrorMock).toHaveBeenCalledTimes(1);
+			expect(mockCalls[0][0]).toBe(oResourceBundle.getText("C_PASTE_HELPER_SAPFE_PASTE_ERROR_MESSAGE_PLURAL", [2]));
+			expect(mockCalls[0][1].title).toBe(messageBoxTitle);
+			expect(mockCalls[0][1].details).toBe(`${messageSingleDetails}<br>${MY_ERROR_2}`);
+		});
+	});
+
+	it("Format messages coming from custom validation function", () => {
+		const i18Row = oResourceBundle.getText("T_MESSAGE_GROUP_DESCRIPTION_TABLE_ROW");
+		expect(PasteHelper.formatCustomMessage([], 1)).toBe("");
+		expect(PasteHelper.formatCustomMessage([{ messageText: MY_ERROR_MESSAGE }], 1)).toBe(`${i18Row} 1: ${MY_ERROR_MESSAGE}`);
+		expect(PasteHelper.formatCustomMessage([{ messageText: MY_ERROR_MESSAGE }, { messageText: MY_ERROR_MESSAGE_2 }], 1)).toBe(
+			`${i18Row} 1: ${MY_ERROR_MESSAGE} ${MY_ERROR_MESSAGE_2}`
+		);
+	});
+
+	describe("Get info on table columns", () => {
+		let infoForEntityPropertySpy: jest.SpyInstance<any>;
+		const dataListBinding = mock(ODataListBinding);
+
+		let tableColumns: any[] = [];
+		const mockTableColumns = function(propertyNames: string[]) {
+			tableColumns = propertyNames.map(propertyName => {
+				return {
+					getDataProperty: function() {
+						return propertyName;
+					}
+				};
+			});
+		};
+
+		const mockFetchProperties = function(properties: any[]) {
+			(table.mock as any).getControlDelegate.mockImplementation(() => {
+				return {
+					fetchProperties: function() {
+						return Promise.resolve(properties);
+					}
+				};
+			});
+		};
+
+		beforeAll(() => {
+			infoForEntityPropertySpy = jest.spyOn(PasteHelper, "getInfoForEntityProperty").mockReturnValue(DUMMY_ENTITY_INFO);
+			dataListBinding.mock.getModel.mockImplementation(() => model);
+
+			table.mock.getRowBinding.mockImplementation(() => dataListBinding);
+			table.mock.getColumns.mockImplementation(() => tableColumns);
+			mockFetchProperties(Object.values(tableProperties));
+		});
+		beforeEach(() => {
+			infoForEntityPropertySpy.mockClear();
+		});
+
+		afterAll(() => {
+			infoForEntityPropertySpy.mockRestore();
+		});
+
+		it("Incomplete property", async () => {
+			mockTableColumns([tableProperties.incompleteProperty.name]);
+			const columInfos = await PasteHelper.getColumnInfo(table);
+			const columnInfo = columInfos[0];
+			expect(columInfos.length).toBe(1);
+			expect(columnInfo.property).toBe("unused");
+			expect(columnInfo.type).toBe(null);
+			expect(columnInfo.ignore).toBe(true);
+		});
+
+		it("Simple property with path", async () => {
+			mockTableColumns([tableProperties.simplePropertyWithPath.name]);
+			const columInfos = await PasteHelper.getColumnInfo(table);
+			const mockCalls = infoForEntityPropertySpy.mock.calls;
+			expect(columInfos.length).toBe(1);
+			expect(columInfos[0]).toBe(DUMMY_ENTITY_INFO);
+			expect(mockCalls.length).toBe(1);
+			expect(mockCalls[0][0]).toBe(tableProperties.simplePropertyWithPath.path);
+			expect(mockCalls[0][1]).toBe(ROWBINDING_PATH);
+			expect(mockCalls[0][2]).toBe(metaContext);
+			expect(mockCalls[0][3]).toBe(metaModel);
+		});
+
+		it("Simple property with propertyInfo", async () => {
+			mockTableColumns([tableProperties.simpleProperty.name]);
+			const columInfos = await PasteHelper.getColumnInfo(table);
+			expect(columInfos.length).toBe(1);
+			expect(columInfos[0]).toBe(DUMMY_ENTITY_INFO);
+			expect(infoForEntityPropertySpy).toHaveBeenCalledTimes(1);
+		});
+
+		it("Complex property", async () => {
+			mockTableColumns([tableProperties.complexProperty.name]);
+			const columInfos = await PasteHelper.getColumnInfo(table);
+			expect(columInfos.length).toBe(2);
+			expect(columInfos[0]).toBe(DUMMY_ENTITY_INFO);
+			expect(columInfos[1]).toBe(DUMMY_ENTITY_INFO);
+			expect(infoForEntityPropertySpy).toHaveBeenCalledTimes(2);
+		});
+
+		it("Complex property with navigation path", async () => {
+			mockTableColumns([tableProperties.complexPropertyWithNav.name]);
+			const columInfos = await PasteHelper.getColumnInfo(table);
+			expect(columInfos.length).toBe(2);
+			expect(columInfos[0]).toBe(DUMMY_ENTITY_INFO);
+			expect(columInfos[1].property).toBe(tableProperties.navProperty.path);
+			expect(columInfos[1].ignore).toBe(true);
+			expect(infoForEntityPropertySpy).toHaveBeenCalledTimes(1);
+		});
+
+		it("Complex property with dataPoint", async () => {
+			mockTableColumns([tableProperties.complexPropertyWithDataPoint.name]);
+			const columInfos = await PasteHelper.getColumnInfo(table);
+			expect(columInfos.length).toBe(2);
+			expect(columInfos[1].property).toBe(tableProperties.dataPoint.path);
+			expect(columInfos[1].ignore).toBe(true);
+			expect(infoForEntityPropertySpy).toHaveBeenCalledTimes(1);
+		});
+	});
+
+	describe("Get Information based on entity property", () => {
+		beforeEach(() => {
+			metaModelUI5TypeMock.mockClear();
+		});
+		it("simple property", () => {
+			const info = PasteHelper.getInfoForEntityProperty(tableProperties.simpleProperty.name, ROWBINDING_PATH, metaContext, metaModel);
+			expect(info.property).toBe(tableProperties.simpleProperty.name);
+			expect(info.ignore).toBe(undefined);
+			expect(info.type).toBe(DUMMY_TYPE);
+			expect(metaModelUI5TypeMock.mock.calls.length).toBe(1);
+			expect(metaModelUI5TypeMock.mock.calls[0][0]).toBe(`${ROWBINDING_PATH}/${tableProperties.simpleProperty.name}`);
+			expect(metaModelUI5TypeMock.mock.calls[0][1]).toEqual({ parseKeepsEmptyString: true });
+		});
+
+		it("Computed property", () => {
+			const info = PasteHelper.getInfoForEntityProperty(simplePropertyWithPath.name, ROWBINDING_PATH, metaContext, metaModel);
+			expect(info.property).toBe(simplePropertyWithPath.name);
+			expect(info.ignore).toBe(true);
+			expect(info.type).toBe(DUMMY_TYPE);
+			expect(metaModelUI5TypeMock.mock.calls.length).toBe(1);
+		});
+
+		it("undefined property", () => {
+			const info = PasteHelper.getInfoForEntityProperty(
+				tableProperties.incompleteProperty.name,
+				ROWBINDING_PATH,
+				metaContext,
+				metaModel
+			);
+			expect(info.property).toBe(tableProperties.incompleteProperty.name);
+			expect(info.ignore).toBe(true);
+			expect(info.type).toBe(DUMMY_TYPE);
+			expect(metaModelUI5TypeMock.mock.calls.length).toBe(1);
+		});
+	});
+
+	describe("Parse pasted data", () => {
+		const expectedColumn = { ignore: undefined };
+		const ignoredColumn = { ignore: true };
+		const completeRow = ["dummyData", "dummyData"];
+		const unCompleteRow = ["dummyData"];
+		const expectedColumnsInfo = [expectedColumn, expectedColumn];
+		const ignoredFirstColumnsInfo = [ignoredColumn, expectedColumn];
+
+		let corePasteHelperSpy: jest.SpyInstance<any>;
+		let columnInfoSpy: jest.SpyInstance<any>;
+		let errorMessagesSpy: jest.SpyInstance<any>;
+
+		beforeAll(() => {
+			corePasteHelperSpy = jest.spyOn(CorePasteHelper, "parse");
+			columnInfoSpy = jest.spyOn(PasteHelper, "getColumnInfo");
+			errorMessagesSpy = jest.spyOn(PasteHelper, "displayErrorMessages").mockReturnValue(undefined);
+		});
+
+		beforeEach(() => {
+			columnInfoSpy.mockResolvedValue(expectedColumnsInfo);
+			corePasteHelperSpy.mockResolvedValue({ parsedData: completeRow });
+			corePasteHelperSpy.mockClear();
+			columnInfoSpy.mockClear();
+		});
+		it("Successful paste", async () => {
+			const res = await PasteHelper.parsePastedData([completeRow], table);
+			expect(columnInfoSpy).toHaveBeenCalledTimes(1);
+			expect(corePasteHelperSpy).toHaveBeenCalledTimes(1);
+			expect(corePasteHelperSpy.mock.calls[0][0]).toEqual([completeRow]);
+			expect(corePasteHelperSpy.mock.calls[0][1]).toEqual(expectedColumnsInfo);
+			expect(res).toEqual(completeRow);
+		});
+
+		it("Incomplete paste", async () => {
+			columnInfoSpy.mockResolvedValue(ignoredFirstColumnsInfo);
+			const res = await PasteHelper.parsePastedData([unCompleteRow], table);
+			expect(corePasteHelperSpy).not.toHaveBeenCalled();
+			expect(res).toEqual([]);
+		});
+
+		it("error from core parser", async () => {
+			corePasteHelperSpy.mockResolvedValue({ errors: [{ message: "dummyError" }] });
+			const res = await PasteHelper.parsePastedData([completeRow], table);
+			expect(corePasteHelperSpy).toHaveBeenCalledTimes(1);
+			expect(errorMessagesSpy).toHaveBeenCalledTimes(1);
+			expect(errorMessagesSpy.mock.calls[0][0]).toEqual(["dummyError"]);
+			expect(res).toEqual([]);
+		});
+	});
+
+	describe("Paste data", () => {
+		const table = mock(MDCTable);
+		table.mock.getParent.mockReturnValue({ getTableDefinition: jest.fn() });
+		const controller = mockListReportController();
+		const pastedData = [["dummyData"], ["dummyData"]];
+		const validationDocumentMock = jest.fn();
+		const createMultipleDocumentsMock = jest.fn();
+		let parserSpy: jest.SpyInstance<any>;
+		let formatSpy: jest.SpyInstance<any>;
+		let displayErrorSpy: jest.SpyInstance<any>;
+
+		controller._editFlow.mock.getTransactionHelper.mockImplementation(() => {
+			return {
+				validateDocument: validationDocumentMock
+			};
+		});
+		controller._editFlow.mock.createMultipleDocuments = createMultipleDocumentsMock;
+
+		beforeAll(() => {
+			parserSpy = jest.spyOn(PasteHelper, "parsePastedData");
+			formatSpy = jest.spyOn(PasteHelper, "formatCustomMessage");
+			displayErrorSpy = jest.spyOn(PasteHelper, "displayErrorMessages");
+		});
+
+		beforeEach(() => {
+			parserSpy.mockClear();
+			formatSpy.mockClear();
+			displayErrorSpy.mockClear();
+			createMultipleDocumentsMock.mockClear();
+			parserSpy.mockResolvedValue(pastedData);
+			validationDocumentMock.mockResolvedValue([]);
+		});
+
+		afterAll(() => {
+			parserSpy.mockRestore();
+			formatSpy.mockRestore();
+			displayErrorSpy.mockRestore();
+		});
+
+		it("parser of PasteHelper returns empty array (i.e. invalid UI5 types)", async () => {
+			parserSpy.mockResolvedValue([]);
+			await PasteHelper.pasteData(pastedData, table, controller);
+			expect(displayErrorSpy).not.toHaveBeenCalled();
+			expect(formatSpy).not.toHaveBeenCalled();
+			expect(validationDocumentMock).not.toHaveBeenCalled();
+			expect(createMultipleDocumentsMock).not.toHaveBeenCalled();
+		});
+
+		it("custom validation generates errors", async () => {
+			const errorMessages = [{ messageText: "dummy1" }, { messageText: "dummy2" }];
+			validationDocumentMock.mockResolvedValue(errorMessages);
+			await PasteHelper.pasteData(pastedData, table, controller);
+			expect(validationDocumentMock).toHaveBeenCalled();
+			expect(formatSpy).toBeCalledTimes(2);
+			expect(formatSpy.mock.calls[0][0]).toEqual(errorMessages);
+			expect(formatSpy.mock.calls[0][1]).toBe(1);
+			expect(displayErrorSpy).toHaveBeenCalled();
+			expect(createMultipleDocumentsMock).not.toHaveBeenCalled();
+		});
+
+		it("create documents without issue", async () => {
+			(controller as any).editFlow = {};
+			await PasteHelper.pasteData(pastedData, table, controller);
+			expect(validationDocumentMock).toHaveBeenCalled();
+			expect(formatSpy).not.toHaveBeenCalled();
+			expect(displayErrorSpy).not.toHaveBeenCalled();
+			expect(createMultipleDocumentsMock).toHaveBeenCalled();
+			expect(createMultipleDocumentsMock.mock.calls[0][1]).toEqual(pastedData);
+		});
+	});
+});

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

@@ -0,0 +1,123 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/helpers/SemanticDateOperators"], function (SemanticDateOperators) {
+  "use strict";
+
+  describe("SemanticDate Operators", function () {
+    var aSemanticMappingTestData = [{
+      desc: "with 'key' and 'equals'",
+      operatorConfiguration: [{
+        "path": "key",
+        "equals": "TODAY,YESTERDAY",
+        "exclude": false
+      }],
+      expectedOperations: ["TODAY", "YESTERDAY"]
+    }, {
+      desc: "with 'key' and 'contains'",
+      operatorConfiguration: [{
+        "path": "key",
+        "contains": "QUARTER",
+        "exclude": false
+      }],
+      expectedOperations: ["THISQUARTER", "LASTQUARTER", "LASTQUARTERS", "NEXTQUARTER", "NEXTQUARTERS", "QUARTER1", "QUARTER2", "QUARTER3", "QUARTER4"]
+    }, {
+      desc: "with 'category' and 'equals'",
+      operatorConfiguration: [{
+        "path": "category",
+        "equals": "FIXED.DATE",
+        "exclude": false
+      }],
+      expectedOperations: ["TODAY", "YESTERDAY", "TOMORROW"]
+    }, {
+      desc: "with 'category' and 'contains'",
+      operatorConfiguration: [{
+        "path": "category",
+        "contains": "DYNAMIC.DATE",
+        "exclude": false
+      }],
+      expectedOperations: ["DATE", "FROM", "TO", "DATERANGE", "TODAYFROMTO", "LASTDAYS", "NEXTDAYS"]
+    }, {
+      desc: "with 'key' and 'equals' - exclude: true",
+      operatorConfiguration: [{
+        "path": "key",
+        "equals": "TODAY",
+        "exclude": true
+      }],
+      expectedOperations: ["DATE", "FROM", "TO", "DATERANGE", "SPECIFICMONTH", "TODAYFROMTO", "YESTERDAY", "TOMORROW", "LASTDAYS", "NEXTDAYS", "THISWEEK", "LASTWEEK", "LASTWEEKS", "NEXTWEEK", "NEXTWEEKS", "THISMONTH", "LASTMONTH", "LASTMONTHS", "NEXTMONTH", "NEXTMONTHS", "THISQUARTER", "LASTQUARTER", "LASTQUARTERS", "NEXTQUARTER", "NEXTQUARTERS", "QUARTER1", "QUARTER2", "QUARTER3", "QUARTER4", "THISYEAR", "LASTYEAR", "LASTYEARS", "NEXTYEAR", "NEXTYEARS", "YEARTODATE"]
+    }, {
+      desc: "with 'category' and 'contains' - exclude: true",
+      operatorConfiguration: [{
+        "path": "category",
+        "contains": "DYNAMIC",
+        "exclude": true
+      }],
+      expectedOperations: ["TODAY", "YESTERDAY", "TOMORROW", "THISWEEK", "LASTWEEK", "NEXTWEEK", "THISMONTH", "LASTMONTH", "NEXTMONTH", "THISQUARTER", "LASTQUARTER", "NEXTQUARTER", "QUARTER1", "QUARTER2", "QUARTER3", "QUARTER4", "THISYEAR", "LASTYEAR", "NEXTYEAR", "YEARTODATE"]
+    }, {
+      desc: "with empty filter settings",
+      operatorConfiguration: [],
+      expectedOperations: []
+    }, {
+      desc: "with multiple filter settings",
+      operatorConfiguration: [{
+        "path": "key",
+        "equals": "TODAY,LASTYEAR,NEXTYEAR",
+        "exclude": true
+      }, {
+        "path": "category",
+        "contains": "MONTH",
+        "exclude": true
+      }, {
+        "path": "key",
+        "contains": "QUARTER",
+        "exclude": true
+      }],
+      expectedOperations: ["DATE", "FROM", "TO", "DATERANGE", "TODAYFROMTO", "YESTERDAY", "TOMORROW", "LASTDAYS", "NEXTDAYS", "THISWEEK", "LASTWEEK", "LASTWEEKS", "NEXTWEEK", "NEXTWEEKS", "THISYEAR", "LASTYEARS", "NEXTYEARS", "YEARTODATE"]
+    }];
+    aSemanticMappingTestData.forEach(function (oTestData) {
+      test("getFilterOperations - " + oTestData.desc, function () {
+        var aSemanticDateOps = SemanticDateOperators.getFilterOperations(oTestData.operatorConfiguration);
+        expect(JSON.stringify(aSemanticDateOps)).toEqual(JSON.stringify(oTestData.expectedOperations)); // "testing semantic date settings " + oTestData.desc + " - done"
+      });
+    });
+    var aFilterConditionsTestMapping = [{
+      desc: "with no semantic date entered in the Filter Bar",
+      condition: {
+        "$editState": [{
+          operator: "DRAFT_EDIT_STATE",
+          values: ["ALL"]
+        }],
+        LastChangedDateTime: [{
+          operator: "EQ",
+          values: ["2020-12-03T15:32:05+0530"]
+        }]
+      },
+      expectedResult: true
+    }, {
+      desc: "with semantic date entered in the Filter Bar",
+      condition: {
+        "$editState": [{
+          operator: "DRAFT_EDIT_STATE",
+          values: ["ALL"]
+        }],
+        LastChangedDateTime: [{
+          operator: "EQ",
+          values: ["2020-12-03T15:32:05+0530"]
+        }],
+        SalesOrderDate: [{
+          operator: "YESTERDAY",
+          values: ["Dec 2, 2020"]
+        }]
+      },
+      expectedResult: false
+    }];
+    aFilterConditionsTestMapping.forEach(function (oTestData) {
+      test("hasSemanticDateOperations - " + oTestData.desc, function () {
+        var bHasSemanticDateOperation = SemanticDateOperators.hasSemanticDateOperations(oTestData.condition);
+        expect(bHasSemanticDateOperation).toEqual(oTestData.expectedResult); // "testing hasSemanticDateOperations " + oTestData.desc + " - done"
+      });
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["SemanticDateOperators.spec.ts"],"names":["describe","aSemanticMappingTestData","desc","operatorConfiguration","expectedOperations","forEach","oTestData","test","aSemanticDateOps","SemanticDateOperators","getFilterOperations","expect","JSON","stringify","toEqual","aFilterConditionsTestMapping","condition","operator","values","LastChangedDateTime","expectedResult","SalesOrderDate","bHasSemanticDateOperation","hasSemanticDateOperations"],"mappings":"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","sourceRoot":".","sourcesContent":["import SemanticDateOperators from \"sap/fe/core/helpers/SemanticDateOperators\";\n\ndescribe(\"SemanticDate Operators\", () => {\n\tconst aSemanticMappingTestData = [\n\t\t{\n\t\t\tdesc: \"with 'key' and 'equals'\",\n\t\t\toperatorConfiguration: [\n\t\t\t\t{\n\t\t\t\t\t\"path\": \"key\",\n\t\t\t\t\t\"equals\": \"TODAY,YESTERDAY\",\n\t\t\t\t\t\"exclude\": false\n\t\t\t\t}\n\t\t\t],\n\t\t\texpectedOperations: [\"TODAY\", \"YESTERDAY\"]\n\t\t},\n\t\t{\n\t\t\tdesc: \"with 'key' and 'contains'\",\n\t\t\toperatorConfiguration: [\n\t\t\t\t{\n\t\t\t\t\t\"path\": \"key\",\n\t\t\t\t\t\"contains\": \"QUARTER\",\n\t\t\t\t\t\"exclude\": false\n\t\t\t\t}\n\t\t\t],\n\t\t\texpectedOperations: [\n\t\t\t\t\"THISQUARTER\",\n\t\t\t\t\"LASTQUARTER\",\n\t\t\t\t\"LASTQUARTERS\",\n\t\t\t\t\"NEXTQUARTER\",\n\t\t\t\t\"NEXTQUARTERS\",\n\t\t\t\t\"QUARTER1\",\n\t\t\t\t\"QUARTER2\",\n\t\t\t\t\"QUARTER3\",\n\t\t\t\t\"QUARTER4\"\n\t\t\t]\n\t\t},\n\t\t{\n\t\t\tdesc: \"with 'category' and 'equals'\",\n\t\t\toperatorConfiguration: [\n\t\t\t\t{\n\t\t\t\t\t\"path\": \"category\",\n\t\t\t\t\t\"equals\": \"FIXED.DATE\",\n\t\t\t\t\t\"exclude\": false\n\t\t\t\t}\n\t\t\t],\n\t\t\texpectedOperations: [\"TODAY\", \"YESTERDAY\", \"TOMORROW\"]\n\t\t},\n\t\t{\n\t\t\tdesc: \"with 'category' and 'contains'\",\n\t\t\toperatorConfiguration: [\n\t\t\t\t{\n\t\t\t\t\t\"path\": \"category\",\n\t\t\t\t\t\"contains\": \"DYNAMIC.DATE\",\n\t\t\t\t\t\"exclude\": false\n\t\t\t\t}\n\t\t\t],\n\t\t\texpectedOperations: [\"DATE\", \"FROM\", \"TO\", \"DATERANGE\", \"TODAYFROMTO\", \"LASTDAYS\", \"NEXTDAYS\"]\n\t\t},\n\t\t{\n\t\t\tdesc: \"with 'key' and 'equals' - exclude: true\",\n\t\t\toperatorConfiguration: [\n\t\t\t\t{\n\t\t\t\t\t\"path\": \"key\",\n\t\t\t\t\t\"equals\": \"TODAY\",\n\t\t\t\t\t\"exclude\": true\n\t\t\t\t}\n\t\t\t],\n\t\t\texpectedOperations: [\n\t\t\t\t\"DATE\",\n\t\t\t\t\"FROM\",\n\t\t\t\t\"TO\",\n\t\t\t\t\"DATERANGE\",\n\t\t\t\t\"SPECIFICMONTH\",\n\t\t\t\t\"TODAYFROMTO\",\n\t\t\t\t\"YESTERDAY\",\n\t\t\t\t\"TOMORROW\",\n\t\t\t\t\"LASTDAYS\",\n\t\t\t\t\"NEXTDAYS\",\n\t\t\t\t\"THISWEEK\",\n\t\t\t\t\"LASTWEEK\",\n\t\t\t\t\"LASTWEEKS\",\n\t\t\t\t\"NEXTWEEK\",\n\t\t\t\t\"NEXTWEEKS\",\n\t\t\t\t\"THISMONTH\",\n\t\t\t\t\"LASTMONTH\",\n\t\t\t\t\"LASTMONTHS\",\n\t\t\t\t\"NEXTMONTH\",\n\t\t\t\t\"NEXTMONTHS\",\n\t\t\t\t\"THISQUARTER\",\n\t\t\t\t\"LASTQUARTER\",\n\t\t\t\t\"LASTQUARTERS\",\n\t\t\t\t\"NEXTQUARTER\",\n\t\t\t\t\"NEXTQUARTERS\",\n\t\t\t\t\"QUARTER1\",\n\t\t\t\t\"QUARTER2\",\n\t\t\t\t\"QUARTER3\",\n\t\t\t\t\"QUARTER4\",\n\t\t\t\t\"THISYEAR\",\n\t\t\t\t\"LASTYEAR\",\n\t\t\t\t\"LASTYEARS\",\n\t\t\t\t\"NEXTYEAR\",\n\t\t\t\t\"NEXTYEARS\",\n\t\t\t\t\"YEARTODATE\"\n\t\t\t]\n\t\t},\n\t\t{\n\t\t\tdesc: \"with 'category' and 'contains' - exclude: true\",\n\t\t\toperatorConfiguration: [\n\t\t\t\t{\n\t\t\t\t\t\"path\": \"category\",\n\t\t\t\t\t\"contains\": \"DYNAMIC\",\n\t\t\t\t\t\"exclude\": true\n\t\t\t\t}\n\t\t\t],\n\t\t\texpectedOperations: [\n\t\t\t\t\"TODAY\",\n\t\t\t\t\"YESTERDAY\",\n\t\t\t\t\"TOMORROW\",\n\t\t\t\t\"THISWEEK\",\n\t\t\t\t\"LASTWEEK\",\n\t\t\t\t\"NEXTWEEK\",\n\t\t\t\t\"THISMONTH\",\n\t\t\t\t\"LASTMONTH\",\n\t\t\t\t\"NEXTMONTH\",\n\t\t\t\t\"THISQUARTER\",\n\t\t\t\t\"LASTQUARTER\",\n\t\t\t\t\"NEXTQUARTER\",\n\t\t\t\t\"QUARTER1\",\n\t\t\t\t\"QUARTER2\",\n\t\t\t\t\"QUARTER3\",\n\t\t\t\t\"QUARTER4\",\n\t\t\t\t\"THISYEAR\",\n\t\t\t\t\"LASTYEAR\",\n\t\t\t\t\"NEXTYEAR\",\n\t\t\t\t\"YEARTODATE\"\n\t\t\t]\n\t\t},\n\t\t{\n\t\t\tdesc: \"with empty filter settings\",\n\t\t\toperatorConfiguration: [],\n\t\t\texpectedOperations: []\n\t\t},\n\t\t{\n\t\t\tdesc: \"with multiple filter settings\",\n\t\t\toperatorConfiguration: [\n\t\t\t\t{\n\t\t\t\t\t\"path\": \"key\",\n\t\t\t\t\t\"equals\": \"TODAY,LASTYEAR,NEXTYEAR\",\n\t\t\t\t\t\"exclude\": true\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\t\"path\": \"category\",\n\t\t\t\t\t\"contains\": \"MONTH\",\n\t\t\t\t\t\"exclude\": true\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\t\"path\": \"key\",\n\t\t\t\t\t\"contains\": \"QUARTER\",\n\t\t\t\t\t\"exclude\": true\n\t\t\t\t}\n\t\t\t],\n\t\t\texpectedOperations: [\n\t\t\t\t\"DATE\",\n\t\t\t\t\"FROM\",\n\t\t\t\t\"TO\",\n\t\t\t\t\"DATERANGE\",\n\t\t\t\t\"TODAYFROMTO\",\n\t\t\t\t\"YESTERDAY\",\n\t\t\t\t\"TOMORROW\",\n\t\t\t\t\"LASTDAYS\",\n\t\t\t\t\"NEXTDAYS\",\n\t\t\t\t\"THISWEEK\",\n\t\t\t\t\"LASTWEEK\",\n\t\t\t\t\"LASTWEEKS\",\n\t\t\t\t\"NEXTWEEK\",\n\t\t\t\t\"NEXTWEEKS\",\n\t\t\t\t\"THISYEAR\",\n\t\t\t\t\"LASTYEARS\",\n\t\t\t\t\"NEXTYEARS\",\n\t\t\t\t\"YEARTODATE\"\n\t\t\t]\n\t\t}\n\t];\n\n\taSemanticMappingTestData.forEach(function(oTestData) {\n\t\ttest(\"getFilterOperations - \" + oTestData.desc, () => {\n\t\t\tconst aSemanticDateOps = SemanticDateOperators.getFilterOperations(oTestData.operatorConfiguration);\n\t\t\texpect(JSON.stringify(aSemanticDateOps)).toEqual(JSON.stringify(oTestData.expectedOperations)); // \"testing semantic date settings \" + oTestData.desc + \" - done\"\n\t\t});\n\t});\n\n\tconst aFilterConditionsTestMapping = [\n\t\t{\n\t\t\tdesc: \"with no semantic date entered in the Filter Bar\",\n\t\t\tcondition: {\n\t\t\t\t\"$editState\": [\n\t\t\t\t\t{\n\t\t\t\t\t\toperator: \"DRAFT_EDIT_STATE\",\n\t\t\t\t\t\tvalues: [\"ALL\"]\n\t\t\t\t\t}\n\t\t\t\t],\n\t\t\t\tLastChangedDateTime: [\n\t\t\t\t\t{\n\t\t\t\t\t\toperator: \"EQ\",\n\t\t\t\t\t\tvalues: [\"2020-12-03T15:32:05+0530\"]\n\t\t\t\t\t}\n\t\t\t\t]\n\t\t\t},\n\t\t\texpectedResult: true\n\t\t},\n\t\t{\n\t\t\tdesc: \"with semantic date entered in the Filter Bar\",\n\t\t\tcondition: {\n\t\t\t\t\"$editState\": [\n\t\t\t\t\t{\n\t\t\t\t\t\toperator: \"DRAFT_EDIT_STATE\",\n\t\t\t\t\t\tvalues: [\"ALL\"]\n\t\t\t\t\t}\n\t\t\t\t],\n\t\t\t\tLastChangedDateTime: [\n\t\t\t\t\t{\n\t\t\t\t\t\toperator: \"EQ\",\n\t\t\t\t\t\tvalues: [\"2020-12-03T15:32:05+0530\"]\n\t\t\t\t\t}\n\t\t\t\t],\n\t\t\t\tSalesOrderDate: [\n\t\t\t\t\t{\n\t\t\t\t\t\toperator: \"YESTERDAY\",\n\t\t\t\t\t\tvalues: [\"Dec 2, 2020\"]\n\t\t\t\t\t}\n\t\t\t\t]\n\t\t\t},\n\t\t\texpectedResult: false\n\t\t}\n\t];\n\taFilterConditionsTestMapping.forEach(function(oTestData) {\n\t\ttest(\"hasSemanticDateOperations - \" + oTestData.desc, () => {\n\t\t\tconst bHasSemanticDateOperation = SemanticDateOperators.hasSemanticDateOperations(oTestData.condition);\n\t\t\texpect(bHasSemanticDateOperation).toEqual(oTestData.expectedResult); // \"testing hasSemanticDateOperations \" + oTestData.desc + \" - done\"\n\t\t});\n\t});\n});\n"]}

package/packages/sap.fe.core/test/sap/fe/core/{qunit/helpers/SemanticDateOperators.qunit.js → jest/helpers/SemanticDateOperators.spec.ts}

@@ -1,10 +1,7 @@
-/* global QUnit */
-sap.ui.define(["sap/fe/core/helpers/SemanticDateOperators"], function(SemanticDateOperators) {
-	"use strict";
+import SemanticDateOperators from "sap/fe/core/helpers/SemanticDateOperators";
 
-	QUnit.module("SemanticDate Operators", {});
-
-	var aSemanticMappingTestData = [
+describe("SemanticDate Operators", () => {
+	const aSemanticMappingTestData = [
 		{
 			desc: "with 'key' and 'equals'",
 			operatorConfiguration: [
@@ -186,17 +183,13 @@ sap.ui.define(["sap/fe/core/helpers/SemanticDateOperators"], function(SemanticDa
 	];
 
 	aSemanticMappingTestData.forEach(function(oTestData) {
-		QUnit.test("getFilterOperations - " + oTestData.desc, function(assert) {
-			var aSemanticDateOps = SemanticDateOperators.getFilterOperations(oTestData.operatorConfiguration);
-			assert.equal(
-				JSON.stringify(aSemanticDateOps),
-				JSON.stringify(oTestData.expectedOperations),
-				"testing semantic date settings " + oTestData.desc + " - done"
-			);
+		test("getFilterOperations - " + oTestData.desc, () => {
+			const aSemanticDateOps = SemanticDateOperators.getFilterOperations(oTestData.operatorConfiguration);
+			expect(JSON.stringify(aSemanticDateOps)).toEqual(JSON.stringify(oTestData.expectedOperations)); // "testing semantic date settings " + oTestData.desc + " - done"
 		});
 	});
 
-	var aFilterConditionsTestMapping = [
+	const aFilterConditionsTestMapping = [
 		{
 			desc: "with no semantic date entered in the Filter Bar",
 			condition: {
@@ -241,13 +234,9 @@ sap.ui.define(["sap/fe/core/helpers/SemanticDateOperators"], function(SemanticDa
 		}
 	];
 	aFilterConditionsTestMapping.forEach(function(oTestData) {
-		QUnit.test("hasSemanticDateOperations - " + oTestData.desc, function(assert) {
-			var bHasSemanticDateOperation = SemanticDateOperators.hasSemanticDateOperations(oTestData.condition);
-			assert.equal(
-				bHasSemanticDateOperation,
-				oTestData.expectedResult,
-				"testing hasSemanticDateOperations " + oTestData.desc + " - done"
-			);
+		test("hasSemanticDateOperations - " + oTestData.desc, () => {
+			const bHasSemanticDateOperation = SemanticDateOperators.hasSemanticDateOperations(oTestData.condition);
+			expect(bHasSemanticDateOperation).toEqual(oTestData.expectedResult); // "testing hasSemanticDateOperations " + oTestData.desc + " - done"
 		});
 	});
 });