@sap/open.fe 1.99.0 → 1.100.0

package/packages/sap.fe.core/test/sap/fe/core/jest/templating/DataModelPathHelper.spec.ts

@@ -0,0 +1,427 @@
+import {
+	basicProperty,
+	computedProperty,
+	getEntitySetPath,
+	getEntitySetWithAnnotation,
+	immutableProperty,
+	NavigationPropertyWrapper,
+	PropertyPathExpression
+} from "../data/TemplatingTestData";
+import { isPathDeletable, isPathInsertable, isPathUpdatable } from "sap/fe/core/templating/DataModelPathHelper";
+import { bindingExpression, compileBinding, constant, equal } from "sap/fe/core/helpers/BindingExpression";
+import { singletonPathVisitor } from "sap/fe/core/converters/helpers/BindingHelper";
+
+const basicEntitySet = getEntitySetWithAnnotation();
+const nonUpdatableEntitySet = getEntitySetWithAnnotation("Capabilities.UpdateRestrictions", {
+	Updatable: false
+});
+const updatableEntitySet = getEntitySetWithAnnotation("Capabilities.UpdateRestrictions", {
+	Updatable: true
+});
+const upsertableEntitySet = getEntitySetWithAnnotation("Capabilities.UpdateRestrictions", {
+	Upsertable: true
+});
+const updatablePathEntitySet = getEntitySetWithAnnotation("Capabilities.UpdateRestrictions", {
+	Updatable: new PropertyPathExpression(basicProperty)
+});
+const singletonUpdatablePathEntitySet = getEntitySetWithAnnotation("Capabilities.UpdateRestrictions", {
+	Updatable: new PropertyPathExpression({
+		_type: "Property",
+		annotations: {},
+		fullyQualifiedName: "/com.c_salesordermanage_sd.EntityContainer/SingletonOne/HiddenUpdate",
+		isKey: true,
+		type: "path",
+		name: "/com.c_salesordermanage_sd.EntityContainer/SingletonOne/HiddenUpdate"
+	})
+});
+const singletonDeletablePathEntitySet = getEntitySetWithAnnotation("Capabilities.DeleteRestrictions", {
+	Deletable: new PropertyPathExpression({
+		_type: "Property",
+		annotations: {},
+		fullyQualifiedName: "/com.c_salesordermanage_sd.EntityContainer/SingletonOne/HiddenDelete",
+		isKey: true,
+		type: "path",
+		name: "/com.c_salesordermanage_sd.EntityContainer/SingletonOne/HiddenDelete"
+	})
+});
+const singletonInsertablePathEntitySet = getEntitySetWithAnnotation("Capabilities.InsertRestrictions", {
+	Insertable: new PropertyPathExpression({
+		_type: "Property",
+		annotations: {},
+		fullyQualifiedName: "/com.c_salesordermanage_sd.EntityContainer/SingletonOne/HiddenCreate",
+		isKey: true,
+		type: "path",
+		name: "/com.c_salesordermanage_sd.EntityContainer/SingletonOne/HiddenCreate"
+	})
+});
+
+test("isPathUpdatable - basic path tests with singleton path", function() {
+	const convertedTypes: any = {
+		singletons: [{ fullyQualifiedName: "com.c_salesordermanage_sd.EntityContainer/SingletonOne", name: "SingletonOne" }]
+	};
+	const singletonUpdatableEntitySetPath = getEntitySetPath(singletonUpdatablePathEntitySet);
+	expect(
+		isPathUpdatable(singletonUpdatableEntitySetPath, {
+			propertyPath: "_Item",
+			pathVisitor: (path: string, navigationPaths: string[]) => singletonPathVisitor(path, convertedTypes, navigationPaths)
+		})
+	).toEqual(equal(bindingExpression("/SingletonOne/HiddenUpdate", undefined), true));
+});
+
+test("isPathDeletable - basic path tests with singleton path", function() {
+	const convertedTypes: any = {
+		singletons: [{ fullyQualifiedName: "com.c_salesordermanage_sd.EntityContainer/SingletonOne", name: "SingletonOne" }]
+	};
+	const singletonDeletableEntitySetPath = getEntitySetPath(singletonDeletablePathEntitySet);
+	expect(
+		isPathDeletable(singletonDeletableEntitySetPath, {
+			propertyPath: "_Item",
+			pathVisitor: (path: string, navigationPaths: string[]) => singletonPathVisitor(path, convertedTypes, navigationPaths)
+		})
+	).toEqual(equal(bindingExpression("/SingletonOne/HiddenDelete", undefined), true));
+});
+
+test("isPathInsertable - basic path tests with singleton path", function() {
+	const convertedTypes: any = {
+		singletons: [{ fullyQualifiedName: "com.c_salesordermanage_sd.EntityContainer/SingletonOne", name: "SingletonOne" }]
+	};
+	const singletonInsertableEntitySetPath = getEntitySetPath(singletonInsertablePathEntitySet);
+	expect(
+		isPathInsertable(singletonInsertableEntitySetPath, {
+			propertyPath: "_Item",
+			pathVisitor: (path: string, navigationPaths: string[]) => singletonPathVisitor(path, convertedTypes, navigationPaths)
+		})
+	).toEqual(equal(bindingExpression("/SingletonOne/HiddenCreate", undefined), true));
+});
+
+test("isPathUpdatable - basic path tests", function() {
+	const basicEntitySetPath = getEntitySetPath(basicEntitySet);
+	expect(isPathUpdatable(basicEntitySetPath)).toEqual(constant(true));
+
+	const nonUpdatableEntitySetPath = getEntitySetPath(nonUpdatableEntitySet);
+	expect(isPathUpdatable(nonUpdatableEntitySetPath)).toEqual(constant(false));
+
+	const updatableEntitySetPath = getEntitySetPath(updatableEntitySet);
+	expect(isPathUpdatable(updatableEntitySetPath)).toEqual(constant(true));
+
+	const upsertableEntitySetPath = getEntitySetPath(upsertableEntitySet);
+	expect(isPathUpdatable(upsertableEntitySetPath)).toEqual(constant(true));
+
+	const updatablePathEntitySetPath = getEntitySetPath(updatablePathEntitySet);
+	expect(isPathUpdatable(updatablePathEntitySetPath)).toEqual(equal(bindingExpression("BasicProperty", undefined), true));
+});
+
+test("isPathUpdatable - basic path tests with additional path", function() {
+	const basicEntitySetPath = getEntitySetPath(basicEntitySet);
+	expect(isPathUpdatable(basicEntitySetPath, { propertyPath: "_Item" })).toEqual(constant(true));
+
+	const nonUpdatableEntitySetPath = getEntitySetPath(nonUpdatableEntitySet);
+	expect(isPathUpdatable(nonUpdatableEntitySetPath, { propertyPath: "_Item" })).toEqual(constant(false));
+
+	const updatableEntitySetPath = getEntitySetPath(updatableEntitySet);
+	expect(isPathUpdatable(updatableEntitySetPath, { propertyPath: "_Item" })).toEqual(constant(true));
+
+	const upsertableEntitySetPath = getEntitySetPath(upsertableEntitySet);
+	expect(isPathUpdatable(upsertableEntitySetPath, { propertyPath: "_Item" })).toEqual(constant(true));
+
+	const updatablePathEntitySetPath = getEntitySetPath(updatablePathEntitySet);
+	expect(isPathUpdatable(updatablePathEntitySetPath, { propertyPath: "_Item" })).toEqual(
+		equal(bindingExpression("BasicProperty", undefined), true)
+	);
+});
+
+test("isPathUpdatable - navigation properties, no condition on root", function() {
+	const navPropTargetEntitySet = getEntitySetWithAnnotation();
+
+	const basicNavProp = new NavigationPropertyWrapper("BasicNavProp", navPropTargetEntitySet.entityType).value();
+	basicEntitySet.navigationPropertyBinding["BasicNavProp"] = navPropTargetEntitySet;
+	const basicEntitySetPath = getEntitySetPath(basicEntitySet, [basicNavProp]);
+
+	expect(isPathUpdatable(basicEntitySetPath)).toEqual(constant(true));
+
+	const restrictedEntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "RestrictedNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: false
+				}
+			}
+		]
+	});
+	const restrictedNavProp = new NavigationPropertyWrapper("RestrictedNavProp", navPropTargetEntitySet.entityType).value();
+	restrictedEntitySet.navigationPropertyBinding["RestrictedNavProp"] = navPropTargetEntitySet;
+	const restrictedNavPropPath = getEntitySetPath(restrictedEntitySet, [restrictedNavProp]);
+	expect(isPathUpdatable(restrictedNavPropPath)).toEqual(constant(false));
+
+	const nonRestrictedEntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "RestrictedNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: true
+				}
+			}
+		]
+	});
+	nonRestrictedEntitySet.navigationPropertyBinding["RestrictedNavProp"] = navPropTargetEntitySet;
+	const nonRestrictedNavPropPath = getEntitySetPath(nonRestrictedEntitySet, [restrictedNavProp]);
+	expect(isPathUpdatable(nonRestrictedNavPropPath)).toEqual(constant(true));
+
+	const pathRestrictedEntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "RestrictedNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: new PropertyPathExpression(immutableProperty)
+				}
+			}
+		]
+	});
+	pathRestrictedEntitySet.navigationPropertyBinding["RestrictedNavProp"] = navPropTargetEntitySet;
+	const pathRestrictedEntityPath = getEntitySetPath(pathRestrictedEntitySet, [restrictedNavProp]);
+	expect(isPathUpdatable(pathRestrictedEntityPath)).toEqual(equal(bindingExpression("ImmutableProperty", undefined), constant(true)));
+});
+
+test("isPathUpdatable - navigation properties, non updatable target", function() {
+	const navPropTargetEntitySet = getEntitySetWithAnnotation("Capabilities.UpdateRestrictions", { Updatable: false });
+
+	const basicNavProp = new NavigationPropertyWrapper("BasicNavProp", navPropTargetEntitySet.entityType).value();
+	basicEntitySet.navigationPropertyBinding["BasicNavProp"] = navPropTargetEntitySet;
+	const basicEntitySetPath = getEntitySetPath(basicEntitySet, [basicNavProp]);
+
+	expect(isPathUpdatable(basicEntitySetPath)).toEqual(constant(false));
+
+	const restrictedEntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "RestrictedNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: false
+				}
+			}
+		]
+	});
+	const restrictedNavProp = new NavigationPropertyWrapper("RestrictedNavProp", navPropTargetEntitySet.entityType).value();
+	restrictedEntitySet.navigationPropertyBinding["RestrictedNavProp"] = navPropTargetEntitySet;
+	const restrictedNavPropPath = getEntitySetPath(restrictedEntitySet, [restrictedNavProp]);
+	expect(isPathUpdatable(restrictedNavPropPath)).toEqual(constant(false));
+
+	const nonRestrictedEntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "RestrictedNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: true
+				}
+			}
+		]
+	});
+	nonRestrictedEntitySet.navigationPropertyBinding["RestrictedNavProp"] = navPropTargetEntitySet;
+	const nonRestrictedNavPropPath = getEntitySetPath(nonRestrictedEntitySet, [restrictedNavProp]);
+	expect(isPathUpdatable(nonRestrictedNavPropPath)).toEqual(constant(true));
+
+	const restrictedPathEntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "RestrictedNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: new PropertyPathExpression(immutableProperty)
+				}
+			}
+		]
+	});
+	restrictedPathEntitySet.navigationPropertyBinding["RestrictedNavProp"] = navPropTargetEntitySet;
+	const restrictedPathEntitySetPath = getEntitySetPath(restrictedPathEntitySet, [restrictedNavProp]);
+	expect(isPathUpdatable(restrictedPathEntitySetPath)).toEqual(
+		equal(bindingExpression(immutableProperty.name, undefined), constant(true))
+	);
+});
+
+test("isPathUpdatable - navigation properties, path updatable target", function() {
+	const navPropTargetEntitySet = getEntitySetWithAnnotation("Capabilities.UpdateRestrictions", {
+		Updatable: new PropertyPathExpression(immutableProperty)
+	});
+
+	const basicNavProp = new NavigationPropertyWrapper("BasicNavProp", navPropTargetEntitySet.entityType).value();
+	basicEntitySet.navigationPropertyBinding["BasicNavProp"] = navPropTargetEntitySet;
+	const basicEntitySetPath = getEntitySetPath(basicEntitySet, [basicNavProp]);
+
+	const isPathUpdatable1 = isPathUpdatable(basicEntitySetPath);
+	expect(isPathUpdatable1).toEqual(equal(bindingExpression("BasicNavProp/" + immutableProperty.name, undefined), constant(true)));
+	expect(compileBinding(isPathUpdatable1)).toEqual("{= %{BasicNavProp/ImmutableProperty} === true}");
+
+	const restrictedEntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "RestrictedNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: false
+				}
+			}
+		]
+	});
+	const restrictedNavProp = new NavigationPropertyWrapper("RestrictedNavProp", navPropTargetEntitySet.entityType).value();
+	restrictedEntitySet.navigationPropertyBinding["RestrictedNavProp"] = navPropTargetEntitySet;
+	const restrictedNavPropPath = getEntitySetPath(restrictedEntitySet, [restrictedNavProp]);
+	expect(isPathUpdatable(restrictedNavPropPath)).toEqual(constant(false));
+
+	const nonRestrictedEntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "RestrictedNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: true
+				}
+			}
+		]
+	});
+	nonRestrictedEntitySet.navigationPropertyBinding["RestrictedNavProp"] = navPropTargetEntitySet;
+	const nonRestrictedNavPropPath = getEntitySetPath(nonRestrictedEntitySet, [restrictedNavProp]);
+	expect(isPathUpdatable(nonRestrictedNavPropPath)).toEqual(constant(true));
+
+	const restrictedPathEntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "RestrictedNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: new PropertyPathExpression(computedProperty)
+				}
+			}
+		]
+	});
+	restrictedPathEntitySet.navigationPropertyBinding["RestrictedNavProp"] = navPropTargetEntitySet;
+	const restrictedPathEntitySetPath = getEntitySetPath(restrictedPathEntitySet, [restrictedNavProp]);
+	expect(isPathUpdatable(restrictedPathEntitySetPath)).toEqual(
+		equal(bindingExpression(computedProperty.name, undefined), constant(true))
+	);
+});
+
+test('isPathUpdatable - navigation properties, multiple level"', function() {
+	const navProp1TargetEntitySet = getEntitySetWithAnnotation();
+	const navProp2TargetEntitySet = getEntitySetWithAnnotation();
+
+	const navProp1 = new NavigationPropertyWrapper("BasicNavProp", navProp1TargetEntitySet.entityType).value();
+	const navProp2 = new NavigationPropertyWrapper("SecondNavProp", navProp2TargetEntitySet.entityType).value();
+	const navProp3 = new NavigationPropertyWrapper("ThirdNavProp", updatablePathEntitySet.entityType).value();
+	const basicEntitySet = getEntitySetWithAnnotation();
+	const basicEntitySetPath = getEntitySetPath(basicEntitySet, [navProp1, navProp2]);
+
+	// By default it's updatable
+	expect(isPathUpdatable(basicEntitySetPath)).toEqual(constant(true));
+
+	const restrictedPath2EntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "SecondNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: false
+				}
+			}
+		]
+	});
+	const restrictedPath2 = getEntitySetPath(restrictedPath2EntitySet, [navProp1, navProp2]);
+	expect(isPathUpdatable(restrictedPath2)).toEqual(constant(true));
+
+	const restrictedPath1EntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "BasicNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: false
+				}
+			}
+		]
+	});
+	// No restrictions on second part
+	const restrictedPath1 = getEntitySetPath(restrictedPath1EntitySet, [navProp1, navProp2]);
+	expect(isPathUpdatable(restrictedPath1)).toEqual(constant(true));
+
+	const restrictedPath12EntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "BasicNavProp/SecondNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: false
+				}
+			}
+		]
+	});
+	navProp1.containsTarget = true;
+	navProp2.containsTarget = true;
+	const restrictedPath12 = getEntitySetPath(restrictedPath12EntitySet, [navProp1, navProp2]);
+	expect(isPathUpdatable(restrictedPath12)).toEqual(constant(false));
+	navProp1.containsTarget = false;
+	navProp2.containsTarget = false;
+
+	const restrictedPath123EntitySet = getEntitySetWithAnnotation("Capabilities.NavigationRestrictions", {
+		RestrictedProperties: [
+			{
+				NavigationProperty: {
+					type: "NavigationPropertyPath",
+					value: "ThirdNavProp"
+				},
+				UpdateRestrictions: {
+					Updatable: false
+				}
+			}
+		]
+	});
+
+	const restrictedPath123 = getEntitySetPath(restrictedPath123EntitySet, [navProp1, navProp2, navProp3]);
+	expect(isPathUpdatable(restrictedPath123)).toEqual(constant(true));
+
+	restrictedPath123EntitySet.navigationPropertyBinding["BasicNavProp"] = navProp1TargetEntitySet;
+	expect(isPathUpdatable(restrictedPath123)).toEqual(constant(true));
+	restrictedPath123EntitySet.navigationPropertyBinding["BasicNavProp"] = nonUpdatableEntitySet;
+	expect(isPathUpdatable(restrictedPath123)).toEqual(constant(false));
+	// restrictedPath123EntitySet.navigationPropertyBinding["BasicNavProp"] = updatablePathEntitySet;
+	// expect(isPathUpdatable(restrictedPath123), constant(true));
+
+	restrictedPath123EntitySet.navigationPropertyBinding["BasicNavProp"] = navProp1TargetEntitySet;
+	navProp1TargetEntitySet.navigationPropertyBinding["SecondNavProp"] = navProp2TargetEntitySet;
+	expect(isPathUpdatable(restrictedPath123)).toEqual(constant(true));
+
+	restrictedPath123EntitySet.navigationPropertyBinding["BasicNavProp"] = navProp1TargetEntitySet;
+	navProp1TargetEntitySet.navigationPropertyBinding["SecondNavProp"] = navProp2TargetEntitySet;
+	navProp2TargetEntitySet.navigationPropertyBinding["ThirdNavProp"] = updatablePathEntitySet;
+	expect(isPathUpdatable(restrictedPath123)).toEqual(
+		equal(bindingExpression("BasicNavProp/SecondNavProp/ThirdNavProp/BasicProperty", undefined), true)
+	);
+});

