@sap/open.fe 1.99.0 → 1.100.0

package/packages/sap.fe.core/test/sap/fe/core/jest/data/TemplatingTestData.ts

@@ -0,0 +1,413 @@
+import { AnyAnnotation, EntitySet, EntityType, NavigationProperty, Property } from "@sap-ux/annotation-converter";
+import {
+	EntitySetAnnotations,
+	EntityTypeAnnotations,
+	NavigationPropertyAnnotations,
+	PropertyAnnotations
+} from "@sap-ux/vocabularies-types";
+import deepClone from "sap/base/util/deepClone";
+import { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
+
+export class ModelObjectWrapper {
+	annotations: AnyAnnotation;
+	constructor() {
+		this.annotations = {};
+	}
+	addAnnotation(annotationPath: string, annotationValue: any) {
+		const pathSplit = annotationPath.split(".");
+		pathSplit.reduce((currObj: any, pathPart, pathIndex) => {
+			if (currObj[pathPart] === undefined) {
+				currObj[pathPart] = {};
+			}
+			if (pathIndex === pathSplit.length - 1) {
+				currObj[pathPart] = annotationValue;
+			}
+			return currObj[pathPart];
+		}, this.annotations);
+		return this;
+	}
+}
+export class PropertyPathExpression extends ModelObjectWrapper {
+	path: string;
+	$target: Property;
+	type: string;
+
+	constructor(targetProperty: Property) {
+		super();
+		this.path = targetProperty.name;
+		this.type = "Path";
+		this.$target = targetProperty;
+	}
+}
+
+export class AnnotationPropertyPathExpression extends ModelObjectWrapper {
+	path: string;
+	$target: Property;
+	type: string;
+
+	constructor(targetProperty: Property) {
+		super();
+		this.path = targetProperty.name;
+		this.type = "AnnotationPath";
+		this.$target = targetProperty;
+	}
+}
+export class PropertyWrapper extends ModelObjectWrapper {
+	private name: string;
+	private isKey: boolean;
+	annotations: PropertyAnnotations;
+
+	constructor(name: string, isKey: boolean = false, annotations = {}) {
+		super();
+		this.annotations = annotations;
+		this.name = name;
+		this.isKey = isKey;
+	}
+
+	value(): Property {
+		return {
+			name: this.name,
+			type: "Edm.String",
+			_type: "Property",
+			fullyQualifiedName: this.name,
+			annotations: this.annotations,
+			isKey: this.isKey
+		};
+	}
+	static clone(property: Property): PropertyWrapper {
+		return new PropertyWrapper(property.name, property.isKey, deepClone(property.annotations));
+	}
+}
+
+export class NavigationPropertyWrapper extends ModelObjectWrapper {
+	private name: string;
+	private targetType: EntityType;
+	annotations: NavigationPropertyAnnotations;
+
+	constructor(name: string, targetType: EntityType, annotations = {}) {
+		super();
+		this.annotations = annotations;
+		this.name = name;
+		this.targetType = targetType;
+	}
+
+	value(): NavigationProperty {
+		return {
+			name: this.name,
+			_type: "NavigationProperty",
+			fullyQualifiedName: this.name,
+			annotations: this.annotations,
+			partner: "",
+			targetType: this.targetType,
+			targetTypeName: this.targetType.name,
+			isCollection: true,
+			containsTarget: false
+		};
+	}
+	static clone(navigationProperty: NavigationProperty): NavigationPropertyWrapper {
+		return new NavigationPropertyWrapper(
+			navigationProperty.name,
+			navigationProperty.targetType,
+			deepClone(navigationProperty.annotations)
+		);
+	}
+}
+
+export class EntityTypeWrapper extends ModelObjectWrapper {
+	private name: string;
+	annotations: EntityTypeAnnotations;
+
+	constructor(name: string) {
+		super();
+		this.annotations = {};
+		this.name = name;
+	}
+
+	value(): EntityType {
+		return {
+			name: this.name,
+			_type: "EntityType",
+			fullyQualifiedName: this.name,
+			annotations: this.annotations,
+			entityProperties: [],
+			keys: [],
+			navigationProperties: [],
+			actions: {},
+			// eslint-disable-next-line @typescript-eslint/no-empty-function
+			resolvePath(relativePath: string): any {}
+		};
+	}
+}
+
+export class EntitySetWrapper extends ModelObjectWrapper {
+	private name: string;
+	private entityType: EntityType;
+	annotations: EntitySetAnnotations;
+
+	constructor(name: string, entityType: EntityType) {
+		super();
+		this.annotations = {};
+		this.name = name;
+		this.entityType = entityType;
+	}
+
+	value(): EntitySet {
+		return {
+			name: this.name,
+			entityTypeName: this.entityType.name,
+			entityType: this.entityType,
+			_type: "EntitySet",
+			fullyQualifiedName: this.name,
+			annotations: this.annotations,
+			navigationPropertyBinding: {}
+		};
+	}
+}
+
+export class DataModelObjectPathWrapper {
+	private rootEntitySet: EntitySet;
+	private navPropArray: NavigationProperty[];
+	constructor(rootEntitySet: EntitySet, navPropArray: NavigationProperty[] = []) {
+		this.rootEntitySet = rootEntitySet;
+		this.navPropArray = navPropArray;
+	}
+
+	value(): DataModelObjectPath {
+		let targetEntitySet: EntitySet | undefined = this.rootEntitySet;
+		let targetEntityType;
+		if (this.navPropArray.length > 0) {
+			targetEntitySet = this.navPropArray.reduce(
+				(currentEntitySet: EntitySet | undefined, navigationProperty: NavigationProperty) => {
+					if (!currentEntitySet) {
+						return undefined;
+					} else {
+						return currentEntitySet.navigationPropertyBinding[navigationProperty.name];
+					}
+				},
+				targetEntitySet
+			);
+		}
+		if (!targetEntitySet) {
+			targetEntityType = this.navPropArray[this.navPropArray.length - 1].targetType;
+		} else {
+			targetEntityType = targetEntitySet.entityType;
+		}
+		return {
+			startingEntitySet: this.rootEntitySet,
+			contextLocation: {
+				startingEntitySet: this.rootEntitySet,
+				navigationProperties: [],
+				targetEntityType: this.rootEntitySet.entityType,
+				targetEntitySet: this.rootEntitySet,
+				targetObject: this.rootEntitySet,
+				convertedTypes: {} as any
+			},
+			navigationProperties: this.navPropArray,
+			targetEntityType: targetEntityType,
+			targetEntitySet: targetEntitySet,
+			targetObject: targetEntitySet,
+			convertedTypes: {} as any
+		};
+	}
+}
+
+export function getEntitySetWithAnnotation(annotationName?: string, annotationValue?: object) {
+	const basicEntityType = new EntityTypeWrapper("BasicEntitySetType").value();
+	const basicEntitySetWrapper = new EntitySetWrapper("BasicEntitySet", basicEntityType);
+	if (annotationName) {
+		basicEntitySetWrapper.addAnnotation(annotationName, annotationValue);
+	}
+	const basicEntitySet = basicEntitySetWrapper.value();
+	return basicEntitySet;
+}
+
+export function getEntitySetPath(entitySet: EntitySet, navPropArray: NavigationProperty[] = []): DataModelObjectPath {
+	return new DataModelObjectPathWrapper(entitySet, navPropArray).value();
+}
+
+export const basicEntityType = new EntityTypeWrapper("BasicEntitySetType").value();
+export const basicEntitySet = new EntitySetWrapper("BasicEntitySet", basicEntityType).value();
+export const basicEntitySetPath = new DataModelObjectPathWrapper(basicEntitySet).value();
+
+export const nonUpdatableEntitySetPath = new DataModelObjectPathWrapper(basicEntitySet).value();
+
+export const entityTypeWithTextOnlyArrangement = new EntityTypeWrapper("EntitySetWithTextArrangementType")
+	.addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextOnly")
+	.value();
+export const entitySetWithTextOnlyArrangement = new EntitySetWrapper(
+	"EntitySetWithTextOnlyArrangement",
+	entityTypeWithTextOnlyArrangement
+).value();
+export const entitySetWithTextOnlyArrangementPath = new DataModelObjectPathWrapper(entitySetWithTextOnlyArrangement).value();
+export const entityTypeWithTextLastArrangement = new EntityTypeWrapper("EntitySetWithTextLastArrangementType")
+	.addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextLast")
+	.value();
+export const entitySetWithTextLastArrangement = new EntitySetWrapper(
+	"EntitySetWithTextLastArrangement",
+	entityTypeWithTextLastArrangement
+).value();
+
+export const entitySetWithTextLastArrangementPath = new DataModelObjectPathWrapper(entitySetWithTextLastArrangement).value();
+
+export const entityTypeWithTextSeparateArrangement = new EntityTypeWrapper("EntitySetWithTextSeparateArrangementType")
+	.addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextSeparate")
+	.value();
+export const entitySetWithTextSeparateArrangement = new EntitySetWrapper(
+	"EntitySetWithTextSeparateArrangement",
+	entityTypeWithTextSeparateArrangement
+).value();
+
+export const entitySetWithTextSeparateArrangementPath = new DataModelObjectPathWrapper(entitySetWithTextSeparateArrangement).value();
+
+export const entityTypeWithTextFirstArrangement = new EntityTypeWrapper("EntitySetWithTextFirstArrangementType")
+	.addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextFirst")
+	.value();
+export const entitySetWithTextFirstArrangement = new EntitySetWrapper(
+	"EntitySetWithTextFirstArrangement",
+	entityTypeWithTextFirstArrangement
+).value();
+
+export const entitySetWithTextFirstArrangementPath = new DataModelObjectPathWrapper(entitySetWithTextFirstArrangement).value();
+
+export const basicProperty = new PropertyWrapper("BasicProperty").value();
+export const pathToCheckProperty = new PropertyWrapper("PathToCheckProperty").value();
+export const basicPropertyWithText = new PropertyWrapper("BasicPropertyWithText").addAnnotation("Common.Text", basicProperty).value();
+export const basicPropertyWithoutTextAndTextOnlyArrangement = new PropertyWrapper("BasicPropertyWithTextOnlyArrangement")
+	.addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextOnly")
+	.value();
+export const basicPropertyWithTextSeparateArrangement = new PropertyWrapper("BasicPropertyWithTextSeparateArrangement")
+	.addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextSeparate")
+	.value();
+export const basicPropertyWithTextOnlyArrangement = new PropertyWrapper("BasicPropertyWithTextOnlyArrangement")
+	.addAnnotation(
+		"Common.Text",
+		new PropertyPathExpression(basicProperty).addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextOnly")
+	)
+	.value();
+export const basicPropertyWithTextLastArrangement = new PropertyWrapper("BasicPropertyWithTextLastArrangement")
+	.addAnnotation(
+		"Common.Text",
+		new PropertyPathExpression(basicProperty).addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextLast")
+	)
+	.value();
+export const basicPropertyWithTextFirstArrangement = new PropertyWrapper("BasicPropertyWithTextFirstArrangement")
+	.addAnnotation(
+		"Common.Text",
+		new PropertyPathExpression(basicProperty).addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextFirst")
+	)
+	.value();
+
+export const basicPropertyWithTextOnlyArrangementAndValueHelp = new PropertyWrapper("BasicPropertyWithTextOnlyArrangementAndValueHelp")
+	.addAnnotation(
+		"Common.Text",
+		new PropertyPathExpression(basicProperty).addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextOnly")
+	)
+	.addAnnotation("Common.ValueListMapping", {})
+	.value();
+export const basicPropertyWithTextLastArrangementAndValueHelp = new PropertyWrapper("BasicPropertyWithTextOnlyArrangementAndValueHelp")
+	.addAnnotation(
+		"Common.Text",
+		new PropertyPathExpression(basicProperty).addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextLast")
+	)
+	.addAnnotation("Common.ValueListMapping", {})
+	.value();
+export const basicPropertyWithTextFirstArrangementAndValueHelp = new PropertyWrapper("BasicPropertyWithTextOnlyArrangementAndValueHelp")
+	.addAnnotation(
+		"Common.Text",
+		new PropertyPathExpression(basicProperty).addAnnotation("UI.TextArrangement", "UI.TextArrangementType/TextFirst")
+	)
+	.addAnnotation("Common.ValueListMapping", {})
+	.value();
+export const basicPropertywithAnnotationPath = new AnnotationPropertyPathExpression(basicProperty);
+export const keyProperty = new PropertyWrapper("KeyProperty", true).value();
+export const computedProperty = new PropertyWrapper("ComputedProperty").addAnnotation("Core.Computed", true).value();
+export const computedKeyProperty = new PropertyWrapper("ComputedKeyProperty", true).addAnnotation("Core.Computed", true).value();
+export const nonComputedProperty = new PropertyWrapper("NonComputedProperty").addAnnotation("Core.Computed", false).value();
+export const nonComputedKeyProperty = new PropertyWrapper("NonComputedKeyProperty", true).addAnnotation("Core.Computed", false).value();
+export const immutableProperty = new PropertyWrapper("ImmutableProperty").addAnnotation("Core.Immutable", true).value();
+export const immutableKeyProperty = new PropertyWrapper("ImmutableKeyProperty", true).addAnnotation("Core.Immutable", true).value();
+export const nonImmutableProperty = new PropertyWrapper("NonImmutableProperty").addAnnotation("Core.Immutable", false).value();
+export const nonImmutableKeyProperty = new PropertyWrapper("NonImmutableKeyProperty", true).addAnnotation("Core.Immutable", false).value();
+export const immutableComputedProperty = new PropertyWrapper("ImmutableComputedProperty")
+	.addAnnotation("Core.Immutable", true)
+	.addAnnotation("Core.Computed", true)
+	.value();
+export const propertyWithSemanticObject = new PropertyWrapper("PropertyWithSemanticObject")
+	.addAnnotation("Common.SemanticObject", "The semantic object")
+	.value();
+export const staticReadOnlyFieldGroupProperty = new PropertyWrapper("StaticReadOnlyFieldGroupProperty")
+	.addAnnotation("Common.FieldControl", "Common.FieldControlType/ReadOnly")
+	.value();
+export const staticDisabledFieldGroupProperty = new PropertyWrapper("StaticDisabledFieldGroupProperty")
+	.addAnnotation("Common.FieldControl", "Common.FieldControlType/Inapplicable")
+	.value();
+export const staticInorrectFieldGroupProperty = new PropertyWrapper("StaticInorrectFieldGroupProperty")
+	.addAnnotation("Common.FieldControl", "Common.FieldControlType/IncorrectValue")
+	.value();
+export const staticMandatoryFieldGroupProperty = new PropertyWrapper("StaticInorrectFieldGroupProperty")
+	.addAnnotation("Common.FieldControl", "Common.FieldControlType/Mandatory")
+	.value();
+
+export const dynamicFieldGroupProperty = new PropertyWrapper("DynamicFieldGroupProperty")
+	.addAnnotation("Common.FieldControl", new PropertyPathExpression(basicProperty))
+	.value();
+
+export const valueListProperty = new PropertyWrapper("ValueListProperty").addAnnotation("Common.ValueList", {}).value();
+
+export const valueListWithFixedValuesProperty = new PropertyWrapper("ValueListWithFixedValuesProperty")
+	.addAnnotation("Common.ValueListWithFixedValues", {})
+	.value();
+
+export const valueListForValidationProperty = new PropertyWrapper("ValueListForValidationProperty")
+	.addAnnotation("Common.ValueListForValidation", {})
+	.value();
+
+export const valueListReferenceProperty = new PropertyWrapper("ValueListReferenceProperty")
+	.addAnnotation("Common.ValueListReferences", {})
+	.value();
+
+export const valueListMappingProperty = new PropertyWrapper("ValueListMappingProperty")
+	.addAnnotation("Common.ValueListMapping", {})
+	.value();
+
+export const propertyWithSemanticObjectAndValueHelp = new PropertyWrapper("PropertyWithSemanticObjectAndValueHelp")
+	.addAnnotation("Common.SemanticObject", "The semantic object")
+	.addAnnotation("Common.ValueListWithFixedValues", {})
+	.value();
+
+export const propertyWithUnit = new PropertyWrapper("PropertyWithUnit")
+	.addAnnotation("Measures.Unit", new PropertyPathExpression(basicProperty))
+	.value();
+
+export const propertyWithCurrency = new PropertyWrapper("PropertyWithUnit")
+	.addAnnotation("Measures.ISOCurrency", new PropertyPathExpression(basicProperty))
+	.value();
+
+export const propertyWithComputedUnit = new PropertyWrapper("propertyWithUnitWithDynamicFieldGroupComputed")
+	.addAnnotation("Measures.Unit", new PropertyPathExpression(computedProperty))
+	.value();
+
+export const propertyWithComputedCurrency = new PropertyWrapper("propertyWithUnitWithDynamicFieldGroupComputed")
+	.addAnnotation("Measures.ISOCurrency", new PropertyPathExpression(computedProperty))
+	.value();
+
+export const propertyWithUnitWithReadOnlyFieldGroup = new PropertyWrapper("PropertyWithUnitWithReadOnlyFieldGroup")
+	.addAnnotation("Measures.Unit", new PropertyPathExpression(staticReadOnlyFieldGroupProperty))
+	.value();
+
+export const propertyWithUnitWithDisabledFieldGroup = new PropertyWrapper("PropertyWithUnitWithDisabledFieldGroup")
+	.addAnnotation("Measures.Unit", new PropertyPathExpression(staticDisabledFieldGroupProperty))
+	.value();
+
+export const propertyWithUnitWithDynamicFieldGroup = new PropertyWrapper("PropertyWithUnitWithDynamicFieldGroup")
+	.addAnnotation("Measures.Unit", new PropertyPathExpression(dynamicFieldGroupProperty))
+	.value();
+
+export const dynamicFieldGroupPropertyWithUnitWithDynamicFieldGroup = new PropertyWrapper(
+	"DynamicFieldGroupPropertyWithUnitWithDynamicFieldGroup"
+)
+	.addAnnotation("Common.FieldControl", new PropertyPathExpression(keyProperty))
+	.addAnnotation("Measures.Unit", new PropertyPathExpression(dynamicFieldGroupProperty))
+	.value();
+
+//