@sap/open.fe 1.97.0 → 1.98.0

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

@@ -19,15 +19,18 @@ import {
 	or,
 	ref,
 	concat,
+	length,
 	isEmpty,
 	transformRecursively,
 	BindingExpressionExpression,
 	resolveBindingString,
 	unresolveableExpression,
-	isTruthy
+	isTruthy,
+	annotationExpression
 } from "sap/fe/core/helpers/BindingExpression";
 import { EntityType } from "@sap-ux/vocabularies-types";
 import { Context } from "sap/ui/model/odata/v4";
+import { BindingParser } from "sap/ui/base";
 
 describe("Binding Expressions Support", function() {
 	it("Constants", () => {
@@ -38,6 +41,32 @@ describe("Binding Expressions Support", function() {
 		expect(compileBinding(unresolveableExpression)).toEqual(undefined);
 	});
 
+	it("Binding Expressions", () => {
+		expect(compileBinding(bindingExpression("myPath"))).toEqual("{myPath}");
+		expect(compileBinding(bindingExpression("myPath"), true)).toEqual("%{myPath}");
+		expect(compileBinding(bindingExpression("myPath"), true, true)).toEqual("${myPath}");
+		expect(compileBinding(bindingExpression("myPath", "myModel"))).toEqual("{myModel>myPath}");
+		expect(compileBinding(bindingExpression("myPath", "myModel"), true)).toEqual("%{myModel>myPath}");
+		expect(compileBinding(bindingExpression("myPath", "myModel"), true, true)).toEqual("${myModel>myPath}");
+		// Not so great usage that we use in some place
+		const myBindingExpression: BindingExpressionExpression<any> = bindingExpression("myPath", "myModel") as BindingExpressionExpression<
+			any
+		>;
+		myBindingExpression.targetType = "boolean";
+		expect(compileBinding(myBindingExpression)).toEqual("{path: 'myModel>myPath', targetType: 'boolean'}");
+		delete myBindingExpression.targetType;
+		myBindingExpression.formatOptions = {
+			parseKeepsEmptyString: true
+		};
+		expect(compileBinding(myBindingExpression)).toEqual("{path: 'myModel>myPath', formatOptions: {parseKeepsEmptyString: true}}");
+		delete myBindingExpression.formatOptions;
+		myBindingExpression.constraints = {};
+		expect(compileBinding(myBindingExpression)).toEqual("{path: 'myModel>myPath'}");
+		myBindingExpression.constraints.scale = 1;
+		myBindingExpression.constraints.precision = 5;
+		expect(compileBinding(myBindingExpression)).toEqual("{path: 'myModel>myPath', constraints: {scale: 1, precision: 5}}");
+	});
+
 	it("Comparison", () => {
 		// "equal(ifElse(x, a, a), a) --> true"
 		expect(compileBinding(equal(ifElse(bindingExpression("isEditable"), constant("A"), constant("A")), constant("A")))).toEqual("true");
@@ -54,7 +83,7 @@ describe("Binding Expressions Support", function() {
 			compileBinding(
 				equal(ifElse(bindingExpression("isEditable"), bindingExpression("A"), bindingExpression("B")), bindingExpression("A"))
 			)
-		).toEqual("{= (%{isEditable} || %{B} === %{A})}");
+		).toEqual("{= %{isEditable} || %{B} === %{A}}");
 
 		//"equal(ifElse(x, a, b), c) --> no reduction";
 		expect(
@@ -77,13 +106,13 @@ describe("Binding Expressions Support", function() {
 		);
 
 		expect(compileBinding(equal(ifElse(bindingExpression("foo"), constant("0"), bindingExpression("B")), constant("0")))).toEqual(
-			"{= (%{foo} || %{B} === '0')}"
+			"{= %{foo} || %{B} === '0'}"
 		);
 		expect(compileBinding(equal(ifElse(bindingExpression("foo"), bindingExpression("B"), constant("1")), constant("1")))).toEqual(
-			"{= (!%{foo} || %{B} === '1')}"
+			"{= !%{foo} || %{B} === '1'}"
 		);
 		expect(compileBinding(equal(ifElse(bindingExpression("foo"), constant("1"), bindingExpression("B")), constant("1")))).toEqual(
-			"{= (%{foo} || %{B} === '1')}"
+			"{= %{foo} || %{B} === '1'}"
 		);
 
 		// "notEqual(a, a) --> false"
@@ -102,6 +131,25 @@ describe("Binding Expressions Support", function() {
 		expect(compileBinding(notEqual(ifElse(bindingExpression("foo"), constant("0"), constant("1")), bindingExpression("bar")))).toEqual(
 			"{= (%{foo} ? '0' : '1') !== %{bar}}"
 		);
+
+		const dualEquality = compileBinding(equal(equal(123, bindingExpression("foo")), equal(137, bindingExpression("bar"))));
+		const dualNEquality = compileBinding(notEqual(equal(123, bindingExpression("foo")), equal(137, bindingExpression("bar"))));
+		expect(dualEquality).toEqual("{= (123 === %{foo}) === (137 === %{bar})}");
+		expect(dualNEquality).toEqual("{= (123 === %{foo}) !== (137 === %{bar})}");
+
+		const dualEqualityExpression = BindingParser.complexParser(dualEquality);
+		// (123 === 123) === (137 === 137) -> true === true -> true
+		expect(dualEqualityExpression.formatter(123, 137)).toEqual(true);
+		// (123 === 123) === (137 === 136) -> true === false -> false
+		expect(dualEqualityExpression.formatter(123, 136)).toEqual(false);
+
+		const dualNEqualityExpression = BindingParser.complexParser(dualNEquality);
+		// (123 === 123) !== (137 === 137) -> true !== true -> false
+		expect(dualNEqualityExpression.formatter(123, 137)).toEqual(false);
+		// (123 === 123) !== (137 === 136) -> true !== false -> true
+		expect(dualNEqualityExpression.formatter(123, 136)).toEqual(true);
+		// (123 === 137) !== (137 === 137) -> false !== true -> true
+		expect(dualNEqualityExpression.formatter(137, 137)).toEqual(true);
 	});
 
 	it("Data model definition", () => {
@@ -206,15 +254,15 @@ describe("Binding Expressions Support", function() {
 		expect(compileBinding(and(constant(true), bindingExpression("SalesOrder")))).toEqual("{SalesOrder}");
 		expect(compileBinding(and(constant(false), bindingExpression("SalesOrder")))).toEqual("false");
 		expect(compileBinding(and(bindingExpression("isEditable", "ui"), bindingExpression("SalesOrder")))).toEqual(
-			"{= (%{ui>isEditable} && %{SalesOrder})}"
+			"{= %{ui>isEditable} && %{SalesOrder}}"
 		);
 
 		const a = and(bindingExpression("a1"), bindingExpression("a2"));
 		const b = and(bindingExpression("b1"), bindingExpression("b2"));
-		expect(compileBinding(and(a, b))).toEqual("{= (%{a1} && %{a2} && %{b1} && %{b2})}");
+		expect(compileBinding(and(a, b))).toEqual("{= %{a1} && %{a2} && %{b1} && %{b2}}");
 
-		expect(compileBinding(and(a, a))).toEqual("{= (%{a1} && %{a2})}");
-		expect(compileBinding(and(a, and(a, a)))).toEqual("{= (%{a1} && %{a2})}");
+		expect(compileBinding(and(a, a))).toEqual("{= %{a1} && %{a2}}");
+		expect(compileBinding(and(a, and(a, a)))).toEqual("{= %{a1} && %{a2}}");
 		expect(compileBinding(and(bindingExpression("foo"), not(bindingExpression("foo"))))).toEqual("false");
 		expect(compileBinding(and(bindingExpression("foo"), not(bindingExpression("foo")), unresolveableExpression))).toEqual(undefined);
 	});
@@ -226,12 +274,12 @@ describe("Binding Expressions Support", function() {
 		expect(compileBinding(or(constant(false), bindingExpression("SalesOrder")))).toEqual("{SalesOrder}");
 		expect(compileBinding(or(constant(true), bindingExpression("SalesOrder")))).toEqual("true");
 		expect(compileBinding(or(bindingExpression("isEditable", "ui"), bindingExpression("SalesOrder")))).toEqual(
-			"{= (%{ui>isEditable} || %{SalesOrder})}"
+			"{= %{ui>isEditable} || %{SalesOrder}}"
 		);
 
 		const a = or(bindingExpression("a1"), bindingExpression("a2"));
 		const b = or(bindingExpression("b1"), bindingExpression("b2"));
-		expect(compileBinding(or(a, b))).toEqual("{= (%{a1} || %{a2} || %{b1} || %{b2})}");
+		expect(compileBinding(or(a, b))).toEqual("{= %{a1} || %{a2} || %{b1} || %{b2}}");
 		expect(compileBinding(or(bindingExpression("foo"), not(bindingExpression("foo"))))).toEqual("true");
 		expect(compileBinding(or(bindingExpression("foo"), not(bindingExpression("foo")), unresolveableExpression))).toEqual(undefined);
 	});
@@ -247,10 +295,10 @@ describe("Binding Expressions Support", function() {
 
 	it("Not operator can simplify some expressions", () => {
 		expect(compileBinding(not(and(equal(1, bindingExpression("SalesOrder")), equal(2, bindingExpression("SalesOrder")))))).toEqual(
-			"{= (1 !== %{SalesOrder} || 2 !== %{SalesOrder})}"
+			"{= 1 !== %{SalesOrder} || 2 !== %{SalesOrder}}"
 		);
 		expect(compileBinding(not(or(equal(1, bindingExpression("SalesOrder")), equal(2, bindingExpression("SalesOrder")))))).toEqual(
-			"{= (1 !== %{SalesOrder} && 2 !== %{SalesOrder})}"
+			"{= 1 !== %{SalesOrder} && 2 !== %{SalesOrder}}"
 		);
 		expect(compileBinding(not(equal(1, bindingExpression("SalesOrder"))))).toEqual("{= 1 !== %{SalesOrder}}");
 		expect(compileBinding(not(notEqual(1, bindingExpression("SalesOrder"))))).toEqual("{= 1 === %{SalesOrder}}");
@@ -381,7 +429,7 @@ describe("Binding Expressions Support", function() {
 			"{= %{isEditable} ? true : %{BoolValue}}"
 		);
 		expect(compileBinding(ifElse(bindingExpression("isEditable"), constant(false), bindingExpression("BoolValue")))).toEqual(
-			"{= (!%{isEditable} && %{BoolValue})}"
+			"{= !%{isEditable} && %{BoolValue}}"
 		);
 		expect(compileBinding(ifElse(not(bindingExpression("condition")), constant("a"), constant("b")))).toEqual(
 			"{= %{condition} ? 'b' : 'a'}"
@@ -390,7 +438,7 @@ describe("Binding Expressions Support", function() {
 			"{= %{isEditable} ? %{BoolValue} : true}"
 		);
 		expect(compileBinding(ifElse(bindingExpression("isEditable"), bindingExpression("BoolValue"), constant(false)))).toEqual(
-			"{= (%{isEditable} && %{BoolValue})}"
+			"{= %{isEditable} && %{BoolValue}}"
 		);
 		// "Optimize nested if-else (condition)"
 		expect(compileBinding(ifElse(ifElse(bindingExpression("condition"), true, false), constant("a"), constant("b")))).toEqual(
@@ -617,19 +665,46 @@ describe("Binding Expressions Support", function() {
 
 	it("Concat Operator", () => {
 		expect(compileBinding(concat("a", "b"))).toEqual("ab");
-		expect(compileBinding(concat("a", bindingExpression("BindingPath")))).toEqual("{= 'a' + ${BindingPath} }");
+		expect(compileBinding(concat("a", bindingExpression("BindingPath")))).toEqual("{= 'a' + ${BindingPath}}");
 		expect(compileBinding(concat("a", unresolveableExpression, bindingExpression("BindingPath")))).toEqual(undefined);
 	});
 
+	it("Length", () => {
+		expect(compileBinding(length(bindingExpression("myProperty", "internal")))).toEqual("{= %{internal>myProperty}.length}");
+		expect(compileBinding(length(bindingExpression(undefined)))).toEqual(undefined);
+		expect(
+			compileBinding(equal(length(bindingExpression("myProperty", "internal")), length(bindingExpression("myProperty", "internal"))))
+		).toEqual("true");
+		expect(compileBinding(lessOrEqual(length(bindingExpression("myProperty", "internal")), 2))).toEqual(
+			"{= (%{internal>myProperty}.length) <= 2}"
+		);
+		expect(
+			compileBinding(
+				and(
+					lessOrEqual(length(bindingExpression("myProperty", "internal")), 2),
+					lessOrEqual(length(bindingExpression("myProperty", "internal")), 2)
+				)
+			)
+		).toEqual("{= (%{internal>myProperty}.length) <= 2}");
+		expect(
+			compileBinding(
+				and(
+					lessOrEqual(length(bindingExpression("myProperty", "internal")), 2),
+					notEqual(length(bindingExpression("myProperty", "internal")), 5)
+				)
+			)
+		).toEqual("{= (%{internal>myProperty}.length) <= 2 && (%{internal>myProperty}.length) !== 5}");
+	});
+
 	it("Is Empty Shortcut", () => {
 		expect(compileBinding(isEmpty(bindingExpression("BindingPath")))).toEqual(
-			"{= (%{BindingPath} === '' || %{BindingPath} === undefined || %{BindingPath} === null)}"
+			"{= %{BindingPath} === '' || %{BindingPath} === undefined || %{BindingPath} === null}"
 		);
 		expect(compileBinding(isEmpty(concat("a", bindingExpression("BindingPath"))))).toEqual(
-			"{= (%{BindingPath} === '' || %{BindingPath} === undefined || %{BindingPath} === null)}"
+			"{= %{BindingPath} === '' || %{BindingPath} === undefined || %{BindingPath} === null}"
 		);
 		expect(compileBinding(isEmpty(concat(bindingExpression("BindingPath1"), bindingExpression("BindingPath2"))))).toEqual(
-			"{= (%{BindingPath1} === '' || %{BindingPath1} === undefined || %{BindingPath1} === null || %{BindingPath2} === '' || %{BindingPath2} === undefined || %{BindingPath2} === null)}"
+			"{= %{BindingPath1} === '' || %{BindingPath1} === undefined || %{BindingPath1} === null || %{BindingPath2} === '' || %{BindingPath2} === undefined || %{BindingPath2} === null}"
 		);
 	});
 
@@ -645,17 +720,15 @@ describe("Binding Expressions Support", function() {
 			return constant("A") as Expression<any>;
 		};
 		expect(compileBinding(transformRecursively(isEmpty(bindingExpression("BindingPath")), "Binding", transformBinding))).toEqual(
-			"{= (%{BindingPath} === '' || %{BindingPath} === undefined || %{BindingPath} === null)}"
+			"{= %{BindingPath} === '' || %{BindingPath} === undefined || %{BindingPath} === null}"
 		);
 
-		expect(compileBinding(concat(bindingExpression("BindingPath"), bindingExpression("Bubu")))).toEqual(
-			"{= ${BindingPath} + ${Bubu} }"
-		);
+		expect(compileBinding(concat(bindingExpression("BindingPath"), bindingExpression("Bubu")))).toEqual("{= ${BindingPath} + ${Bubu}}");
 		expect(
 			compileBinding(
 				transformRecursively(concat(bindingExpression("BindingPath"), bindingExpression("Bubu")), "Binding", transformBinding)
 			)
-		).toEqual("{= ${newModel>BindingPath} + ${newModel>Bubu} }");
+		).toEqual("{= ${newModel>BindingPath} + ${newModel>Bubu}}");
 
 		expect(
 			compileBinding(