@sap/open.fe 1.99.0 → 1.100.0

package/packages/sap.fe.core/test/sap/fe/core/jest/CommonUtils.spec.ts

@@ -1,7 +1,14 @@
 import path from "path";
 import CommonUtils from "sap/fe/core/CommonUtils";
+import SelectionVariant from "sap/fe/navigation/SelectionVariant";
 import { compileCDS, getMetaModel } from "sap/fe/test/JestTemplatingHelper";
+import MessageBox from "sap/m/MessageBox";
 import ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
+import * as FilterHelper from "sap/fe/core/templating/FilterHelper";
+import MessageView from "sap/m/MessageView";
+import MessageHandling from "sap/fe/core/actions/messageHandling";
+import Dialog from "sap/m/Dialog";
+import ODataModel from "sap/ui/model/odata/v4/ODataModel";
 
 let metaModel: ODataMetaModel;
 beforeAll(async function() {
@@ -31,8 +38,7 @@ describe("CommonUtils", function() {
 				SalesOrderType: "OR",
 				SalesOrganization: "1"
 			};
-			//@ts-ignore
-			var actualOutput = CommonUtils.getAdditionalParamsForCreate(oUriParams, oInbounds);
+			const actualOutput = CommonUtils.getAdditionalParamsForCreate(oUriParams, oInbounds);
 			expect(actualOutput).toEqual(oExpectedOutput);
 		});
 
@@ -50,8 +56,7 @@ describe("CommonUtils", function() {
 				}
 			};
 			const oExpectedOutput = undefined;
-			//@ts-ignore
-			var actualOutput = CommonUtils.getAdditionalParamsForCreate(oUriParams, oInbounds);
+			const actualOutput = CommonUtils.getAdditionalParamsForCreate(oUriParams, oInbounds);
 			expect(actualOutput).toEqual(oExpectedOutput);
 		});
 
@@ -62,8 +67,7 @@ describe("CommonUtils", function() {
 			};
 			const oInbounds = {};
 			const oExpectedOutput = undefined;
-			//@ts-ignore
-			var actualOutput = CommonUtils.getAdditionalParamsForCreate(oUriParams, oInbounds);
+			const actualOutput = CommonUtils.getAdditionalParamsForCreate(oUriParams, oInbounds);
 			expect(actualOutput).toEqual(oExpectedOutput);
 		});
 
@@ -71,8 +75,7 @@ describe("CommonUtils", function() {
 			const oUriParams = {};
 			const oInbounds = {};
 			const oExpectedOutput = undefined;
-			//@ts-ignore
-			var actualOutput = CommonUtils.getAdditionalParamsForCreate(oUriParams, oInbounds);
+			const actualOutput = CommonUtils.getAdditionalParamsForCreate(oUriParams, oInbounds);
 			expect(actualOutput).toEqual(oExpectedOutput);
 		});
 	});