package/packages/sap.fe.core/test/sap/fe/core/jest/templating/PropertyHelper.spec.js

@@ -2,12 +2,50 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2021 SAP SE. All rights reserved
  */
-sap.ui.define(["path", "sap/fe/core/converters/MetaModelConverter", "sap/fe/test/JestTemplatingHelper", "sap/fe/core/templating/FieldControlHelper", "sap/fe/core/helpers/BindingExpression"], function (path, MetaModelConverter, JestTemplatingHelper, FieldControlHelper, BindingExpression) {
+sap.ui.define(["path", "sap/fe/core/converters/MetaModelConverter", "sap/fe/test/JestTemplatingHelper", "sap/fe/core/templating/FieldControlHelper", "sap/fe/core/helpers/BindingExpression", "sap/fe/core/templating/PropertyHelper", "../data/TemplatingTestData"], function (path, MetaModelConverter, JestTemplatingHelper, FieldControlHelper, BindingExpression, PropertyHelper, TemplatingTestData) {
   "use strict";
 
+  var valueListWithFixedValuesProperty = TemplatingTestData.valueListWithFixedValuesProperty;
+  var valueListReferenceProperty = TemplatingTestData.valueListReferenceProperty;
+  var valueListProperty = TemplatingTestData.valueListProperty;
+  var valueListMappingProperty = TemplatingTestData.valueListMappingProperty;
+  var valueListForValidationProperty = TemplatingTestData.valueListForValidationProperty;
+  var staticReadOnlyFieldGroupProperty = TemplatingTestData.staticReadOnlyFieldGroupProperty;
+  var staticInorrectFieldGroupProperty = TemplatingTestData.staticInorrectFieldGroupProperty;
+  var staticDisabledFieldGroupProperty = TemplatingTestData.staticDisabledFieldGroupProperty;
+  var propertyWithSemanticObjectAndValueHelp = TemplatingTestData.propertyWithSemanticObjectAndValueHelp;
+  var propertyWithSemanticObject = TemplatingTestData.propertyWithSemanticObject;
+  var nonImmutableProperty = TemplatingTestData.nonImmutableProperty;
+  var nonImmutableKeyProperty = TemplatingTestData.nonImmutableKeyProperty;
+  var nonComputedProperty = TemplatingTestData.nonComputedProperty;
+  var nonComputedKeyProperty = TemplatingTestData.nonComputedKeyProperty;
+  var keyProperty = TemplatingTestData.keyProperty;
+  var immutableProperty = TemplatingTestData.immutableProperty;
+  var immutableKeyProperty = TemplatingTestData.immutableKeyProperty;
+  var dynamicFieldGroupProperty = TemplatingTestData.dynamicFieldGroupProperty;
+  var computedProperty = TemplatingTestData.computedProperty;
+  var computedKeyProperty = TemplatingTestData.computedKeyProperty;
+  var basicPropertyWithTextSeparateArrangement = TemplatingTestData.basicPropertyWithTextSeparateArrangement;
+  var basicPropertyWithText = TemplatingTestData.basicPropertyWithText;
+  var basicPropertyWithoutTextAndTextOnlyArrangement = TemplatingTestData.basicPropertyWithoutTextAndTextOnlyArrangement;
+  var basicPropertywithAnnotationPath = TemplatingTestData.basicPropertywithAnnotationPath;
+  var basicProperty = TemplatingTestData.basicProperty;
+  var isProperty = PropertyHelper.isProperty;
+  var isKey = PropertyHelper.isKey;
+  var isImmutable = PropertyHelper.isImmutable;
+  var isComputed = PropertyHelper.isComputed;
+  var isAnnotationPathExpression = PropertyHelper.isAnnotationPathExpression;
+  var hasValueListForValidation = PropertyHelper.hasValueListForValidation;
+  var hasValueHelp = PropertyHelper.hasValueHelp;
+  var hasSemanticObject = PropertyHelper.hasSemanticObject;
+  var or = BindingExpression.or;
+  var equal = BindingExpression.equal;
+  var constant = BindingExpression.constant;
   var compileBinding = BindingExpression.compileBinding;
+  var bindingExpression = BindingExpression.bindingExpression;
   var isRequiredExpression = FieldControlHelper.isRequiredExpression;
   var isReadOnlyExpression = FieldControlHelper.isReadOnlyExpression;
+  var isNonEditableExpression = FieldControlHelper.isNonEditableExpression;
   var isDisabledExpression = FieldControlHelper.isDisabledExpression;
   var getMetaModel = JestTemplatingHelper.getMetaModel;
   var compileCDS = JestTemplatingHelper.compileCDS;
@@ -58,5 +96,97 @@ sap.ui.define(["path", "sap/fe/core/converters/MetaModelConverter", "sap/fe/test
       expect(compileBinding(isRequiredExpression(properties["FieldControlDynamic"]))).toEqual("{= %{FieldControlValue} === 7 || %{FieldControlValue} === '7'}");
     });
   });
+  test("isProperty", function () {
+    expect(isProperty(basicProperty)).toEqual(true);
+    expect(isProperty(keyProperty)).toEqual(true);
+    expect(isProperty(computedProperty)).toEqual(true);
+    expect(isProperty(computedKeyProperty)).toEqual(true);
+    expect(isProperty(nonComputedProperty)).toEqual(true);
+    expect(isProperty(nonComputedKeyProperty)).toEqual(true);
+    expect(isProperty(immutableProperty)).toEqual(true);
+    expect(isProperty(immutableKeyProperty)).toEqual(true);
+    expect(isProperty(nonImmutableProperty)).toEqual(true);
+    expect(isProperty(nonImmutableKeyProperty)).toEqual(true);
+    expect(isProperty(basicPropertyWithText)).toEqual(true);
+    expect(isProperty(basicPropertyWithoutTextAndTextOnlyArrangement)).toEqual(true);
+    expect(isProperty(basicPropertyWithTextSeparateArrangement)).toEqual(true);
+    expect(isProperty(valueListProperty)).toEqual(true);
+    expect(isProperty(dynamicFieldGroupProperty)).toEqual(true);
+    expect(isProperty(propertyWithSemanticObjectAndValueHelp)).toEqual(true);
+  });
+  test("isComputed", function () {
+    expect(isComputed(basicProperty)).toEqual(false);
+    expect(isComputed(keyProperty)).toEqual(false);
+    expect(isComputed(computedProperty)).toEqual(true);
+    expect(isComputed(computedKeyProperty)).toEqual(true);
+    expect(isComputed(nonComputedProperty)).toEqual(false);
+    expect(isComputed(nonComputedKeyProperty)).toEqual(false);
+    expect(isComputed(immutableProperty)).toEqual(false);
+    expect(isComputed(immutableKeyProperty)).toEqual(false);
+    expect(isComputed(nonImmutableProperty)).toEqual(false);
+    expect(isComputed(nonImmutableKeyProperty)).toEqual(false);
+  });
+  test("isImmutable", function () {
+    expect(isImmutable(basicProperty)).toEqual(false);
+    expect(isImmutable(keyProperty)).toEqual(false);
+    expect(isImmutable(computedProperty)).toEqual(false);
+    expect(isImmutable(computedKeyProperty)).toEqual(false);
+    expect(isImmutable(nonComputedProperty)).toEqual(false);
+    expect(isImmutable(nonComputedKeyProperty)).toEqual(false);
+    expect(isImmutable(immutableProperty)).toEqual(true);
+    expect(isImmutable(immutableKeyProperty)).toEqual(true);
+    expect(isImmutable(nonImmutableProperty)).toEqual(false);
+    expect(isImmutable(nonImmutableKeyProperty)).toEqual(false);
+  });
+  test("isKey", function () {
+    expect(isKey(basicProperty)).toEqual(false);
+    expect(isKey(keyProperty)).toEqual(true);
+    expect(isKey(computedProperty)).toEqual(false);
+    expect(isKey(computedKeyProperty)).toEqual(true);
+    expect(isKey(nonComputedProperty)).toEqual(false);
+    expect(isKey(nonComputedKeyProperty)).toEqual(true);
+    expect(isKey(immutableProperty)).toEqual(false);
+    expect(isKey(immutableKeyProperty)).toEqual(true);
+    expect(isKey(nonImmutableProperty)).toEqual(false);
+    expect(isKey(nonImmutableKeyProperty)).toEqual(true);
+  });
+  test("hasSemanticObject", function () {
+    expect(hasSemanticObject(propertyWithSemanticObject)).toEqual(true);
+    expect(hasSemanticObject(basicProperty)).toEqual(false);
+  });
+  test("isReadOnly", function () {
+    expect(isReadOnlyExpression(basicProperty)).toEqual(false);
+    expect(isReadOnlyExpression(staticDisabledFieldGroupProperty)).toEqual(false);
+    expect(isReadOnlyExpression(staticInorrectFieldGroupProperty)).toEqual(false);
+    expect(isReadOnlyExpression(staticReadOnlyFieldGroupProperty)).toEqual(true);
+    expect(isReadOnlyExpression(dynamicFieldGroupProperty)).toEqual(or(equal(bindingExpression("BasicProperty"), 1), equal(bindingExpression("BasicProperty"), "1")));
+  });
+  test("isDisabled", function () {
+    expect(isDisabledExpression(basicProperty)).toEqual(false);
+    expect(isDisabledExpression(staticDisabledFieldGroupProperty)).toEqual(true);
+    expect(isDisabledExpression(staticInorrectFieldGroupProperty)).toEqual(false);
+    expect(isDisabledExpression(staticReadOnlyFieldGroupProperty)).toEqual(false);
+    expect(isDisabledExpression(dynamicFieldGroupProperty)).toEqual(or(equal(bindingExpression("BasicProperty"), 0), equal(bindingExpression("BasicProperty"), "0")));
+  });
+  test("isNonEditable", function () {
+    expect(isNonEditableExpression(basicProperty)).toEqual(constant(false));
+    expect(isNonEditableExpression(staticDisabledFieldGroupProperty)).toEqual(constant(true));
+    expect(isNonEditableExpression(staticInorrectFieldGroupProperty)).toEqual(constant(false));
+    expect(isNonEditableExpression(staticReadOnlyFieldGroupProperty)).toEqual(constant(true));
+    expect(isNonEditableExpression(dynamicFieldGroupProperty)).toEqual(or(or(equal(bindingExpression("BasicProperty"), 1), equal(bindingExpression("BasicProperty"), "1")), or(equal(bindingExpression("BasicProperty"), 0), equal(bindingExpression("BasicProperty"), "0"))));
+  });
+  test("hasValueHelp", function () {
+    expect(hasValueHelp(basicProperty)).toEqual(false);
+    expect(hasValueHelp(valueListProperty)).toEqual(true);
+    expect(hasValueHelp(valueListMappingProperty)).toEqual(true);
+    expect(hasValueHelp(valueListReferenceProperty)).toEqual(true);
+    expect(hasValueHelp(valueListWithFixedValuesProperty)).toEqual(true);
+  });
+  test("hasValueListForValidation", function () {
+    expect(hasValueListForValidation(valueListForValidationProperty)).toEqual(true);
+  });
+  test("isAnnotationPathExpression", function () {
+    expect(isAnnotationPathExpression(basicPropertywithAnnotationPath)).toEqual(true);
+  });
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["PropertyHelper.spec.ts"],"names":["convertedTypes","entityType","properties","beforeAll","sMetadataUrl","compileCDS","path","join","__dirname","getMetaModel","metaModel","convertTypes","maybeEntityType","entityTypes","find","et","name","entityProperties","forEach","prop","Error","describe","it","expect","isReadOnlyExpression","toEqual","compileBinding","isDisabledExpression","isRequiredExpression","test","isProperty","basicProperty","keyProperty","computedProperty","computedKeyProperty","nonComputedProperty","nonComputedKeyProperty","immutableProperty","immutableKeyProperty","nonImmutableProperty","nonImmutableKeyProperty","basicPropertyWithText","basicPropertyWithoutTextAndTextOnlyArrangement","basicPropertyWithTextSeparateArrangement","valueListProperty","dynamicFieldGroupProperty","propertyWithSemanticObjectAndValueHelp","isComputed","isImmutable","isKey","hasSemanticObject","propertyWithSemanticObject","staticDisabledFieldGroupProperty","staticInorrectFieldGroupProperty","staticReadOnlyFieldGroupProperty","or","equal","bindingExpression","isNonEditableExpression","constant","hasValueHelp","valueListMappingProperty","valueListReferenceProperty","valueListWithFixedValuesProperty","hasValueListForValidation","valueListForValidationProperty","isAnnotationPathExpression","basicPropertywithAnnotationPath"],"mappings":"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","sourceRoot":".","sourcesContent":["import path from \"path\";\nimport { convertTypes } from \"sap/fe/core/converters/MetaModelConverter\";\nimport { compileCDS, getMetaModel } from \"sap/fe/test/JestTemplatingHelper\";\nimport { EntityType, Property } from \"@sap-ux/annotation-converter\";\nimport {\n\tisDisabledExpression,\n\tisNonEditableExpression,\n\tisReadOnlyExpression,\n\tisRequiredExpression\n} from \"sap/fe/core/templating/FieldControlHelper\";\nimport { bindingExpression, compileBinding, constant, equal, or } from \"sap/fe/core/helpers/BindingExpression\";\nimport {\n\thasSemanticObject,\n\thasValueHelp,\n\thasValueListForValidation,\n\tisAnnotationPathExpression,\n\tisComputed,\n\tisImmutable,\n\tisKey,\n\tisProperty\n} from \"sap/fe/core/templating/PropertyHelper\";\nimport {\n\tbasicProperty,\n\tbasicPropertywithAnnotationPath,\n\tbasicPropertyWithoutTextAndTextOnlyArrangement,\n\tbasicPropertyWithText,\n\tbasicPropertyWithTextSeparateArrangement,\n\tcomputedKeyProperty,\n\tcomputedProperty,\n\tdynamicFieldGroupProperty,\n\timmutableKeyProperty,\n\timmutableProperty,\n\tkeyProperty,\n\tnonComputedKeyProperty,\n\tnonComputedProperty,\n\tnonImmutableKeyProperty,\n\tnonImmutableProperty,\n\tpropertyWithSemanticObject,\n\tpropertyWithSemanticObjectAndValueHelp,\n\tstaticDisabledFieldGroupProperty,\n\tstaticInorrectFieldGroupProperty,\n\tstaticReadOnlyFieldGroupProperty,\n\tvalueListForValidationProperty,\n\tvalueListMappingProperty,\n\tvalueListProperty,\n\tvalueListReferenceProperty,\n\tvalueListWithFixedValuesProperty\n} from \"../data/TemplatingTestData\";\n\nlet convertedTypes;\nlet entityType: EntityType;\nconst properties: Record<string, Property> = {};\nbeforeAll(async function() {\n\tconst sMetadataUrl = compileCDS(path.join(__dirname, \"../data/PropertyHelper.cds\"));\n\tconst metaModel = await getMetaModel(sMetadataUrl);\n\tconvertedTypes = convertTypes(metaModel);\n\tconst maybeEntityType = convertedTypes.entityTypes.find(et => et.name === \"TestEntity\");\n\tif (maybeEntityType) {\n\t\tentityType = maybeEntityType;\n\t\tentityType.entityProperties.forEach(prop => {\n\t\t\tproperties[prop.name] = prop;\n\t\t});\n\t} else {\n\t\tthrow new Error(\"Error in test setup\");\n\t}\n});\n\ndescribe(\"PropertyHelper\", function() {\n\tit(\"#isReadOnlyExpression\", () => {\n\t\texpect(isReadOnlyExpression(properties[\"FieldControlReadOnly\"])).toEqual(true);\n\t\texpect(isReadOnlyExpression(properties[\"FieldControlInapplicable\"])).toEqual(false);\n\t\texpect(isReadOnlyExpression(properties[\"FieldControlRequired\"])).toEqual(false);\n\t\texpect(compileBinding(isReadOnlyExpression(properties[\"FieldControlDynamic\"]))).toEqual(\n\t\t\t\"{= %{FieldControlValue} === 1 || %{FieldControlValue} === '1'}\"\n\t\t);\n\t});\n\tit(\"#isDisabledExpression\", () => {\n\t\texpect(isDisabledExpression(properties[\"FieldControlReadOnly\"])).toEqual(false);\n\t\texpect(isDisabledExpression(properties[\"FieldControlInapplicable\"])).toEqual(true);\n\t\texpect(isDisabledExpression(properties[\"FieldControlRequired\"])).toEqual(false);\n\t\texpect(compileBinding(isDisabledExpression(properties[\"FieldControlDynamic\"]))).toEqual(\n\t\t\t\"{= %{FieldControlValue} === 0 || %{FieldControlValue} === '0'}\"\n\t\t);\n\t});\n\tit(\"#isRequiredExpression\", () => {\n\t\texpect(isRequiredExpression(properties[\"FieldControlReadOnly\"])).toEqual(false);\n\t\texpect(isRequiredExpression(properties[\"FieldControlInapplicable\"])).toEqual(false);\n\t\texpect(isRequiredExpression(properties[\"FieldControlRequired\"])).toEqual(true);\n\t\texpect(compileBinding(isRequiredExpression(properties[\"FieldControlDynamic\"]))).toEqual(\n\t\t\t\"{= %{FieldControlValue} === 7 || %{FieldControlValue} === '7'}\"\n\t\t);\n\t});\n});\n\ntest(\"isProperty\", function() {\n\texpect(isProperty(basicProperty)).toEqual(true);\n\texpect(isProperty(keyProperty)).toEqual(true);\n\texpect(isProperty(computedProperty)).toEqual(true);\n\texpect(isProperty(computedKeyProperty)).toEqual(true);\n\texpect(isProperty(nonComputedProperty)).toEqual(true);\n\texpect(isProperty(nonComputedKeyProperty)).toEqual(true);\n\texpect(isProperty(immutableProperty)).toEqual(true);\n\texpect(isProperty(immutableKeyProperty)).toEqual(true);\n\texpect(isProperty(nonImmutableProperty)).toEqual(true);\n\texpect(isProperty(nonImmutableKeyProperty)).toEqual(true);\n\texpect(isProperty(basicPropertyWithText)).toEqual(true);\n\texpect(isProperty(basicPropertyWithoutTextAndTextOnlyArrangement)).toEqual(true);\n\texpect(isProperty(basicPropertyWithTextSeparateArrangement)).toEqual(true);\n\texpect(isProperty(valueListProperty)).toEqual(true);\n\texpect(isProperty(dynamicFieldGroupProperty)).toEqual(true);\n\texpect(isProperty(propertyWithSemanticObjectAndValueHelp)).toEqual(true);\n});\n\ntest(\"isComputed\", function() {\n\texpect(isComputed(basicProperty)).toEqual(false);\n\texpect(isComputed(keyProperty)).toEqual(false);\n\texpect(isComputed(computedProperty)).toEqual(true);\n\texpect(isComputed(computedKeyProperty)).toEqual(true);\n\texpect(isComputed(nonComputedProperty)).toEqual(false);\n\texpect(isComputed(nonComputedKeyProperty)).toEqual(false);\n\texpect(isComputed(immutableProperty)).toEqual(false);\n\texpect(isComputed(immutableKeyProperty)).toEqual(false);\n\texpect(isComputed(nonImmutableProperty)).toEqual(false);\n\texpect(isComputed(nonImmutableKeyProperty)).toEqual(false);\n});\n\ntest(\"isImmutable\", function() {\n\texpect(isImmutable(basicProperty)).toEqual(false);\n\texpect(isImmutable(keyProperty)).toEqual(false);\n\texpect(isImmutable(computedProperty)).toEqual(false);\n\texpect(isImmutable(computedKeyProperty)).toEqual(false);\n\texpect(isImmutable(nonComputedProperty)).toEqual(false);\n\texpect(isImmutable(nonComputedKeyProperty)).toEqual(false);\n\texpect(isImmutable(immutableProperty)).toEqual(true);\n\texpect(isImmutable(immutableKeyProperty)).toEqual(true);\n\texpect(isImmutable(nonImmutableProperty)).toEqual(false);\n\texpect(isImmutable(nonImmutableKeyProperty)).toEqual(false);\n});\n\ntest(\"isKey\", function() {\n\texpect(isKey(basicProperty)).toEqual(false);\n\texpect(isKey(keyProperty)).toEqual(true);\n\texpect(isKey(computedProperty)).toEqual(false);\n\texpect(isKey(computedKeyProperty)).toEqual(true);\n\texpect(isKey(nonComputedProperty)).toEqual(false);\n\texpect(isKey(nonComputedKeyProperty)).toEqual(true);\n\texpect(isKey(immutableProperty)).toEqual(false);\n\texpect(isKey(immutableKeyProperty)).toEqual(true);\n\texpect(isKey(nonImmutableProperty)).toEqual(false);\n\texpect(isKey(nonImmutableKeyProperty)).toEqual(true);\n});\n\ntest(\"hasSemanticObject\", function() {\n\texpect(hasSemanticObject(propertyWithSemanticObject)).toEqual(true);\n\texpect(hasSemanticObject(basicProperty)).toEqual(false);\n});\n\ntest(\"isReadOnly\", function() {\n\texpect(isReadOnlyExpression(basicProperty)).toEqual(false);\n\texpect(isReadOnlyExpression(staticDisabledFieldGroupProperty)).toEqual(false);\n\texpect(isReadOnlyExpression(staticInorrectFieldGroupProperty)).toEqual(false);\n\texpect(isReadOnlyExpression(staticReadOnlyFieldGroupProperty)).toEqual(true);\n\texpect(isReadOnlyExpression(dynamicFieldGroupProperty)).toEqual(\n\t\tor(equal(bindingExpression(\"BasicProperty\"), 1), equal(bindingExpression(\"BasicProperty\"), \"1\"))\n\t);\n});\n\ntest(\"isDisabled\", function() {\n\texpect(isDisabledExpression(basicProperty)).toEqual(false);\n\texpect(isDisabledExpression(staticDisabledFieldGroupProperty)).toEqual(true);\n\texpect(isDisabledExpression(staticInorrectFieldGroupProperty)).toEqual(false);\n\texpect(isDisabledExpression(staticReadOnlyFieldGroupProperty)).toEqual(false);\n\texpect(isDisabledExpression(dynamicFieldGroupProperty)).toEqual(\n\t\tor(equal(bindingExpression(\"BasicProperty\"), 0), equal(bindingExpression(\"BasicProperty\"), \"0\"))\n\t);\n});\n\ntest(\"isNonEditable\", function() {\n\texpect(isNonEditableExpression(basicProperty)).toEqual(constant(false));\n\texpect(isNonEditableExpression(staticDisabledFieldGroupProperty)).toEqual(constant(true));\n\texpect(isNonEditableExpression(staticInorrectFieldGroupProperty)).toEqual(constant(false));\n\texpect(isNonEditableExpression(staticReadOnlyFieldGroupProperty)).toEqual(constant(true));\n\texpect(isNonEditableExpression(dynamicFieldGroupProperty)).toEqual(\n\t\tor(\n\t\t\tor(equal(bindingExpression(\"BasicProperty\"), 1), equal(bindingExpression(\"BasicProperty\"), \"1\")),\n\t\t\tor(equal(bindingExpression(\"BasicProperty\"), 0), equal(bindingExpression(\"BasicProperty\"), \"0\"))\n\t\t)\n\t);\n});\n\ntest(\"hasValueHelp\", function() {\n\texpect(hasValueHelp(basicProperty)).toEqual(false);\n\texpect(hasValueHelp(valueListProperty)).toEqual(true);\n\texpect(hasValueHelp(valueListMappingProperty)).toEqual(true);\n\texpect(hasValueHelp(valueListReferenceProperty)).toEqual(true);\n\texpect(hasValueHelp(valueListWithFixedValuesProperty)).toEqual(true);\n});\n\ntest(\"hasValueListForValidation\", function() {\n\texpect(hasValueListForValidation(valueListForValidationProperty)).toEqual(true);\n});\n\ntest(\"isAnnotationPathExpression\", function() {\n\texpect(isAnnotationPathExpression(basicPropertywithAnnotationPath)).toEqual(true);\n});\n"]}