@@ -80,43 +83,37 @@ describe("CommonUtils", function() {
 	describe("getNonComputedVisibleFields", function() {
 		it("getNonComputedVisibleFields - GUID ComputedDefaultValue key field with text annotation", async function() {
 			const aExpectedOutput = ["ID", "ImmutableNonKeyWithText", "ImmutableNonKeyWithoutText"];
-			//@ts-ignore
-			var actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithKeyFieldHavingText");
+			const actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithKeyFieldHavingText");
 			expect(actualOutput).toEqual(aExpectedOutput);
 		});
 
 		it("getNonComputedVisibleFields - GUID ComputedDefaultValue key field without text annotation", async function() {
 			const aExpectedOutput: any[] = [];
-			//@ts-ignore
-			var actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithKeyFieldNotHavingText");
+			const actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithKeyFieldNotHavingText");
 			expect(actualOutput).toEqual(aExpectedOutput);
 		});
 
 		it("getNonComputedVisibleFields - Hidden GUID ComputedDefaultValue key field", async function() {
 			const aExpectedOutput: any[] = [];
-			//@ts-ignore
-			var actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithHiddenKeyField");
+			const actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithHiddenKeyField");
 			expect(actualOutput).toEqual(aExpectedOutput);
 		});
 
 		it("getNonComputedVisibleFields - ReadOnly GUID ComputedDefaultValue key field", async function() {
 			const aExpectedOutput: any[] = ["ID"];
-			//@ts-ignore
-			var actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithReadOnlyKeyFieldHavingText");
+			const actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithReadOnlyKeyFieldHavingText");
 			expect(actualOutput).toEqual(aExpectedOutput);
 		});
 
 		it("getNonComputedVisibleFields - ReadOnly GUID ComputedDefaultValue key field", async function() {
 			const aExpectedOutput: any[] = [];
-			//@ts-ignore
-			var actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithReadOnlyKeyFieldNotHavingText");
+			const actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithReadOnlyKeyFieldNotHavingText");
 			expect(actualOutput).toEqual(aExpectedOutput);
 		});
 
 		it("getNonComputedVisibleFields - GUID key field with both Computed and ComputeDefaultValue annotation without view", async function() {
 			const aExpectedOutput: any[] = [];
-			//@ts-ignore
-			var actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithComputedAndComputedDefaultValueKeyField");
+			const actualOutput = CommonUtils.getNonComputedVisibleFields(metaModel, "/EntityWithComputedAndComputedDefaultValueKeyField");
 			expect(actualOutput).toEqual(aExpectedOutput);
 		});
 
@@ -128,8 +125,7 @@ describe("CommonUtils", function() {
 					addIssue: jest.fn().mockReturnValue("")
 				})
 			};
-			//@ts-ignore
-			var actualOutput = CommonUtils.getNonComputedVisibleFields(
+			const actualOutput = CommonUtils.getNonComputedVisibleFields(
 				metaModel,
 				"/EntityWithComputedAndComputedDefaultValueKeyField",
 				oView
@@ -137,65 +133,2208 @@ describe("CommonUtils", function() {
 			expect(oView.getDiagnostics().addIssue).toHaveBeenCalled();
 			expect(actualOutput).toEqual(aExpectedOutput);
 		});
-		describe("getOperatorsForProperty", function() {
-			it("getOperatorsForProperty - Single Value Allowed Expressions", async function() {
-				[
-					{
-						dataField: "SalesOrderDate",
-						oContext: {
-							getObject: function(path: string) {
-								// Edm type
-								if (path === "/dummy/SalesOrderDate/$Type") {
-									return "Edm.Date";
-								} else {
-									// Filter Annotations
+	});
+	describe("getOperatorsForProperty", function() {
+		it("getOperatorsForProperty - Single Value Allowed Expressions", async function() {
+			[
+				{
+					dataField: "SalesOrderDate",
+					oContext: {
+						getObject: function(path: string) {
+							// Edm type
+							if (path === "/dummy/SalesOrderDate/$Type") {
+								return "Edm.Date";
+							} else {
+								// Filter Annotations
+								return {
+									FilterExpressionRestrictions: [
+										{
+											Property: { $PropertyPath: "SalesOrderDate" },
+											AllowedExpressions: "SingleValue"
+										}
+									]
+								};
+							}
+						}
+					},
+					expectedValue:
+						"DATE,TODAY,YESTERDAY,TOMORROW,FIRSTDAYWEEK,LASTDAYWEEK,FIRSTDAYMONTH,LASTDAYMONTH,FIRSTDAYQUARTER,LASTDAYQUARTER,FIRSTDAYYEAR,LASTDAYYEAR",
+					sMessage: "Edm.Date and Single Value Or Search Expressions"
+				},
+				{
+					dataField: "SalesOrderDate",
+					oContext: {
+						getObject: function(path: string) {
+							// Edm type
+							if (path === "/dummy/SalesOrderDate/$Type") {
+								return "Edm.String";
+							} else {
+								// Filter Annotations
+								return {
+									FilterExpressionRestrictions: [
+										{
+											Property: { $PropertyPath: "SalesOrderDate" },
+											AllowedExpressions: "SingleValue"
+										}
+									]
+								};
+							}
+						}
+					},
+					expectedValue: "EQ",
+					sMessage: "Edm.String and Single Value Or Search Expressions"
+				}
+			].forEach(function(oProperty) {
+				const actualValue = CommonUtils.getOperatorsForProperty(
+					oProperty.dataField,
+					"/dummy",
+					oProperty.oContext,
+					oProperty.oContext.getObject("/dummy/" + oProperty.dataField + "/$Type"),
+					true
+				);
+				expect(actualValue).toEqual(oProperty.expectedValue);
+			});
+		});
+	});
+	describe("CommonUtils - normalizeSearchTerm() input ", function() {
+		const aTests = [
+			{
+				title: "is an empty search string",
+				input: "",
+				expected: undefined
+			},
+			{
+				title: "is an undefined search term",
+				input: undefined,
+				expected: undefined
+			},
+			{
+				title: "is a double quote",
+				input: '"',
+				expected: undefined
+			},
+			{
+				title: "is a single quote",
+				input: "'",
+				expected: '"\'"'
+			},
+			{
+				title: "contains two words",
+				input: "Wuthering Heights",
+				expected: '"Wuthering" "Heights"'
+			},
+			{
+				title: "contains a tab in between",
+				input: "Word0 Word1\tWord2 Word3",
+				expected: '"Word0" "Word1" "Word2" "Word3"'
+			},
+			{
+				title: "contains a return in between",
+				input: "Word0 Word1\nWord2\r\nWord3",
+				expected: '"Word0" "Word1" "Word2" "Word3"'
+			},
+			{
+				title: "contains multiple words with multiple spaces at the beginning",
+				input: "     Wuthering, Heights Part-II",
+				expected: '"Wuthering," "Heights" "Part-II"'
+			},
+			{
+				title: "contains multiple words with multiple spaces in between",
+				input: "Wuthering,    Heights Part-  II",
+				expected: '"Wuthering," "Heights" "Part-" "II"'
+			},
+			{
+				title: "contains multiple words with multiple spaces at the end",
+				input: "Wuthering, Heights Part-II    ",
+				expected: '"Wuthering," "Heights" "Part-II"'
+			},
+			{
+				title: "contains double quotes at the beginning",
+				input: '"Wuthering my Heights',
+				expected: '"Wuthering" "my" "Heights"'
+			},
+			{
+				title: "contains double quotes in between",
+				input: 'Wuth"ering',
+				expected: '"Wuth" "ering"'
+			},
+			{
+				title: "contains double quotes at the end",
+				input: 'Wuthering no heights"',
+				expected: '"Wuthering" "no" "heights"'
+			},
+			{
+				title: "contains multiple double quotes at the beginning",
+				input: '""Wuth"ering Heig"hts',
+				expected: '"Wuth" "ering" "Heig" "hts"'
+			},
+			{
+				title: "contains multiple double quotes in between",
+				input: 'Wuth"eri""ng Heig"hts',
+				expected: '"Wuth" "eri" "ng" "Heig" "hts"'
+			},
+			{
+				title: "contains multiple double quotes at the end",
+				input: 'Wuth"ering He"ights""',
+				expected: '"Wuth" "ering" "He" "ights"'
+			},
+			{
+				title: "contains a special character in string",
+				input: "Wuth)ering",
+				expected: '"Wuth)ering"'
+			},
+			{
+				title: "contains multiple special characters in string",
+				input: "W!u$t^h)er&in*g(",
+				expected: '"W!u$t^h)er&in*g("'
+			},
+			{
+				title: "contains single quotes in string",
+				input: "It's Apple's new iPhone",
+				expected: '"It\'s" "Apple\'s" "new" "iPhone"'
+			}
+		];
+
+		aTests.forEach(test => {
+			it(
+				test.title,
+				{
+					"references": [
+						{
+							"type": "JIRA",
+							"ID": "FIORITECHP1-21846"
+						}
+					]
+				},
+				function() {
+					expect(CommonUtils.normalizeSearchTerm(test.input as string)).toBe(test.expected);
+				}
+			);
+		});
+	});
+	describe("Unit Test for isStickyEditMode", function() {
+		test("Unit test to check isStickyEditMode", function() {
+			[
+				{
+					"oControl": {
+						getModel: function() {
+							return {
+								getMetaModel: function() {
 									return {
-										FilterExpressionRestrictions: [
-											{
-												Property: { $PropertyPath: "SalesOrderDate" },
-												AllowedExpressions: "SingleValue"
-											}
-										]
+										getObject: function(sParam: string) {
+											return sParam === "/"
+												? {
+														"rootEntitySet": { $kind: "EntitySet" }
+												  }
+												: {
+														"@com.sap.vocabularies.Session.v1.StickySessionSupported": true
+												  };
+										}
 									};
+								},
+								getProperty: function() {
+									return true;
 								}
-							}
+							};
+						}
+					},
+					"expectedValue": true,
+					"sMessage": "Matched"
+				},
+				{
+					"oControl": {
+						getModel: function() {
+							return {
+								getMetaModel: function() {
+									return {
+										getObject: function(sParam: string) {
+											return sParam === "/"
+												? {
+														"rootEntitySet": { $kind: "EntitySet" }
+												  }
+												: null;
+										}
+									};
+								},
+								getProperty: function() {
+									return true;
+								}
+							};
+						}
+					},
+					"expectedValue": false,
+					"sMessage": "Matched"
+				},
+				{
+					"oControl": {
+						getModel: function() {
+							return {
+								getMetaModel: function() {
+									return {
+										getObject: function(sParam: string) {
+											return sParam === "/"
+												? {
+														"rootEntitySet": { $kind: "EntitySet" }
+												  }
+												: {
+														"@com.sap.vocabularies.Session.v1.StickySessionSupported": true
+												  };
+										}
+									};
+								},
+								getProperty: function() {
+									return false;
+								}
+							};
+						}
+					},
+					"expectedValue": false,
+					"sMessage": "Matched"
+				}
+			].forEach(function(oProperty: any) {
+				const actualValue = CommonUtils.isStickyEditMode(oProperty.oControl);
+				expect(actualValue).toEqual(oProperty.expectedValue); //, "Unit test to check isStickyEditMode() " + oProperty.sMessage + " : ok");
+			});
+		});
+	});
+
+	describe("Unit Test for isFieldControlPathInapplicable", function() {
+		test("Unit test to check isFieldControlPathInapplicable", function() {
+			[
+				{
+					"attribute": {
+						"prop1": "A",
+						"prop2": "B",
+						"fieldControl": 0
+					},
+					"fieldControlPath": "fieldControl",
+					"expectedValue": true,
+					"message": "for inapplicable"
+				},
+				{
+					"attribute": {
+						"prop1": "A",
+						"prop2": "B",
+						"fieldControl": 7
+					},
+					"fieldControlPath": "fieldControl",
+					"expectedValue": false,
+					"message": "for different value"
+				},
+				{
+					"attribute": {
+						"prop1": "A",
+						"prop2": "B"
+					},
+					"fieldControlPath": "fieldControl",
+					"expectedValue": false,
+					"message": "when property doesn't exists"
+				}
+			].forEach(function(oProperty) {
+				const actualValue = CommonUtils.isFieldControlPathInapplicable(oProperty.fieldControlPath, oProperty.attribute);
+				expect(actualValue).toEqual(oProperty.expectedValue); // ,"Unit test to check isFieldControlPathInapplicable() " + oProperty.message + " : ok"
+			});
+		});
+	});
+
+	describe("Unit Test for Remove Sensitive Data", function() {
+		test("Unit Test to check removeSensitiveData", function() {
+			const aAttributes = [
+					{
+						"contextData": {
+							"%40odata.context": "yolo",
+							"SensitiveProp": "A",
+							"PublicationUUID": "00505691-8175-1ed8-9dbe-64c14268326b",
+							"FieldControlStatic": "D",
+							"fieldControl": 0
+						},
+						"entitySet": "SalesOrderManage"
+					},
+					{
+						"contextData": {
+							"%40odata.metadataEtag": "yolo",
+							"ExcludeNavProp": "B",
+							"PublicationUUID": "00505691-8175-1ed8-9dbe-64c14268326888",
+							"fieldControl": 7
+						},
+						"entitySet": "SalesOrderManage"
+					},
+					{
+						"contextData": {
+							"HasActiveEntity": false
 						},
-						expectedValue: "DATE,TODAY,YESTERDAY,TOMORROW",
-						sMessage: "Edm.Date and Single Value Or Search Expressions"
+						"entitySet": "SalesOrderManage"
+					}
+				],
+				oMetaModel = {
+					getObject: function(sPath: string) {
+						if (sPath.indexOf("PublicationUUID@") > -1) {
+							return {
+								"@com.sap.vocabularies.Common.v1.FieldControl": {
+									"$Path": "fieldControl"
+								}
+							};
+						} else if (sPath.indexOf("FieldControlStatic@") > -1) {
+							return {
+								"@com.sap.vocabularies.Common.v1.FieldControl": {
+									"$EnumMember": "@com.sap.vocabularies.Common.v1.FieldControl/Inapplicable"
+								}
+							};
+						} else if (sPath.indexOf("SensitiveProp@") > -1) {
+							return {
+								"@com.sap.vocabularies.PersonalData.v1.IsPotentiallySensitive": {
+									"$Path": "fieldControl"
+								}
+							};
+						} else if (sPath.indexOf("ExcludeNavProp@") > -1) {
+							return {
+								"@com.sap.vocabularies.UI.v1.ExcludeFromNavigationContext": {
+									"$Path": "fieldControl"
+								}
+							};
+						}
+					}
+				},
+				ExpectedResult = [
+					{
+						"fieldControl": 0
+					},
+					{
+						"PublicationUUID": "00505691-8175-1ed8-9dbe-64c14268326888",
+						"fieldControl": 7
 					},
 					{
-						dataField: "SalesOrderDate",
-						oContext: {
-							getObject: function(path: string) {
-								// Edm type
-								if (path === "/dummy/SalesOrderDate/$Type") {
+						"HasActiveEntity": false
+					}
+				];
+			const Result = CommonUtils.removeSensitiveData(aAttributes, oMetaModel as any);
+			expect(JSON.stringify(ExpectedResult)).toEqual(JSON.stringify(Result));
+		});
+	});
+
+	describe("Unit Test for isPropertyFilterable", function() {
+		test("Unit test to check isPropertyFilterable with hidden", function() {
+			const fnCreateModel = function(oModel: any) {
+				return Object.assign(
+					{
+						createBindingContext: function() {
+							return {
+								getProperty: oModel.getObject
+							};
+						},
+						getProperty: function(sPath: string) {
+							return sPath === "/parameterEntity/@com.sap.vocabularies.Common.v1.ResultContext";
+						},
+						getObject: function(sPath: string) {
+							return sPath === "/parameterEntity/@com.sap.vocabularies.Common.v1.ResultContext";
+						}
+					},
+					oModel
+				);
+			};
+
+			[
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (sPath === "@com.sap.vocabularies.UI.v1.Hidden") {
+								return true;
+							}
+							return { "prop1": {} };
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: false,
+					message: "full path and hidden"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (sPath === "@com.sap.vocabularies.UI.v1.HiddenFilter") {
+								return true;
+							}
+							return { "prop1": {} };
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: false,
+					message: "full path and hidden filter"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (sPath === "@com.sap.vocabularies.UI.v1.Hidden") {
+								return true;
+							}
+							return { "prop1": {} };
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: false,
+					message: "hidden"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (sPath === "@com.sap.vocabularies.UI.v1.HiddenFilter") {
+								return true;
+							}
+							return { "prop1": {} };
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: false,
+					message: "hidden filter"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (sPath === "/entitySet@Org.OData.Capabilities.V1.FilterRestrictions") {
+								return {
+									NonFilterableProperties: [
+										{
+											$PropertyPath: "prop1"
+										}
+									]
+								};
+							}
+							return { "prop1": {} };
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: false,
+					message: "non-filterable"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (sPath === "/entitySet@Org.OData.Capabilities.V1.FilterRestrictions") {
+								return {
+									NonFilterableProperties: [
+										{
+											$PropertyPath: "prop1"
+										}
+									]
+								};
+							}
+							return { "prop1": {} };
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: false,
+					message: "full path and non-filterable"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (!sPath) {
+								return {};
+							}
+							switch (sPath) {
+								case "/entitySet/prop1@com.sap.vocabularies.UI.v1.HiddenFilter":
+									return true;
+								case "$Type":
+									return "Edm.String";
+								case "$kind":
+									return "Property";
+								case "/entitySet/":
+									return { "prop1": {} };
+								default:
+									return undefined;
+							}
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: true,
+					expectedValue: true,
+					message: "skip hidden filter"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (!sPath) {
+								return {};
+							}
+							switch (sPath) {
+								case "$Type":
+									return "Edm.Stream";
+								case "$kind":
+									return "Property";
+								case "/entitySet/":
+									return { "prop1": {} };
+								default:
+									return undefined;
+							}
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: false,
+					message: "type not filterable"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (!sPath) {
+								return {};
+							}
+							switch (sPath) {
+								case "$Type":
+									return "Edm.String";
+								case "$kind":
+									return "Property";
+								case "/entitySet/":
+									return { "prop1": {} };
+								default:
+									return undefined;
+							}
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: true,
+					message: "type filterable"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (!sPath) {
+								return {};
+							}
+							switch (sPath) {
+								case "$Type":
+									return "com.sap.vocabularies.UI.v1.DataField";
+								case "Value/$Path/$Type":
+									return "Edm.Stream";
+								case "/entitySet/":
+									return { "prop1": {} };
+								default:
+									return undefined;
+							}
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: false,
+					message: "datafield type not filterable"
+				},
+				{
+					model: {
+						getObject: function(sPath: string) {
+							if (!sPath) {
+								return {};
+							}
+							switch (sPath) {
+								case "$Type":
+									return "com.sap.vocabularies.UI.v1.DataField";
+								case "Value/$Path/$Type":
 									return "Edm.String";
-								} else {
-									// Filter Annotations
+								case "/entitySet/":
+									return { "prop1": {} };
+								default:
+									return undefined;
+							}
+						}
+					},
+					entitySetPath: "/entitySet",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: true,
+					message: "datafield type filterable"
+				},
+				{
+					model: {},
+					entitySetPath: "/parameterEntity",
+					property: "prop1",
+					skipHiddenFilter: false,
+					expectedValue: true,
+					message: "parameter"
+				}
+			].forEach(function(oProperty) {
+				const actualValue = CommonUtils.isPropertyFilterable(
+					fnCreateModel(oProperty.model),
+					oProperty.entitySetPath,
+					oProperty.property,
+					oProperty.skipHiddenFilter
+				);
+				expect(actualValue).toEqual(oProperty.expectedValue); // ,"Unit test to check isPropertyFilterable with " + oProperty.message + " : ok"
+			});
+		});
+	});
+
+	describe("Test CommonUtils : addSelectionVariantToConditions", function() {
+		const that: any = {};
+		beforeEach(() => {
+			//CREATE MOCK
+			that.getValueStub = jest.spyOn(FilterHelper, "getTypeCompliantValue").mockImplementation(function fakeFn(oValue) {
+				return oValue;
+			});
+			that.getOperatorStub = jest.spyOn(CommonUtils, "getOperatorsForProperty").mockImplementation(function fakeFn() {
+				return undefined;
+			});
+			that.getValidPropsStub = jest.spyOn(CommonUtils, "getContextPathProperties").mockImplementation(function fakeFn(oValue) {
+				return that.validProperties;
+			});
+			that.getFilterableStub = jest.spyOn(CommonUtils, "isPropertyFilterable").mockImplementation(function fakeFn(oValue) {
+				return true;
+			});
+			that.getParameterInfoStub = jest.spyOn(CommonUtils, "getParameterInfo").mockImplementation(function fakeFn(oValue) {
+				return that.parameterInfo;
+			});
+		});
+		afterEach(() => {
+			//RESTORE
+			that.getValueStub.mockRestore();
+			that.getOperatorStub.mockRestore();
+			that.getValidPropsStub.mockRestore();
+			that.getFilterableStub.mockRestore();
+			that.getParameterInfoStub.mockRestore();
+		});
+
+		test("Test convertion of Selection Variant to conditions without valid properties.", function() {
+			const oSV = new SelectionVariant(),
+				oConditions = {};
+
+			oSV.addSelectOption("attribute1", "I", "EQ", "value1");
+			that.validProperties = {};
+			that.parameterInfo = {};
+			CommonUtils.addSelectionVariantToConditions(oSV, oConditions, {} as any, "");
+
+			//CHECK
+			expect(Object.keys(oConditions).length).toEqual(0); //, "CommonUtils: No conditions are added without any valid properties.");
+		});
+
+		test("Test conversion of Selection Variant to conditions with empty SV.", function() {
+			const oSV = new SelectionVariant(),
+				oConditions = {};
+
+			that.validProperties = {
+				"attribute1": {
+					$Type: "Edm.Boolean"
+				},
+				"attribute2": {
+					$Type: "Edm.String"
+				}
+			};
+			that.parameterInfo = {};
+
+			CommonUtils.addSelectionVariantToConditions(oSV, oConditions, {} as any, "");
+
+			//CHECK
+			expect(Object.keys(oConditions).length).toEqual(0); // "CommonUtils: No conditions are added with empty SV.");
+		});
+
+		test("Test conversion of Selection Variant to conditions.", function() {
+			let oSV = new SelectionVariant();
+			const oConditions: any = {};
+			let iCount = 0;
+
+			that.validProperties = {
+				"attribute1": {
+					$Type: "Edm.Boolean"
+				},
+				"attribute2": {
+					$Type: "Edm.String"
+				},
+				"Material": {
+					$Type: "Edm.String"
+				},
+				"MaterialCategory": {
+					$Type: "Edm.String"
+				},
+				"ItemNumber": {
+					$Type: "Edm.String"
+				},
+				"CityName": {
+					$Type: "Edm.String"
+				}
+			};
+			that.parameterInfo = {};
+			const oMetaModel = {
+				getObject: function(sPath: string) {
+					if (sPath.includes("_Item")) {
+						return { sPath: sPath, $isCollection: true, $Type: "Edm.String" };
+					} else {
+						return { sPath: sPath, $Type: "Edm.String" };
+					}
+				}
+			} as ODataMetaModel;
+			oSV.addSelectOption("attribute1", "I", "EQ", "true");
+			oSV.addSelectOption("attribute2", "I", "EQ", "value1");
+			oSV.addSelectOption("attribute2", "I", "EQ", "value2");
+			oSV.addSelectOption("SalesOrderManage._Item.Material", "I", "EQ", "VNG01");
+			oSV.addSelectOption("_MaterialDetails.MaterialCategory", "I", "EQ", "A");
+			oSV.addSelectOption("ItemDetails.ItemNumber", "I", "EQ", "10");
+
+			CommonUtils.addSelectionVariantToConditions(oSV, oConditions, oMetaModel, "/SalesOrderManage");
+			oSV = new SelectionVariant();
+			oSV.addSelectOption("Customer.Set.CityName", "I", "EQ", "ABC");
+			CommonUtils.addSelectionVariantToConditions(oSV, oConditions, oMetaModel, "/Customer/Set");
+
+			const aProperties = Object.keys(oConditions);
+			aProperties.forEach(function(sPropertyName) {
+				iCount += oConditions[sPropertyName].length;
+			});
+
+			//CHECK
+			expect(aProperties.length).toEqual(6); // "CommonUtils: Correct no. of propertyPath are added from SV.");
+			expect(iCount).toEqual(7); // "CommonUtils: Correct no. of conditions are added from SV.");
+			expect(oConditions["SalesOrderManage/_Item*/Material"][0].values[0]).toEqual("VNG01"); //, "Conditions for navigation path is added");
+			expect(oConditions["_MaterialDetails/MaterialCategory"][0].values[0]).toEqual("A"); //, "Conditions for navigation path is added");
+			expect(oConditions["ItemDetails/ItemNumber"][0].values[0]).toEqual("10"); //, "Conditions for navigation path is added");
+			expect(oConditions["Customer/Set/CityName"][0].values[0]).toEqual("ABC"); //"Conditions for navigation path in case of pamaterized service is added"
+		});
+
+		test("Test conversion of Selection Variant to conditions with parameters.", function() {
+			const oSV = new SelectionVariant(),
+				oConditions: any = {};
+			let iCount = 0;
+
+			that.validProperties = {
+				"attribute1": {
+					$Type: "Edm.String"
+				}
+			};
+			that.parameterInfo = {
+				contextPath: "/Customer/Set",
+				parameterProperties: {
+					"param1": {
+						$Type: "Edm.Boolean"
+					},
+					"param2": {
+						$Type: "Edm.String"
+					}
+				}
+			};
+
+			oSV.addSelectOption("attribute1", "I", "EQ", "value1");
+			oSV.addSelectOption("$Parameter.param1", "I", "EQ", "true");
+			oSV.addSelectOption("P_param2", "I", "EQ", "paramValue1");
+
+			CommonUtils.addSelectionVariantToConditions(oSV, oConditions, {} as any, "");
+
+			const aProperties = Object.keys(oConditions);
+			aProperties.forEach(function(sPropertyName) {
+				iCount += oConditions[sPropertyName].length;
+			});
+
+			//CHECK
+			expect(aProperties.length).toEqual(3); //, "CommonUtils: Correct no. of propertyPath are added from SV.");
+			expect(iCount).toEqual(3); //, "CommonUtils: Correct no. of conditions are added from SV.");
+		});
+
+		test("Test conversion of Selection Variant to conditions with conflicting parameters.", function() {
+			const oSV = new SelectionVariant(),
+				oConditions: any = {};
+			let iCount = 0;
+
+			that.validProperties = {
+				"attribute1": {
+					$Type: "Edm.String"
+				}
+			};
+			that.parameterInfo = {
+				contextPath: "/Customer/Set",
+				parameterProperties: {
+					"param1": {
+						$Type: "Edm.Boolean"
+					},
+					"param2": {
+						$Type: "Edm.String"
+					}
+				}
+			};
+
+			oSV.addSelectOption("attribute1", "I", "EQ", "value1");
+			oSV.addSelectOption("P_param1", "I", "EQ", "false");
+			oSV.addSelectOption("$Parameter.param1", "I", "EQ", "true");
+			oSV.addSelectOption("$Parameter.param2", "I", "EQ", "paramValue2_$");
+			oSV.addSelectOption("P_param2", "I", "EQ", "paramValue2_P");
+
+			CommonUtils.addSelectionVariantToConditions(oSV, oConditions, {} as any, "");
+
+			const aProperties = Object.keys(oConditions);
+			aProperties.forEach(function(sPropertyName) {
+				iCount += oConditions[sPropertyName].length;
+			});
+
+			const param1Value = oConditions["param1"][0].values[0] === true;
+			const param2Value = oConditions["param2"][0].values[0] === "paramValue2_$";
+			//CHECK
+			expect(param1Value && param2Value).toBe(true); //, "CommonUtils: Correct parameter values are added from SV.");
+			expect(aProperties.length).toEqual(3); // === 3, "CommonUtils: Correct no. of propertyPath are added from SV.");
+			expect(iCount).toEqual(3); // === 3, "CommonUtils: Correct no. of conditions are added from SV.");
+		});
+
+		test("Test conversion of Selection Variant to conditions with parameters case of 'param -> P_param'.", function() {
+			const oSV = new SelectionVariant(),
+				oConditions: any = {};
+			let iCount = 0;
+
+			that.validProperties = {
+				"attribute1": {
+					$Type: "Edm.String"
+				}
+			};
+			that.parameterInfo = {
+				contextPath: "/Customer/Set",
+				parameterProperties: {
+					"P_param1": {
+						$Type: "Edm.String"
+					}
+				}
+			};
+
+			oSV.addSelectOption("attribute1", "I", "EQ", "value1");
+			oSV.addSelectOption("param1", "I", "EQ", "paramValue1");
+
+			CommonUtils.addSelectionVariantToConditions(oSV, oConditions, {} as any, "");
+
+			const aProperties = Object.keys(oConditions);
+			aProperties.forEach(function(sPropertyName) {
+				iCount += oConditions[sPropertyName].length;
+			});
+
+			const param1Value = oConditions["P_param1"][0].values[0] === "paramValue1";
+			//CHECK
+			expect(param1Value).toBe(true); // "CommonUtils: Correct parameter values are added from SV.");
+			expect(aProperties.length).toEqual(2); // === 2, "CommonUtils: Correct no. of propertyPath are added from SV.");
+			expect(iCount).toEqual(2); // === 2, "CommonUtils: Correct no. of conditions are added from SV.");
+		});
+
+		test("Test conversion of Selection Variant to conditions with parameters case of fall back to filter field.", function() {
+			const oSV = new SelectionVariant(),
+				oConditions: any = {};
+			let iCount = 0;
+
+			that.validProperties = {
+				"attribute1": {
+					$Type: "Edm.String"
+				},
+				"param2": {
+					$Type: "Edm.String"
+				}
+			};
+			that.parameterInfo = {
+				contextPath: "/Customer/Set",
+				parameterProperties: {
+					"P_param1": {
+						$Type: "Edm.String"
+					}
+				}
+			};
+
+			oSV.addSelectOption("attribute1", "I", "EQ", "value1");
+			oSV.addSelectOption("P_param2", "I", "EQ", "paramValue2");
+
+			CommonUtils.addSelectionVariantToConditions(oSV, oConditions, {} as any, "");
+
+			const aProperties = Object.keys(oConditions);
+			aProperties.forEach(function(sPropertyName) {
+				iCount += oConditions[sPropertyName].length;
+			});
+
+			const param2Value = oConditions["param2"][0].values[0] === "paramValue2";
+			//CHECK
+			expect(param2Value).toBe(true); //, "CommonUtils: Correct parameter values are added from SV.");
+			expect(aProperties.length).toEqual(2); //== 2, "CommonUtils: Correct no. of propertyPath are added from SV.");
+			expect(iCount).toEqual(2); //, "CommonUtils: Correct no. of conditions are added from SV.");
+		});
+
+		test("Test conversion of Selection Variant to conditions with already existing conditions.", function() {
+			const oSV = new SelectionVariant(),
+				oConditions: any = {
+					"attribute2": [
+						{
+							"operator": "EQ",
+							"values": ["value3"]
+						}
+					]
+				};
+			let iCount = 0;
+
+			that.validProperties = {
+				"attribute1": {
+					$Type: "Edm.Boolean"
+				},
+				"attribute2": {
+					$Type: "Edm.String"
+				}
+			};
+			that.parameterInfo = {};
+
+			oSV.addSelectOption("attribute1", "I", "EQ", "true");
+			oSV.addSelectOption("attribute2", "I", "EQ", "value1");
+			oSV.addSelectOption("attribute2", "I", "EQ", "value2");
+
+			CommonUtils.addSelectionVariantToConditions(oSV, oConditions, {} as any, "");
+
+			const aProperties = Object.keys(oConditions);
+			aProperties.forEach(function(sPropertyName) {
+				iCount += oConditions[sPropertyName].length;
+			});
+
+			//CHECK
+			expect(aProperties.length).toEqual(2); // === 2, "CommonUtils: Correct no. of propertyPath are added from SV.");
+			expect(iCount).toEqual(4); // 4, "CommonUtils: Correct no. of conditions are added from SV.");
+		});
+	});
+
+	describe("addExternalStateFiltersToSelectionVariant", function() {
+		test("addExternalStateFiltersToSelectionVariant", function() {
+			const oInputSelectionVariant = new SelectionVariant();
+			const oTargetInfo = {
+				"propertiesWithoutConflict": {
+					"Material": ["SalesOrderManage.Material"]
+				}
+			};
+			const mFilters = {
+				"filterConditions": {
+					"Date": [
+						{
+							"operator": "EQ",
+							"values": ["2020-03-04"]
+						}
+					],
+					"DateTimeOffset": [
+						{
+							"operator": "EQ",
+							"values": ["2020-03-04T20:53:54+0530"]
+						}
+					],
+					"TimeOfDay": [
+						{
+							"operator": "EQ",
+							"values": ["16:51:51"]
+						}
+					],
+					"String": [],
+					"Boolean": [
+						{
+							"operator": "EEQ",
+							"values": [true]
+						}
+					],
+					"Byte": [
+						{
+							"operator": "EQ",
+							"values": [4]
+						}
+					],
+					"ByteMulti": [
+						{
+							"operator": "LE",
+							"values": [5]
+						},
+						{
+							"operator": "GE",
+							"values": [10]
+						}
+					],
+					"DateTimeOffsetMulti": [
+						{
+							"operator": "NOTGT",
+							"values": ["2020-03-25T20:55:42+0530"]
+						},
+						{
+							"operator": "NOTLT",
+							"values": ["2020-02-01T20:55:51+0530"]
+						}
+					],
+					"Decimal": [
+						{
+							"operator": "EQ",
+							"values": ["4.45"]
+						}
+					],
+					"DecimalMulti": [
+						{
+							"operator": "NE",
+							"values": ["6.25"]
+						}
+					],
+					"Double": [
+						{
+							"operator": "EQ",
+							"values": [3.333333]
+						}
+					],
+					"DoubleMulti": [
+						{
+							"operator": "NOTGE",
+							"values": [6.666666666]
+						},
+						{
+							"operator": "NOTGT",
+							"values": [10.0000099999]
+						}
+					],
+					"Guid": [
+						{
+							"operator": "EQ",
+							"values": ["11111182-aaaa-bbbb-cccc-ddddeeeeffff"]
+						}
+					],
+					"GuidMulti": [
+						{
+							"operator": "EQ",
+							"values": ["11111183-aaaa-bbbb-cccc-ddddeeeeffff"]
+						},
+						{
+							"operator": "EQ",
+							"values": ["11111185-aaaa-bbbb-cccc-ddddeeeeffff"]
+						}
+					],
+					"Int16": [
+						{
+							"operator": "EQ",
+							"values": [10]
+						}
+					],
+					"Empty": [
+						{
+							"operator": "Empty",
+							"values": []
+						}
+					],
+					"Int16Multi": [
+						{
+							"operator": "EQ",
+							"values": [15]
+						},
+						{
+							"operator": "NOTGE",
+							"values": [10000]
+						},
+						{
+							"operator": "NOTBT",
+							"values": [100, 200]
+						},
+						{
+							"operator": "NOTLT",
+							"values": [10]
+						}
+					],
+					"Int32": [
+						{
+							"operator": "EQ",
+							"values": [9999999]
+						}
+					],
+					"Int32Multi": [
+						{
+							"operator": "BT",
+							"values": [1000000, 1000000000]
+						}
+					],
+					"Int64": [
+						{
+							"operator": "EQ",
+							"values": ["99"]
+						}
+					],
+					"Int64Multi": [
+						{
+							"operator": "NOTLT",
+							"values": ["9999999"]
+						},
+						{
+							"operator": "NE",
+							"values": ["99999"]
+						}
+					],
+					"SByte": [
+						{
+							"operator": "EQ",
+							"values": [1]
+						}
+					],
+					"SByteMulti": [
+						{
+							"operator": "EQ",
+							"values": [2]
+						},
+						{
+							"operator": "GT",
+							"values": [3]
+						}
+					],
+					"Single": [
+						{
+							"operator": "EQ",
+							"values": [1]
+						}
+					],
+					"SingleMulti": [
+						{
+							"operator": "EQ",
+							"values": [2]
+						}
+					],
+					"StringMulti": [
+						{
+							"operator": "EndsWith",
+							"values": ["xyz"]
+						},
+						{
+							"operator": "StartsWith",
+							"values": ["abc"]
+						},
+						{
+							"operator": "Contains",
+							"values": ["def"]
+						},
+						{
+							"operator": "NotStartsWith",
+							"values": ["ijk"]
+						},
+						{
+							"operator": "NotEndsWith",
+							"values": ["uvw"]
+						},
+						{
+							"operator": "NotContains",
+							"values": ["pqr"]
+						}
+					],
+					"TimeOfDayMulti": [
+						{
+							"operator": "EQ",
+							"values": ["22:00:39"]
+						},
+						{
+							"operator": "EQ",
+							"values": ["17:00:43"]
+						}
+					]
+				},
+				"filterConditionsWithoutConflict": {
+					"Material": ["SalesOrderManage._Item.Material"]
+				}
+			};
+			const oOutPutSelectionVariant = CommonUtils.addExternalStateFiltersToSelectionVariant(
+				oInputSelectionVariant,
+				mFilters,
+				oTargetInfo
+			);
+			const oActualSelectionVariant = {
+				_mParameters: {},
+				_mSelectOptions: {
+					"Date": [{ "Sign": "I", "Option": "EQ", "Low": "2020-03-04", "High": null }],
+					"DateTimeOffset": [
+						{
+							"Sign": "I",
+							"Option": "EQ",
+							"Low": "2020-03-04T20:53:54+0530",
+							"High": null
+						}
+					],
+					"TimeOfDay": [{ "Sign": "I", "Option": "EQ", "Low": "16:51:51", "High": null }],
+					"Boolean": [
+						{
+							"Sign": "I",
+							"Option": "EQ",
+							"Low": "true",
+							"High": null
+						}
+					],
+					"Byte": [
+						{
+							"Sign": "I",
+							"Option": "EQ",
+							"Low": "4",
+							"High": null
+						}
+					],
+					"ByteMulti": [
+						{
+							"Sign": "I",
+							"Option": "LE",
+							"Low": "5",
+							"High": null
+						}
+					],
+					"DateTimeOffsetMulti": [
+						{ "Sign": "E", "Option": "GT", "Low": "2020-03-25T20:55:42+0530", "High": null },
+						{ "Sign": "E", "Option": "LT", "Low": "2020-02-01T20:55:51+0530", "High": null }
+					],
+					"Decimal": [
+						{
+							"Sign": "I",
+							"Option": "EQ",
+							"Low": "4.45",
+							"High": null
+						}
+					],
+					"DecimalMulti": [{ "Sign": "I", "Option": "NE", "Low": "6.25", "High": null }],
+					"Double": [{ "Sign": "I", "Option": "EQ", "Low": "3.333333", "High": null }],
+					"DoubleMulti": [
+						{ "Sign": "E", "Option": "GE", "Low": "6.666666666", "High": null },
+						{ "Sign": "E", "Option": "GT", "Low": "10.0000099999", "High": null }
+					],
+					"Empty": [
+						{
+							"High": null,
+							"Low": "",
+							"Option": "EQ",
+							"Sign": "I"
+						}
+					],
+					"Guid": [
+						{
+							"Sign": "I",
+							"Option": "EQ",
+							"Low": "11111182-aaaa-bbbb-cccc-ddddeeeeffff",
+							"High": null
+						}
+					],
+					"GuidMulti": [
+						{
+							"Sign": "I",
+							"Option": "EQ",
+							"Low": "11111183-aaaa-bbbb-cccc-ddddeeeeffff",
+							"High": null
+						},
+						{
+							"Sign": "I",
+							"Option": "EQ",
+							"Low": "11111185-aaaa-bbbb-cccc-ddddeeeeffff",
+							"High": null
+						}
+					],
+					"Int16": [{ "Sign": "I", "Option": "EQ", "Low": "10", "High": null }],
+					"Int16Multi": [
+						{ "Sign": "I", "Option": "EQ", "Low": "15", "High": null },
+						{ "Sign": "E", "Option": "GE", "Low": "10000", "High": null },
+						{ "Sign": "E", "Option": "BT", "Low": "100", "High": "200" },
+						{ "Sign": "E", "Option": "LT", "Low": "10", "High": null }
+					],
+					"Int32": [{ "Sign": "I", "Option": "EQ", "Low": "9999999", "High": null }],
+					"Int32Multi": [{ "Sign": "I", "Option": "BT", "Low": "1000000", "High": "1000000000" }],
+					"Int64": [{ "Sign": "I", "Option": "EQ", "Low": "99", "High": null }],
+					"Int64Multi": [
+						{ "Sign": "E", "Option": "LT", "Low": "9999999", "High": null },
+						{ "Sign": "I", "Option": "NE", "Low": "99999", "High": null }
+					],
+					"SByte": [{ "Sign": "I", "Option": "EQ", "Low": "1", "High": null }],
+					"SByteMulti": [
+						{ "Sign": "I", "Option": "EQ", "Low": "2", "High": null },
+						{ "Sign": "I", "Option": "GT", "Low": "3", "High": null }
+					],
+					"Single": [{ "Sign": "I", "Option": "EQ", "Low": "1", "High": null }],
+					"SingleMulti": [{ "Sign": "I", "Option": "EQ", "Low": "2", "High": null }],
+					"StringMulti": [
+						{ "Sign": "I", "Option": "CP", "Low": "*xyz", "High": null },
+						{ "Sign": "I", "Option": "CP", "Low": "abc*", "High": null },
+						{ "Sign": "I", "Option": "CP", "Low": "def", "High": null },
+						{ "Sign": "E", "Option": "CP", "Low": "ijk*", "High": null },
+						{ "Sign": "E", "Option": "CP", "Low": "*uvw", "High": null },
+						{ "Sign": "E", "Option": "CP", "Low": "pqr", "High": null }
+					],
+					"TimeOfDayMulti": [
+						{ "Sign": "I", "Option": "EQ", "Low": "22:00:39", "High": null },
+						{ "Sign": "I", "Option": "EQ", "Low": "17:00:43", "High": null }
+					]
+				},
+				_sId: ""
+			};
+			expect(oActualSelectionVariant).toEqual(oOutPutSelectionVariant); //"the external state filters have been added to the selection variant correctly"
+		});
+	});
+	describe("Unit Test check Operators", function() {
+		test("Unit test to check Operators", function() {
+			[
+				{
+					dataField: "LastChangedDateTime",
+					oContext: {
+						getObject: function(path: string) {
+							// Edm Type
+							if (path === "/dummy/LastChangedDateTime/$Type") {
+								return "Edm.DateTime";
+							} else {
+								// Filter Annotations
+								return {
+									FilterExpressionRestrictions: [
+										{
+											Property: { $PropertyPath: "LastChangedDateTime" },
+											AllowedExpressions: "SingleRange"
+										}
+									]
+								};
+							}
+						}
+					},
+					expectedValue: "EQ,BT,LT,LE,GT,GE,NOTLT,NOTLE,NOTGT,NOTGE",
+					sMessage: "Edm.String and Single Range"
+				},
+				{
+					dataField: "SalesOrderDate",
+					oContext: {
+						getObject: function(path: string) {
+							// Edm Type
+							if (path === "/dummy/SalesOrderDate/$Type") {
+								return "Edm.Date";
+							} else {
+								// Filter Annotations
+								return {
+									FilterExpressionRestrictions: [
+										{
+											Property: { $PropertyPath: "SalesOrderDate" },
+											AllowedExpressions: "SingleValue"
+										}
+									]
+								};
+							}
+						}
+					},
+					expectedValue: "EQ",
+					sMessage: "Edm.Date and Single Value"
+				},
+				{
+					dataField: "SalesOrderDate",
+					oContext: {
+						getObject: function(path: string) {
+							// Edm Type
+							if (path === "/dummy/SalesOrderDate/$Type") {
+								return "Edm.Date";
+							} else {
+								// Filter Annotations
+								return {
+									FilterExpressionRestrictions: [
+										{
+											Property: { $PropertyPath: "SalesOrderDate" },
+											AllowedExpressions: "MultiValue"
+										}
+									]
+								};
+							}
+						}
+					},
+					expectedValue: "EQ",
+					sMessage: "Edm.Date and Multi Value"
+				},
+				{
+					dataField: "NetAmount",
+					oContext: {
+						getObject: function(path: string) {
+							// Edm Type
+							if (path === "/dummy/NetAmount/$Type") {
+								return "Edm.Decimal";
+							} else {
+								// Filter Annotations
+								return {
+									FilterExpressionRestrictions: [
+										{
+											Property: { $PropertyPath: "NetAmount" },
+											AllowedExpressions: "MultiRange"
+										}
+									]
+								};
+							}
+						}
+					},
+					expectedValue: "EQ,BT,LT,LE,GT,GE,NE,NOTBT,NOTLT,NOTLE,NOTGT,NOTGE",
+					sMessage: "Edm.Decimal and Multi Range"
+				},
+				{
+					dataField: "SoldToParty",
+					oContext: {
+						getObject: function(path: string) {
+							// Edm type
+							if (path === "/dummy/SoldToParty/$Type") {
+								return "Edm.String";
+							} else {
+								// Filter Annotations
+								return {
+									FilterExpressionRestrictions: [
+										{
+											Property: { $PropertyPath: "SoldToParty" },
+											AllowedExpressions: "SearchExpression"
+										}
+									]
+								};
+							}
+						}
+					},
+					expectedValue: "Contains,StartsWith,EndsWith,NotContains,NotStartsWith,NotEndsWith",
+					sMessage: "Edm.String and Search Expressions"
+				},
+				{
+					dataField: "SoldToParty",
+					oContext: {
+						getObject: function(path: string) {
+							// Edm type
+							if (path === "/dummy/SoldToParty/$Type") {
+								return "Edm.String";
+							} else {
+								// Filter Annotations
+								return {
+									FilterExpressionRestrictions: [
+										{
+											Property: { $PropertyPath: "SoldToParty" },
+											AllowedExpressions: "MultiRangeOrSearchExpression"
+										}
+									]
+								};
+							}
+						}
+					},
+					expectedValue:
+						"Contains,EQ,BT,StartsWith,EndsWith,LT,LE,GT,GE,NotContains,NE,NOTBT,NotStartsWith,NotEndsWith,NOTLT,NOTLE,NOTGT,NOTGE",
+					sMessage: "Edm.String and MultiRange Or Search Expressions"
+				}
+			].forEach(function(oProperty) {
+				const actualValue = CommonUtils.getOperatorsForProperty(
+					oProperty.dataField,
+					"/dummy",
+					oProperty.oContext,
+					oProperty.oContext.getObject("/dummy/" + oProperty.dataField + "/$Type")
+				);
+				expect(actualValue).toEqual(oProperty.expectedValue); // , "Unit test to check Operators for " + oProperty.sMessage + ":  ok");
+			});
+		});
+	});
+
+	describe("Test CommonUtils : addDefaultDisplayCurrency", function() {
+		test("Test adding default display currency to SV.", function() {
+			[
+				{
+					aMandatoryFields: [],
+					oAppData: {},
+					oExpectedValue: undefined
+				},
+				{
+					aMandatoryFields: [
+						{
+							$PropertyPath: "DisplayCurrency"
+						}
+					],
+					oAppData: {},
+					oExpectedValue: undefined,
+					sMessage: "no SV in appData"
+				},
+				{
+					aMandatoryFields: [
+						{
+							$PropertyPath: "DisplayCurrency"
+						}
+					],
+					oAppData: {
+						oSelectionVariant: new SelectionVariant()
+					},
+					oExpectedValue: undefined,
+					sMessage: "no Defaulted SV"
+				},
+				{
+					aMandatoryFields: [
+						{
+							$PropertyPath: "DisplayCurrency"
+						}
+					],
+					oAppData: {
+						oSelectionVariant: new SelectionVariant(),
+						oDefaultedSelectionVariant: new SelectionVariant()
+					},
+					oExpectedValue: undefined,
+					sMessage: "no DisplayCurrency in Defaulted SV"
+				},
+				{
+					aMandatoryFields: [
+						{
+							$PropertyPath: "DisplayCurrency"
+						}
+					],
+					oAppData: {
+						oSelectionVariant: new SelectionVariant(),
+						oDefaultedSelectionVariant: new SelectionVariant({
+							"SelectOptions": [
+								{
+									"PropertyName": "DisplayCurrency",
+									"Ranges": [
+										{
+											"Sign": "I",
+											"Option": "EQ",
+											"Low": "EUR",
+											"High": null
+										}
+									]
+								}
+							]
+						})
+					},
+					oExpectedValue: "EUR",
+					sMessage: "DisplayCurrency in Defaulted SV"
+				},
+				{
+					aMandatoryFields: [
+						{
+							$PropertyPath: "DisplayCurrency"
+						}
+					],
+					oAppData: {
+						oSelectionVariant: new SelectionVariant({
+							"SelectOptions": [
+								{
+									"PropertyName": "DisplayCurrency",
+									"Ranges": [
+										{
+											"Sign": "I",
+											"Option": "EQ",
+											"Low": "INR",
+											"High": null
+										}
+									]
+								}
+							]
+						}),
+						oDefaultedSelectionVariant: new SelectionVariant({
+							"SelectOptions": [
+								{
+									"PropertyName": "DisplayCurrency",
+									"Ranges": [
+										{
+											"Sign": "I",
+											"Option": "EQ",
+											"Low": "EUR",
+											"High": null
+										}
+									]
+								}
+							]
+						})
+					},
+					oExpectedValue: "INR",
+					sMessage: "DisplayCurrency in SV and Defaulted SV"
+				}
+			].forEach(function(oTestData) {
+				CommonUtils.addDefaultDisplayCurrency(
+					oTestData.aMandatoryFields,
+					oTestData.oAppData.oSelectionVariant,
+					oTestData.oAppData.oDefaultedSelectionVariant
+				);
+				expect(
+					oTestData.oAppData &&
+						oTestData.oAppData.oSelectionVariant &&
+						oTestData.oAppData.oSelectionVariant.getSelectOption("DisplayCurrency") &&
+						oTestData.oAppData.oSelectionVariant.getSelectOption("DisplayCurrency")[0].Low
+				).toEqual(oTestData.oExpectedValue); // ,"NavHelper: addDefaultDisplayCurrency works when " + oTestData.sMessage + "."
+			});
+		});
+	});
+
+	describe("Unit Test to check getNonComputedVisibleFields", function() {
+		test("Unit Test to check getNonComputedVisibleFields", function() {
+			[
+				{
+					metaModel: {
+						getObject: function(sPath: string) {
+							switch (sPath) {
+								case "/SalesOrderItem/":
+									return {
+										"$Key": ["key1", "key2"],
+										"key1": {
+											$kind: "Property"
+										},
+										"key2": {
+											$kind: "Property"
+										},
+										"prop1": {
+											$kind: "Property"
+										}
+									};
+								case "/SalesOrderItem/key2@":
+									return {
+										"@Org.OData.Core.V1.Computed": false
+									};
+								case "/SalesOrderItem/prop1@":
+									return {
+										"@Org.OData.Core.V1.Immutable": true
+									};
+								default:
+									return {};
+							}
+						}
+					},
+					path: "/SalesOrderItem",
+					expectedValue: "key1,key2,prop1",
+					message: "with technical keys and immutable prop"
+				},
+				{
+					metaModel: {
+						getObject: function(sPath: string) {
+							switch (sPath) {
+								case "/SalesOrderItem/":
+									return {
+										"$Key": ["key1", "key2"],
+										"key1": {
+											$kind: "Property"
+										},
+										"key2": {
+											$kind: "Property"
+										},
+										"prop1": {
+											$kind: "Property"
+										}
+									};
+								default:
+									return {};
+							}
+						}
+					},
+					path: "/SalesOrderItem",
+					expectedValue: "key1,key2",
+					message: "with technical keys and no immutable prop"
+				},
+				{
+					metaModel: {
+						getObject: function(sPath: string) {
+							switch (sPath) {
+								case "/SalesOrderItem/":
+									return {
+										"$Key": ["key1", "key2"],
+										"key1": {
+											$kind: "Property"
+										},
+										"key2": {
+											$kind: "Property"
+										},
+										"prop1": {
+											$kind: "Property"
+										}
+									};
+								case "/SalesOrderItem/key2@":
+									return {
+										"@Org.OData.Core.V1.Computed": true
+									};
+								case "/SalesOrderItem/prop1@":
+									return {
+										"@Org.OData.Core.V1.Immutable": true
+									};
+								default:
+									return {};
+							}
+						}
+					},
+					path: "/SalesOrderItem",
+					expectedValue: "key1,prop1",
+					message: "with a computed technical key"
+				},
+				{
+					metaModel: {
+						getObject: function(sPath: string) {
+							switch (sPath) {
+								case "/SalesOrderItem/":
+									return {
+										"$Key": ["key1", "key2"],
+										"key1": {
+											$kind: "Property"
+										},
+										"key2": {
+											$kind: "Property"
+										},
+										"prop1": {
+											$kind: "Property"
+										}
+									};
+								case "/SalesOrderItem/key2@":
+									return {
+										"@com.sap.vocabularies.UI.v1.Hidden": true
+									};
+								case "/SalesOrderItem/prop1@":
+									return {
+										"@Org.OData.Core.V1.Immutable": true
+									};
+								default:
+									return {};
+							}
+						}
+					},
+					path: "/SalesOrderItem",
+					expectedValue: "key1,prop1",
+					message: "with a hidden technical key"
+				},
+				{
+					metaModel: {
+						getObject: function(sPath: string) {
+							switch (sPath) {
+								case "/SalesOrderItem/":
+									return {
+										"$Key": ["key1", "key2"],
+										"key1": {
+											$kind: "Property"
+										},
+										"key2": {
+											$kind: "Property"
+										},
+										"prop1": {
+											$kind: "Property"
+										}
+									};
+								case "/SalesOrderItem/prop1@":
+									return {
+										"@Org.OData.Core.V1.Immutable": true,
+										"@com.sap.vocabularies.UI.v1.Hidden": true
+									};
+								default:
+									return {};
+							}
+						}
+					},
+					path: "/SalesOrderItem",
+					expectedValue: "key1,key2",
+					message: "with a hidden property"
+				},
+				{
+					metaModel: {
+						getObject: function(sPath: string) {
+							switch (sPath) {
+								case "/SalesOrderItem/":
 									return {
-										FilterExpressionRestrictions: [
-											{
-												Property: { $PropertyPath: "SalesOrderDate" },
-												AllowedExpressions: "SingleValue"
-											}
-										]
+										"$Key": ["key1", "key2"],
+										"key1": {
+											$kind: "Property"
+										},
+										"key2": {
+											$kind: "Property"
+										},
+										"prop1": {
+											$kind: "Property"
+										}
 									};
+								case "/SalesOrderItem/prop1@":
+									return {
+										"@Org.OData.Core.V1.Immutable": true,
+										"@Org.OData.Core.V1.Computed": true
+									};
+								default:
+									return {};
+							}
+						}
+					},
+					path: "/SalesOrderItem",
+					expectedValue: "key1,key2",
+					message: "with a computed property"
+				}
+			].forEach(function(oData) {
+				const aKeyFields = CommonUtils.getNonComputedVisibleFields(oData.metaModel as ODataMetaModel, oData.path);
+				expect(aKeyFields.toString()).toEqual(oData.expectedValue); // ,"getNonComputedVisibleFields executed " + oData.message + " -- OK"
+			});
+		});
+	});
+
+	describe("Unit Test for checking Semantic Object Mappings", function() {
+		test("Testing if semantic Object mappings are getting correcty replaced in the context or not", function() {
+			const oSelectionVariant1 = new SelectionVariant();
+			const oSelectionVariant2 = new SelectionVariant();
+
+			oSelectionVariant1.addSelectOption("SalesOrder", "I", "EQ", "2919682", undefined);
+			oSelectionVariant1.addSelectOption("Delivered", "I", "EQ", "false", undefined);
+
+			oSelectionVariant2.addSelectOption("SalesOrder", "I", "EQ", "2919682", undefined);
+			oSelectionVariant2.addSelectOption("Completed", "I", "EQ", "false", undefined);
+
+			const sMapping1 = '[{"LocalProperty":{"$PropertyPath":"Delivered"},"SemanticObjectProperty":"Completed"}]';
+			// var sMapping2 = '[{"LocalProperty":{"$PropertyPath":"isImageUrl"},"SemanticObjectProperty":"ImageAddress"}]';
+			expect(JSON.stringify(CommonUtils.setSemanticObjectMappings(oSelectionVariant1, sMapping1 as any))).toEqual(
+				JSON.stringify(oSelectionVariant2)
+			);
+		});
+		test("Testing if SelectionVariant remains unchanged if no Mapping matches with any field in context", function() {
+			const oSelectionVariant1 = new SelectionVariant();
+			const oSelectionVariant2 = new SelectionVariant();
+
+			oSelectionVariant1.addSelectOption("SalesOrder", "I", "EQ", "2919682", undefined);
+			oSelectionVariant1.addSelectOption("Delivered", "I", "EQ", "false", undefined);
+
+			oSelectionVariant2.addSelectOption("SalesOrder", "I", "EQ", "2919682", undefined);
+			oSelectionVariant2.addSelectOption("Completed", "I", "EQ", "false", undefined);
+
+			// var sMapping1 = '[{"LocalProperty":{"$PropertyPath":"Delivered"},"SemanticObjectProperty":"Completed"}]';
+			const sMapping2 = '[{"LocalProperty":{"$PropertyPath":"isImageUrl"},"SemanticObjectProperty":"ImageAddress"}]';
+			expect(JSON.stringify(CommonUtils.setSemanticObjectMappings(oSelectionVariant1, sMapping2 as any))).toEqual(
+				JSON.stringify(oSelectionVariant1)
+			);
+		});
+	});
+
+	describe("Unit Test for getHeaderFacetItemConfigForExternalNavigation", function() {
+		test("Unit Test for getHeaderFacetItemConfigForExternalNavigation", function() {
+			[
+				{
+					viewData: {
+						controlConfiguration: {
+							"@com.sap.vocabularies.UI.v1.DataPoint#dp1": {
+								"navigation": {
+									"targetOutbound": {
+										"outbound": "outbound1"
+									}
+								}
+							},
+							"@com.sap.vocabularies.UI.v1.DataPoint#dp2": {
+								"navigation": {
+									"targetOutbound": {
+										"outbound": "outbound1"
+									},
+									"targetSections": {
+										"sectionId": "sectionID1"
+									}
+								}
+							},
+							"@com.sap.vocabularies.UI.v1.Chart#chart1": {
+								"navigation": {
+									"targetOutbound": {
+										"outbound": "outbound1"
+									},
+									"targetSections": {
+										"sectionId": "sectionID1"
+									}
+								}
+							},
+							"@com.sap.vocabularies.UI.v1.Chart#chart2": {
+								"navigation": {
+									"targetSections": {
+										"sectionId": "sectionID1"
+									}
+								}
+							},
+							"_Partner/@com.sap.vocabularies.UI.v1.LineItem": {
+								"tableSettings": {
+									"personalization": false
+								}
+							}
+						}
+					},
+					crossNav: {
+						"outbound1": {
+							semanticObject: "SO1",
+							action: "action1"
+						}
+					},
+					expectedValue: {
+						"fe::HeaderDPLink::DataPoint::dp1": {
+							"action": "action1",
+							"semanticObject": "SO1",
+							"semanticObjectMapping": []
+						},
+						"fe::HeaderDPLink::DataPoint::dp2": {
+							"action": "action1",
+							"semanticObject": "SO1",
+							"semanticObjectMapping": []
+						},
+						"fe::MicroChartLink::Chart::chart1": {
+							"action": "action1",
+							"semanticObject": "SO1",
+							"semanticObjectMapping": []
+						}
+					},
+					message: "with target outbound configured with valid SO-action"
+				},
+				{
+					viewData: {
+						controlConfiguration: {
+							"@com.sap.vocabularies.UI.v1.DataPoint#dp1": {
+								"navigation": {
+									"targetOutbound": {
+										"outbound": "outbound1"
+									}
+								}
+							},
+							"@com.sap.vocabularies.UI.v1.DataPoint#dp2": {
+								"navigation": {
+									"targetOutbound": {
+										"outbound": "outbound1"
+									},
+									"targetSections": {
+										"sectionId": "sectionID1"
+									}
+								}
+							},
+							"@com.sap.vocabularies.UI.v1.Chart#chart1": {
+								"navigation": {
+									"targetOutbound": {
+										"outbound": "outbound1"
+									},
+									"targetSections": {
+										"sectionId": "sectionID1"
+									}
+								}
+							},
+							"@com.sap.vocabularies.UI.v1.Chart#chart2": {
+								"navigation": {
+									"targetSections": {
+										"sectionId": "sectionID1"
+									}
+								}
+							},
+							"_Partner/@com.sap.vocabularies.UI.v1.LineItem": {
+								"tableSettings": {
+									"personalization": false
 								}
 							}
+						}
+					},
+					crossNav: {
+						"outbound1": {}
+					},
+					expectedValue: {},
+					message: "with target outbound configured with no SO-action"
+				},
+				{
+					viewData: {
+						controlConfiguration: {
+							"@com.sap.vocabularies.UI.v1.DataPoint#dp1": {
+								"navigation": {
+									"targetOutbound": {
+										"outbound": "outbound1"
+									}
+								}
+							},
+							"@com.sap.vocabularies.UI.v1.Chart#chart1": {
+								"navigation": {
+									"targetOutbound": {
+										"outbound": "outbound1"
+									}
+								}
+							}
+						}
+					},
+					crossNav: {
+						"outbound1": {
+							semanticObject: "SO1",
+							action: "action1",
+							parameters: {
+								"mappedProperty1": {
+									"value": {
+										"value": "mainProperty1",
+										"format": "binding"
+									}
+								},
+								"mappedProperty2": {
+									"value": {
+										"value": "mainProperty2",
+										"format": "plain"
+									}
+								},
+								"mainProperty3": {
+									"defaultValue": {
+										"value": "UserDefault.GLAccount",
+										"format": "reference"
+									},
+									"filter": {
+										"value": "\\d+",
+										"format": "regexp"
+									}
+								}
+							}
+						}
+					},
+					expectedValue: {
+						"fe::HeaderDPLink::DataPoint::dp1": {
+							"action": "action1",
+							"semanticObject": "SO1",
+							"semanticObjectMapping": [
+								{
+									"LocalProperty": {
+										"$PropertyPath": "mainProperty1"
+									},
+									"SemanticObjectProperty": "mappedProperty1"
+								}
+							]
 						},
-						expectedValue: "EQ",
-						sMessage: "Edm.String and Single Value Or Search Expressions"
+						"fe::MicroChartLink::Chart::chart1": {
+							"action": "action1",
+							"semanticObject": "SO1",
+							"semanticObjectMapping": [
+								{
+									"LocalProperty": {
+										"$PropertyPath": "mainProperty1"
+									},
+									"SemanticObjectProperty": "mappedProperty1"
+								}
+							]
+						}
+					},
+					message: "with target outbound configured with valid SO-action and semantic mapping"
+				}
+			].forEach(function(oData) {
+				const oHeaderFacetItems = CommonUtils.getHeaderFacetItemConfigForExternalNavigation(oData.viewData, oData.crossNav);
+				expect(oHeaderFacetItems).toEqual(oData.expectedValue); // , "Unit test to check getHeaderFacetItemConfigForExternalNavigation " + oData.message + ":  ok"
+			});
+		});
+	});
+	describe("Unit Test for getSemanticObjectMapping", function() {
+		test("Unit Test for getSemanticObjectMapping", function() {
+			[
+				{
+					outbound: {
+						"outbound1": {
+							semanticObject: "SO1",
+							action: "action1"
+						}
+					},
+					expectedValue: [],
+					message: "with target outbound configured no semanticobject mapping"
+				},
+				{
+					outbound: {
+						semanticObject: "SO1",
+						action: "action1",
+						parameters: {
+							"mappedProperty1": {
+								"value": {
+									"value": "mainProperty1",
+									"format": "binding"
+								}
+							},
+							"mappedProperty2": {
+								"value": {
+									"value": "mainProperty2",
+									"format": "plain"
+								}
+							},
+							"mainProperty3": {
+								"defaultValue": {
+									"value": "UserDefault.GLAccount",
+									"format": "reference"
+								},
+								"filter": {
+									"value": "\\d+",
+									"format": "regexp"
+								}
+							},
+							"mappedProperty4": {
+								"value": {
+									"value": "mainProperty4",
+									"format": "binding"
+								}
+							}
+						}
+					},
+					expectedValue: [
+						{
+							"LocalProperty": {
+								"$PropertyPath": "mainProperty1"
+							},
+							"SemanticObjectProperty": "mappedProperty1"
+						},
+						{
+							"LocalProperty": {
+								"$PropertyPath": "mainProperty4"
+							},
+							"SemanticObjectProperty": "mappedProperty4"
+						}
+					],
+					message: "with target outbound configured with valid SO-action and semantic mapping"
+				}
+			].forEach(function(oData) {
+				const oHeaderFacetItems = CommonUtils.getSemanticObjectMapping(oData.outbound);
+				expect(oHeaderFacetItems).toEqual(oData.expectedValue); // ,"Unit test to check getSemanticObjectMapping " + oData.message + ":  ok"
+			});
+		});
+
+		describe("fnOnStrictHandlingFailed", () => {
+			test("fnOnStrictHandlingFailed for unbound action and single 412 message from backend", async function() {
+				let confirmWarning: (msg: string, options?: object) => void;
+				let confirmSelection: string = "UnboundAction";
+				jest.spyOn(MessageBox, "warning").mockImplementation((msg: string, options?: any) =>
+					confirmWarning.call(null, msg, options)
+				);
+
+				confirmWarning = (msg: string, options?: any) => {
+					expect(options.title).toEqual("Warning");
+					expect(msg).toEqual("Unable to execute the action due to a warning" + "\n" + "Proceed anyway?");
+					options.onClose(confirmSelection);
+				};
+
+				const oModel: ODataModel | any = {
+					submitBatch: jest.fn().mockReturnValue(Promise.resolve({}))
+				};
+				const aMessages = [
+					{
+						message: "Unable to execute the action due to a warning"
 					}
-				].forEach(function(oProperty) {
-					var actualValue = CommonUtils.getOperatorsForProperty(
-						oProperty.dataField,
-						"/dummy",
-						oProperty.oContext,
-						oProperty.oContext.getObject("/dummy/" + oProperty.dataField + "/$Type"),
-						true
-					);
-					expect(actualValue).toEqual(oProperty.expectedValue);
+				];
+				await CommonUtils.fnOnStrictHandlingFailed("actionImport", "UnboundAction", oModel, aMessages);
+			});
+
+			test("fnOnStrictHandlingFailed for unbound action and multiple 412 messages from backend - ignore warnings and continue", async function() {
+				let oMockprepareMessageViewForDialog = jest.spyOn(MessageHandling, "prepareMessageViewForDialog");
+				oMockprepareMessageViewForDialog.mockImplementationOnce(() => {
+					const oMessageView = new MessageView({
+						showDetailsPageHeader: false
+					});
+					return {
+						oMessageView: oMessageView,
+						bhasEtagMessage: false
+					};
+				});
+				let oDialogOpenStub = jest.spyOn(Dialog.prototype, "open");
+				oDialogOpenStub.mockImplementation(function(this: Dialog) {
+					const oActionButton = this.getBeginButton();
+					oActionButton.firePress();
 				});
+				const oModel: ODataModel | any = {
+					submitBatch: jest.fn().mockReturnValue(Promise.resolve({}))
+				};
+				const aMessages = [
+					{
+						message: "Unable to execute the action due to a warning"
+					},
+					{
+						message: "Unable to execute the action due to a warning"
+					}
+				];
+				await expect(CommonUtils.fnOnStrictHandlingFailed("actionImport", "UnboundAction", oModel, aMessages));
+				expect(oMockprepareMessageViewForDialog).toHaveBeenCalledTimes(1);
+				expect(oDialogOpenStub).toHaveBeenCalledTimes(1);
+			});
+
+			test("fnOnStrictHandlingFailed for unbound action and multiple 412 messages from backend - cancel", async function() {
+				let oMockprepareMessageViewForDialog = jest.spyOn(MessageHandling, "prepareMessageViewForDialog");
+				oMockprepareMessageViewForDialog.mockImplementationOnce(() => {
+					const oMessageView = new MessageView({
+						showDetailsPageHeader: false
+					});
+					return {
+						oMessageView: oMessageView,
+						bhasEtagMessage: false
+					};
+				});
+				let oDialogOpenStub = jest.spyOn(Dialog.prototype, "open");
+				oDialogOpenStub.mockImplementation(function(this: Dialog) {
+					const oActionButton = this.getEndButton();
+					oActionButton.firePress();
+				});
+				const oModel: ODataModel | any = {
+					submitBatch: jest.fn().mockReturnValue(Promise.resolve({}))
+				};
+				const aMessages = [
+					{
+						message: "Unable to execute the action due to a warning"
+					},
+					{
+						message: "Unable to execute the action due to a warning"
+					}
+				];
+				await expect(CommonUtils.fnOnStrictHandlingFailed("actionImport", "UnboundAction", oModel, aMessages));
+				expect(oMockprepareMessageViewForDialog).toHaveBeenCalledTimes(2);
+				expect(oDialogOpenStub).toHaveBeenCalledTimes(2);
 			});
 		});
 	});