@sap/open.fe 1.97.0 → 1.98.0

package/packages/sap.fe.core/test/sap/fe/core/jest/converters/TableStandardActions.spec.ts

@@ -0,0 +1,2150 @@
+import {
+	getCreateTemplating,
+	getCreateVisibility,
+	getCreateEnablement,
+	getDeleteVisibility,
+	getDefaultTemplating,
+	isExternalCreateConfigured,
+	isDraftOrStickySupported,
+	getNewAction,
+	getDeleteEnablement,
+	getPasteVisibility,
+	getMassEditVisibility,
+	getMassEditEnablement,
+	getRestrictions,
+	isActionAnnotatedHidden,
+	getInsertUpdateActionsTemplating,
+	generateStandardActionsContext,
+	StandardActionsContext,
+	getStandardActionCreate,
+	getStandardActionDelete,
+	getStandardActionPaste,
+	getStandardActionMassEdit
+} from "sap/fe/core/converters/controls/Common/table/StandardActions";
+
+import path from "path";
+import { convertTypes } from "sap/fe/core/converters/MetaModelConverter";
+import { compileCDS, getConverterContextForTest, getMetaModel } from "sap/fe/test/JestTemplatingHelper";
+import { CreationMode, SelectionMode, TemplateType } from "sap/fe/core/converters/ManifestSettings";
+import { ConverterOutput } from "@sap-ux/vocabularies-types";
+import { bindingExpression, compileBinding, constant, equal } from "sap/fe/core/helpers/BindingExpression";
+import { UI } from "sap/fe/core/converters/helpers/BindingHelper";
+import ConverterContext from "sap/fe/core/converters/ConverterContext";
+import { Binding } from "sap/ui/model";
+
+let convertedTypes: ConverterOutput;
+let convertedTypesNoOa: ConverterOutput;
+let convertedTypesOaTrue: ConverterOutput;
+let convertedTypesOaFalse: ConverterOutput;
+let convertedTypesOaOnSticky: ConverterOutput;
+
+let BASIC_CONTEXT_LR: ConverterContext;
+let BASIC_CONTEXT_LR_DYNAMIC_HIDDEN: ConverterContext;
+let BASIC_CONTEXT_OP: ConverterContext;
+let BASIC_CONTEXT_ALP: ConverterContext;
+
+let NEW_ACTION_NO_OA: ConverterContext;
+let NEW_ACTION_OA_TRUE: ConverterContext;
+let NEW_ACTION_OA_FALSE: ConverterContext;
+let NEW_ACTION_OA_ON_STICKY: ConverterContext;
+
+let BASIC_ACTION_CONTEXT: StandardActionsContext;
+let BASIC_MASS_EDIT_ACTION_CONTEXT: StandardActionsContext;
+
+const CONSTANT_FALSE = constant(false);
+const CONSTANT_TRUE = constant(true);
+const DUMMY_DYNAMIC_BINDING = bindingExpression("dummyExpression");
+
+const NOT_INSERTABLE = {
+	isInsertable: {
+		expression: CONSTANT_FALSE
+	}
+};
+const INSERTABLE = {
+	isInsertable: {
+		expression: CONSTANT_TRUE
+	}
+};
+const DYNAMIC_INSERTABLE = {
+	isInsertable: {
+		expression: bindingExpression("SomeDynamicInsertable"),
+		isOnlyCurrentEntityExpression: false
+	}
+};
+const DYNAMIC_INSERTABLE_ONLY_ON_CURRENT = {
+	isInsertable: {
+		expression: bindingExpression("SomeDynamicInsertable"),
+		isOnlyCurrentEntityExpression: true
+	}
+};
+
+const NOT_DELETABLE = {
+	isDeletable: {
+		expression: CONSTANT_FALSE
+	}
+};
+const DELETABLE = {
+	isDeletable: {
+		expression: CONSTANT_TRUE
+	}
+};
+const DYNAMIC_DELETABLE = {
+	isDeletable: {
+		expression: bindingExpression("SomeDynamicDeletable"),
+		isOnlyCurrentEntityExpression: false
+	}
+};
+const DYNAMIC_DELETABLE_ONLY_ON_CURRENT = {
+	isDeletable: {
+		expression: bindingExpression("SomeDynamicDeletable"),
+		isOnlyCurrentEntityExpression: true
+	}
+};
+
+const NOT_UPDATABLE = {
+	isUpdatable: {
+		expression: CONSTANT_FALSE
+	}
+};
+const UPDATABLE = {
+	isUpdatable: {
+		expression: CONSTANT_TRUE
+	}
+};
+const DYNAMIC_UPDATABLE = {
+	isUpdatable: {
+		expression: bindingExpression("SomeDynamicUpdatable"),
+		isOnlyCurrentEntityExpression: false
+	}
+};
+const DYNAMIC_UPDATABLE_ONLY_ON_CURRENT = {
+	isUpdatable: {
+		expression: bindingExpression("SomeDynamicUpdatable"),
+		isOnlyCurrentEntityExpression: true
+	}
+};
+const HIDDEN_CREATE = { create: CONSTANT_TRUE };
+const NOT_HIDDEN_CREATE = { create: CONSTANT_FALSE };
+const DYNAMIC_HIDDEN_CREATE = { create: bindingExpression("SomeDynamicHiddenCreate") };
+
+const HIDDEN_DELETE = { "delete": CONSTANT_TRUE };
+const NOT_HIDDEN_DELETE = { "delete": CONSTANT_FALSE };
+const DYNAMIC_HIDDEN_DELETE = { "delete": bindingExpression("SomeDynamicHiddenDelete") };
+
+const HIDDEN_UPDATE = { update: CONSTANT_TRUE };
+const NOT_HIDDEN_UPDATE = { update: CONSTANT_FALSE };
+const DYNAMIC_HIDDEN_UPDATE = { update: bindingExpression("SomeDynamicHiddenUpdate") };
+
+const DYNAMIC_CREATE_VISIBILITY = bindingExpression("SomeDynamicCreateVisibility");
+const AVAILABLE_NEW_ACTION = {
+	name: "availableNewAction",
+	available: constant(true)
+};
+const NOT_AVAILABLE_NEW_ACTION = {
+	name: "availableNewAction",
+	available: constant(false)
+};
+const DYNAMIC_NEW_ACTION = {
+	name: "availableNewAction",
+	available: bindingExpression("SomeDynamicNewAction")
+};
+
+beforeAll(async function() {
+	const sMetadataUrl = compileCDS(path.join(__dirname, "../data/Table.cds"));
+	const metaModel = await getMetaModel(sMetadataUrl);
+	convertedTypes = convertTypes(metaModel);
+
+	const sMetadataUrlOaTrue = compileCDS(path.join(__dirname, "../data/TableNewActionOperationAvailableTrue.cds"));
+	const metaModelOaTrue = await getMetaModel(sMetadataUrlOaTrue);
+	convertedTypesOaTrue = convertTypes(metaModelOaTrue);
+
+	BASIC_CONTEXT_LR = getConverterContextForTest(convertedTypes, {
+		entitySet: "TestEntity",
+		converterType: TemplateType.ListReport
+	});
+	BASIC_CONTEXT_LR_DYNAMIC_HIDDEN = getConverterContextForTest(convertedTypes, {
+		entitySet: "TestDynamicActionsHidden",
+		converterType: TemplateType.ListReport
+	});
+	BASIC_CONTEXT_OP = getConverterContextForTest(convertedTypes, {
+		entitySet: "TestEntityWithNavigation",
+		converterType: TemplateType.ObjectPage
+	});
+
+	BASIC_CONTEXT_ALP = getConverterContextForTest(convertedTypes, {
+		entitySet: "TestEntity",
+		converterType: TemplateType.AnalyticalListPage
+	});
+
+	NEW_ACTION_OA_TRUE = getConverterContextForTest(convertedTypesOaTrue, {
+		entitySet: "TestEntity",
+		converterType: TemplateType.ListReport
+	});
+
+	BASIC_ACTION_CONTEXT = generateStandardActionsContext(
+		BASIC_CONTEXT_OP,
+		{},
+		{
+			enablePaste: true,
+			creationMode: "Inline"
+		} as any,
+		{} as any
+	);
+
+	BASIC_MASS_EDIT_ACTION_CONTEXT = generateStandardActionsContext(
+		BASIC_CONTEXT_OP,
+		{},
+		{
+			creationMode: "Inline",
+			enableMassEdit: true,
+			selectionLimit: 3
+		} as any,
+		{} as any
+	);
+});
+
+describe("Table Converter - Standard actions - Get Context - Hidden via Annotation", function() {
+	it("Hidden property is collected for all actions", () => {
+		const ContextWithDynamicHidden = BASIC_CONTEXT_OP.getEntityTypeAnnotation("_actionsHidden/@com.sap.vocabularies.UI.v1.LineItem")
+			.converterContext;
+		const ContextWithoutHidden = BASIC_CONTEXT_OP.getEntityTypeAnnotation(
+			"_onlyCapabilitiesRestrictionsOnTarget/@com.sap.vocabularies.UI.v1.LineItem"
+		).converterContext;
+		expect(isActionAnnotatedHidden(ContextWithDynamicHidden, "CreateHidden")).toEqual(bindingExpression("_actionsHidden/hiddenCreate"));
+		expect(isActionAnnotatedHidden(ContextWithDynamicHidden, "DeleteHidden")).toEqual(bindingExpression("_actionsHidden/hiddenDelete"));
+		expect(isActionAnnotatedHidden(ContextWithDynamicHidden, "UpdateHidden")).toEqual(bindingExpression("_actionsHidden/hiddenUpdate"));
+		expect(isActionAnnotatedHidden(BASIC_CONTEXT_LR, "CreateHidden")).toEqual(constant(false));
+		expect(isActionAnnotatedHidden(BASIC_CONTEXT_LR, "DeleteHidden")).toEqual(constant(false));
+		expect(isActionAnnotatedHidden(BASIC_CONTEXT_LR, "UpdateHidden")).toEqual(constant(false));
+		expect(isActionAnnotatedHidden(ContextWithoutHidden, "CreateHidden")).toEqual(constant(false));
+		expect(isActionAnnotatedHidden(ContextWithoutHidden, "DeleteHidden")).toEqual(constant(false));
+		expect(isActionAnnotatedHidden(ContextWithoutHidden, "UpdateHidden")).toEqual(constant(false));
+		expect(isActionAnnotatedHidden(BASIC_CONTEXT_LR_DYNAMIC_HIDDEN, "CreateHidden")).toEqual(bindingExpression("hiddenCreate"));
+		expect(isActionAnnotatedHidden(BASIC_CONTEXT_LR_DYNAMIC_HIDDEN, "DeleteHidden")).toEqual(bindingExpression("hiddenDelete"));
+		expect(isActionAnnotatedHidden(BASIC_CONTEXT_LR_DYNAMIC_HIDDEN, "UpdateHidden")).toEqual(bindingExpression("hiddenUpdate"));
+	});
+});
+
+describe("Table Converter - Standard actions - Get Context - Restrictions", function() {
+	it("Restrictions are collected", () => {
+		const ContextWithWithoutRestrictions = BASIC_CONTEXT_OP.getEntityTypeAnnotation(
+			"_actionsHidden/@com.sap.vocabularies.UI.v1.LineItem"
+		).converterContext;
+		const ContextWithOnlyNavRestrictions = BASIC_CONTEXT_OP.getEntityTypeAnnotation(
+			"_restrictionsAndActionsHidden/@com.sap.vocabularies.UI.v1.LineItem"
+		).converterContext;
+		const ContextWithOnlyCapabilitiesRestrictionOnTarget = BASIC_CONTEXT_OP.getEntityTypeAnnotation(
+			"_onlyCapabilitiesRestrictionsOnTarget/@com.sap.vocabularies.UI.v1.LineItem"
+		).converterContext;
+		const ContextWithRestrictionOnTargetAndNavigation = BASIC_CONTEXT_OP.getEntityTypeAnnotation(
+			"_restrictionsOnTargetAndNavigation/@com.sap.vocabularies.UI.v1.LineItem"
+		).converterContext;
+
+		expect(getRestrictions(ContextWithWithoutRestrictions)).toEqual({
+			"isDeletable": {
+				"expression": constant(true),
+				"isOnlyCurrentEntityExpression": false
+			},
+			"isInsertable": {
+				"expression": constant(true),
+				"isOnlyCurrentEntityExpression": false
+			},
+			"isUpdatable": {
+				"expression": constant(true),
+				"isOnlyCurrentEntityExpression": false
+			}
+		});
+
+		expect(getRestrictions(ContextWithOnlyNavRestrictions)).toEqual({
+			"isDeletable": {
+				"expression": equal(bindingExpression("restrictionOnDelete", undefined), true),
+				"isOnlyCurrentEntityExpression": false
+			},
+			"isInsertable": {
+				"expression": equal(bindingExpression("restrictionOnInsert", undefined), true),
+				"isOnlyCurrentEntityExpression": false
+			},
+			"isUpdatable": {
+				"expression": equal(bindingExpression("restrictionOnUpdate", undefined), true),
+				"isOnlyCurrentEntityExpression": false
+			}
+		});
+
+		expect(getRestrictions(ContextWithOnlyCapabilitiesRestrictionOnTarget)).toEqual({
+			"isDeletable": {
+				"expression": equal(bindingExpression("_onlyCapabilitiesRestrictionsOnTarget/localRestrictionOnDelete", undefined), true),
+				"isOnlyCurrentEntityExpression": true
+			},
+			"isInsertable": {
+				"expression": equal(bindingExpression("_onlyCapabilitiesRestrictionsOnTarget/localRestrictionOnInsert", undefined), true),
+				"isOnlyCurrentEntityExpression": true
+			},
+			"isUpdatable": {
+				"expression": equal(bindingExpression("_onlyCapabilitiesRestrictionsOnTarget/localRestrictionOnUpdate", undefined), true),
+				"isOnlyCurrentEntityExpression": true
+			}
+		});
+
+		expect(getRestrictions(ContextWithRestrictionOnTargetAndNavigation)).toEqual({
+			"isDeletable": {
+				"expression": equal(bindingExpression("restrictionOnDelete", undefined), true),
+				"isOnlyCurrentEntityExpression": false
+			},
+			"isInsertable": {
+				"expression": equal(bindingExpression("restrictionOnInsert", undefined), true),
+				"isOnlyCurrentEntityExpression": false
+			},
+			"isUpdatable": {
+				"expression": equal(bindingExpression("restrictionOnUpdate", undefined), true),
+				"isOnlyCurrentEntityExpression": false
+			}
+		});
+
+		expect(getRestrictions(BASIC_CONTEXT_LR)).toEqual({
+			"isDeletable": {
+				"expression": constant(true),
+				"isOnlyCurrentEntityExpression": false
+			},
+			"isInsertable": {
+				"expression": constant(true),
+				"isOnlyCurrentEntityExpression": false
+			},
+			"isUpdatable": {
+				"expression": constant(true),
+				"isOnlyCurrentEntityExpression": false
+			}
+		});
+	});
+});
+
+describe("Table Converter - Standard actions - Get Context - Is external action Configured", function() {
+	it("Completed configuration", () => {
+		expect(
+			isExternalCreateConfigured({
+				create: {
+					outbound: "outbound",
+					outboundDetail: {
+						semanticObject: "dummy",
+						action: "dummy"
+					}
+				}
+			})
+		).toEqual(true);
+	});
+
+	it("Uncompleted configuration", () => {
+		expect(
+			isExternalCreateConfigured({
+				create: {
+					outbound: "outbound"
+				}
+			})
+		).toEqual(false);
+	});
+
+	it("Not configured", () => {
+		expect(
+			isExternalCreateConfigured({
+				detail: {
+					route: "dummy"
+				}
+			})
+		).toEqual(false);
+	});
+});
+
+describe("Table Converter - Standard actions - Get Context - Is draft or sticky supported", function() {
+	const generateMockConverterContext = function(mParams: any): ConverterContext {
+		return ({
+			getEntitySet: function() {
+				return mParams.isContainment
+					? undefined
+					: {
+							annotations: {
+								Common: {
+									DraftNode: mParams.isDraftNode,
+									DraftRoot: mParams.isDraftRoot
+								}
+							}
+					  };
+			},
+			getDataModelObjectPath: function() {
+				return {
+					startingEntitySet: {
+						annotations: {
+							Session: {
+								StickySessionSupported: mParams.isSticky
+							},
+							Common: {
+								DraftNode: mParams.isContainmentDraftNode,
+								DraftRoot: mParams.isContainmentDraftRoot
+							}
+						}
+					},
+					targetObject: {
+						containsTarget: mParams.isContainment
+					}
+				};
+			}
+		} as any) as ConverterContext;
+	};
+
+	it("test all configs", () => {
+		expect(isDraftOrStickySupported(generateMockConverterContext({}))).toEqual(false);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isDraftRoot: true
+				})
+			)
+		).toEqual(true);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isDraftRoot: false
+				})
+			)
+		).toEqual(false);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isDraftRoot: false,
+					isSticky: true
+				})
+			)
+		).toEqual(true);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isDraftNode: true
+				})
+			)
+		).toEqual(true);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isDraftNode: false
+				})
+			)
+		).toEqual(false);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isDraftNode: false,
+					isSticky: true
+				})
+			)
+		).toEqual(true);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isSticky: true
+				})
+			)
+		).toEqual(true);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isSticky: false
+				})
+			)
+		).toEqual(false);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isContainment: true
+				})
+			)
+		).toEqual(false);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isContainment: true,
+					isContainmentDraftNode: true
+				})
+			)
+		).toEqual(true);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isContainment: true,
+					isContainmentDraftNode: false
+				})
+			)
+		).toEqual(false);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isContainment: true,
+					isContainmentDraftRoot: true
+				})
+			)
+		).toEqual(true);
+
+		expect(
+			isDraftOrStickySupported(
+				generateMockConverterContext({
+					isContainment: true,
+					isContainmentDraftRoot: false
+				})
+			)
+		).toEqual(false);
+	});
+});
+
+describe("Table Converter - Standard actions - Get Context - New Action", function() {
+	beforeAll(async function() {
+		const sMetadataUrlNoOa = compileCDS(path.join(__dirname, "../data/TableNewActionNoOperationAvailable.cds"));
+		const metaModelNoOa = await getMetaModel(sMetadataUrlNoOa);
+		convertedTypesNoOa = convertTypes(metaModelNoOa);
+
+		const sMetadataUrlOaFalse = compileCDS(path.join(__dirname, "../data/TableNewActionOperationAvailableFalse.cds"));
+		const metaModelOaFalse = await getMetaModel(sMetadataUrlOaFalse);
+		convertedTypesOaFalse = convertTypes(metaModelOaFalse);
+
+		const sMetadataUrlOaOnSticky = compileCDS(path.join(__dirname, "../data/TableNewActionOperationAvailableSticky.cds"));
+		const metaModelOaOnSticky = await getMetaModel(sMetadataUrlOaOnSticky);
+		convertedTypesOaOnSticky = convertTypes(metaModelOaOnSticky);
+
+		NEW_ACTION_NO_OA = getConverterContextForTest(convertedTypesNoOa, {
+			entitySet: "TestEntity",
+			converterType: TemplateType.ListReport
+		});
+		NEW_ACTION_OA_FALSE = getConverterContextForTest(convertedTypesOaFalse, {
+			entitySet: "TestEntity",
+			converterType: TemplateType.ListReport
+		});
+
+		NEW_ACTION_OA_ON_STICKY = getConverterContextForTest(convertedTypesOaOnSticky, {
+			entitySet: "TestEntity",
+			converterType: TemplateType.ListReport
+		});
+	});
+
+	it("No newAction is set", () => {
+		const action = getNewAction(BASIC_CONTEXT_LR);
+		expect(action).toEqual(undefined);
+	});
+
+	it("No OperationAvailable is set", () => {
+		const action = getNewAction(NEW_ACTION_NO_OA);
+		expect(action.name).toEqual("sap.fe.test.JestService.myNewAction");
+		expect(action.available).toEqual(constant(true));
+	});
+
+	it("OperationAvailable set to true", () => {
+		const action = getNewAction(NEW_ACTION_OA_TRUE);
+		expect(action.name).toEqual("sap.fe.test.JestService.myNewAction");
+		expect(action.available).toEqual(constant(true));
+	});
+
+	it("OperationAvailable set to false", () => {
+		const action = getNewAction(NEW_ACTION_OA_FALSE);
+		expect(action.name).toEqual("sap.fe.test.JestService.myNewAction");
+		expect(action.available).toEqual(constant(false));
+	});
+
+	it("OperationAvailable set on sticky entitySet", () => {
+		const action = getNewAction(NEW_ACTION_OA_ON_STICKY);
+		expect(action.name).toEqual("sap.fe.test.JestService.myNewAction");
+		expect(action.available).toEqual(constant(true));
+	});
+});
+
+describe("Table Converter - Standard actions - Do we need to template the insert/update actions", function() {
+	it("Depends only of create visibility, external create and draft/sticky mode", () => {
+		expect(
+			getInsertUpdateActionsTemplating(
+				{
+					isExternalCreateConfigured: true
+				} as any,
+				true,
+				true
+			)
+		).toEqual(false);
+
+		expect(
+			getInsertUpdateActionsTemplating(
+				{
+					isExternalCreateConfigured: true
+				} as any,
+				true,
+				false
+			)
+		).toEqual(true);
+
+		expect(
+			getInsertUpdateActionsTemplating(
+				{
+					isExternalCreateConfigured: false
+				} as any,
+				true,
+				false
+			)
+		).toEqual(true);
+
+		expect(
+			getInsertUpdateActionsTemplating(
+				{
+					isExternalCreateConfigured: true
+				} as any,
+				false,
+				false
+			)
+		).toEqual(true);
+
+		expect(
+			getInsertUpdateActionsTemplating(
+				{
+					isExternalCreateConfigured: false
+				} as any,
+				false,
+				false
+			)
+		).toEqual(false);
+	});
+});
+
+describe("Table Converter - Standard actions - Create visibility ", function() {
+	it("If it's statically not insertable -> Create is not visible", () => {
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: NOT_INSERTABLE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: NOT_INSERTABLE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: NOT_INSERTABLE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: NOT_INSERTABLE
+				} as any)
+			)
+		).toEqual("{ui>/isEditable}");
+	});
+
+	it("If Create is statically hidden -> Create is not visible", () => {
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("false");
+	});
+
+	it("Otherwise if the Create mode is external -> Create is visible", () => {
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("{ui>/isEditable}");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any)
+			)
+		).toEqual("{ui>/isEditable}");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: DYNAMIC_HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenCreate}}");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: DYNAMIC_HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenCreate} && %{ui>/isEditable}}");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: DYNAMIC_HIDDEN_CREATE,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenCreate}}");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: true,
+					hiddenAnnotation: DYNAMIC_HIDDEN_CREATE,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenCreate} && %{ui>/isEditable}}");
+	});
+
+	it("If we're on the list report -> Create is visible", () => {
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: DYNAMIC_HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenCreate}}");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: DYNAMIC_HIDDEN_CREATE,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenCreate}}");
+	});
+
+	it("Otherwise this depends on the value of the the UI.IsEditable", () => {
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual(compileBinding(UI.IsEditable));
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any)
+			)
+		).toEqual(compileBinding(UI.IsEditable));
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: DYNAMIC_HIDDEN_CREATE,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenCreate} && %{ui>/isEditable}}");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_OP, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: DYNAMIC_HIDDEN_CREATE,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenCreate} && %{ui>/isEditable}}");
+	});
+
+	it("If a New Action exists Create depends on the Core.OperationAvailable annotation", () => {
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					newAction: AVAILABLE_NEW_ACTION,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					newAction: AVAILABLE_NEW_ACTION,
+					restrictions: NOT_INSERTABLE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					newAction: DYNAMIC_NEW_ACTION,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					newAction: DYNAMIC_NEW_ACTION,
+					restrictions: NOT_INSERTABLE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					newAction: NOT_AVAILABLE_NEW_ACTION,
+					restrictions: INSERTABLE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getCreateVisibility(BASIC_CONTEXT_LR, {
+					isExternalCreateConfigured: false,
+					hiddenAnnotation: NOT_HIDDEN_CREATE,
+					newAction: NOT_AVAILABLE_NEW_ACTION,
+					restrictions: NOT_INSERTABLE
+				} as any)
+			)
+		).toEqual("false");
+	});
+});
+
+describe("Table Converter - Standard actions - Create Templating ", function() {
+	it("Create is not visible", () => {
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.Inline
+					},
+					isExternalCreateConfigured: false,
+					restrictions: INSERTABLE
+				} as any,
+				constant(false)
+			)
+		).toEqual(constant(false));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.CreationRow
+					},
+					isExternalCreateConfigured: false,
+					restrictions: INSERTABLE
+				} as any,
+				constant(false)
+			)
+		).toEqual(constant(false));
+	});
+
+	it("Create visibility is dynamic", () => {
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.CreationRow
+					},
+					isExternalCreateConfigured: false,
+					restrictions: INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(false));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.Inline
+					},
+					isExternalCreateConfigured: false,
+					newAction: NOT_AVAILABLE_NEW_ACTION,
+					restrictions: INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(false));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.NewPage
+					},
+					isExternalCreateConfigured: false,
+					newAction: AVAILABLE_NEW_ACTION,
+					restrictions: INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(true));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.NewPage
+					},
+					isExternalCreateConfigured: false,
+					newAction: AVAILABLE_NEW_ACTION,
+					restrictions: NOT_INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(false));
+	});
+
+	it("Create is visible", () => {
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.CreationRow
+					},
+					isExternalCreateConfigured: false,
+					restrictions: INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(false));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.Inline
+					},
+					isExternalCreateConfigured: false,
+					newAction: NOT_AVAILABLE_NEW_ACTION,
+					restrictions: INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(false));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.NewPage
+					},
+					isExternalCreateConfigured: false,
+					newAction: AVAILABLE_NEW_ACTION,
+					restrictions: INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(true));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.NewPage
+					},
+					isExternalCreateConfigured: false,
+					newAction: AVAILABLE_NEW_ACTION,
+					restrictions: NOT_INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(false));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.NewPage
+					},
+					isExternalCreateConfigured: false,
+					newAction: AVAILABLE_NEW_ACTION,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(true));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.NewPage
+					},
+					isExternalCreateConfigured: true,
+					restrictions: DYNAMIC_INSERTABLE
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(true));
+
+		expect(
+			getCreateTemplating(
+				{
+					tableManifestConfiguration: {
+						creationMode: CreationMode.NewPage
+					},
+					isExternalCreateConfigured: true,
+					restrictions: DYNAMIC_INSERTABLE_ONLY_ON_CURRENT
+				} as any,
+				DYNAMIC_CREATE_VISIBILITY
+			)
+		).toEqual(constant(true));
+	});
+});
+
+describe("Table Converter - Standard actions - Create enablement", function() {
+	it("Create is not visible", () => {
+		expect(
+			compileBinding(
+				getCreateEnablement(
+					BASIC_CONTEXT_LR,
+					{
+						collectionPath: "/TestEntity",
+						restrictions: INSERTABLE
+					} as any,
+					constant(false)
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("Create is visible", () => {
+		expect(
+			compileBinding(
+				getCreateEnablement(
+					BASIC_CONTEXT_LR,
+					{
+						collectionPath: "/TestEntity",
+						restrictions: INSERTABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateEnablement(
+					BASIC_CONTEXT_ALP,
+					{
+						collectionPath: "/TestEntity",
+						restrictions: INSERTABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getCreateEnablement(
+					BASIC_CONTEXT_OP,
+					{
+						collectionPath: "/TestEntityWithNavigation/_navigation",
+						restrictions: INSERTABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("{= %{ui>/editMode} === 'Editable'}");
+
+		expect(
+			compileBinding(
+				getCreateEnablement(
+					BASIC_CONTEXT_OP,
+					{
+						collectionPath: "/TestEntityWithNavigation/_navigation",
+						restrictions: NOT_INSERTABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("Create visibility is dynamic", () => {
+		expect(
+			compileBinding(
+				getCreateEnablement(
+					BASIC_CONTEXT_LR,
+					{
+						collectionPath: "/TestEntity",
+						restrictions: INSERTABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual("{= %{dummyExpression} !== false}");
+
+		expect(
+			compileBinding(
+				getCreateEnablement(
+					BASIC_CONTEXT_ALP,
+					{
+						collectionPath: "/TestEntity",
+						restrictions: INSERTABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual("{= %{dummyExpression} !== false}");
+
+		expect(
+			compileBinding(
+				getCreateEnablement(
+					BASIC_CONTEXT_OP,
+					{
+						collectionPath: "/TestEntityWithNavigation/_navigation",
+						restrictions: INSERTABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual("{= %{dummyExpression} !== false && %{ui>/editMode} === 'Editable'}");
+
+		expect(
+			compileBinding(
+				getCreateEnablement(
+					BASIC_CONTEXT_OP,
+					{
+						collectionPath: "/TestEntityWithNavigation/_navigation",
+						restrictions: NOT_INSERTABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual("false");
+	});
+});
+
+describe("Table Converter - Standard actions - Delete visibility ", function() {
+	it("Multi visualizations or ALP-> not visible (prerequisite)", () => {
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_LR, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: true,
+					restrictions: DELETABLE,
+					hiddenAnnotation: NOT_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("false");
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_ALP, {
+					isViewWithMultipleVisualizations: true,
+					restrictions: DELETABLE,
+					hiddenAnnotation: NOT_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("false");
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_ALP, {
+					isViewWithMultipleVisualizations: false,
+					restrictions: DELETABLE,
+					hiddenAnnotation: NOT_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("false");
+	});
+
+	it("on List Report", () => {
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_LR, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DELETABLE,
+					hiddenAnnotation: NOT_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_LR, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DELETABLE,
+					hiddenAnnotation: HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_LR, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: NOT_DELETABLE,
+					hiddenAnnotation: NOT_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_LR, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DELETABLE,
+					hiddenAnnotation: DYNAMIC_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenDelete}}");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_LR, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DYNAMIC_DELETABLE,
+					hiddenAnnotation: NOT_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_LR, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DYNAMIC_DELETABLE,
+					hiddenAnnotation: DYNAMIC_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenDelete}}");
+	});
+
+	it("on ObjectPage", () => {
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_OP, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DELETABLE,
+					hiddenAnnotation: NOT_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("{= %{ui>/editMode} === 'Editable'}");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_OP, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DELETABLE,
+					hiddenAnnotation: HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_OP, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: NOT_DELETABLE,
+					hiddenAnnotation: NOT_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_OP, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DELETABLE,
+					hiddenAnnotation: DYNAMIC_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenDelete} && %{ui>/editMode} === 'Editable'}");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_OP, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DYNAMIC_DELETABLE,
+					hiddenAnnotation: NOT_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("{= %{ui>/editMode} === 'Editable'}");
+
+		expect(
+			compileBinding(
+				getDeleteVisibility(BASIC_CONTEXT_OP, {
+					isDraftOrStickySupported: true,
+					isViewWithMultipleVisualizations: false,
+					restrictions: DYNAMIC_DELETABLE,
+					hiddenAnnotation: DYNAMIC_HIDDEN_DELETE
+				} as any)
+			)
+		).toEqual("{= !%{SomeDynamicHiddenDelete} && %{ui>/editMode} === 'Editable'}");
+	});
+});
+
+describe("Table Converter - Standard actions - Delete enablement", function() {
+	it("Delete is not visible", () => {
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_LR,
+					{
+						restrictions: DELETABLE
+					} as any,
+					constant(false)
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_OP,
+					{
+						restrictions: DELETABLE
+					} as any,
+					constant(false)
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("Delete is visible", () => {
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_LR,
+					{
+						restrictions: DYNAMIC_DELETABLE_ONLY_ON_CURRENT
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual(
+			"{= ((%{internal>deletableContexts} !== undefined && (%{internal>deletableContexts}.length) > 0) || (%{internal>unSavedContexts} !== undefined && (%{internal>unSavedContexts}.length) > 0)) && %{internal>deleteEnabled}}"
+		);
+
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_LR,
+					{
+						restrictions: DELETABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual(
+			"{= ((%{internal>deletableContexts} !== undefined && (%{internal>deletableContexts}.length) > 0) || (%{internal>unSavedContexts} !== undefined && (%{internal>unSavedContexts}.length) > 0)) && %{internal>deleteEnabled}}"
+		);
+
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_OP,
+					{
+						restrictions: DYNAMIC_DELETABLE_ONLY_ON_CURRENT
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual(
+			"{= ((%{internal>deletableContexts} !== undefined && (%{internal>deletableContexts}.length) > 0) || (%{internal>unSavedContexts} !== undefined && (%{internal>unSavedContexts}.length) > 0)) && %{internal>deleteEnabled}}"
+		);
+
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_OP,
+					{
+						restrictions: DYNAMIC_DELETABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("{= %{internal>numberOfSelectedContexts} !== 0 && %{SomeDynamicDeletable}}");
+	});
+
+	it("Delete visibility is dynamic", () => {
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_LR,
+					{
+						restrictions: DYNAMIC_DELETABLE_ONLY_ON_CURRENT
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual(
+			"{= %{dummyExpression} !== false && ((%{internal>deletableContexts} !== undefined && (%{internal>deletableContexts}.length) > 0) || (%{internal>unSavedContexts} !== undefined && (%{internal>unSavedContexts}.length) > 0)) && %{internal>deleteEnabled}}"
+		);
+
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_LR,
+					{
+						restrictions: DELETABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual(
+			"{= %{dummyExpression} !== false && ((%{internal>deletableContexts} !== undefined && (%{internal>deletableContexts}.length) > 0) || (%{internal>unSavedContexts} !== undefined && (%{internal>unSavedContexts}.length) > 0)) && %{internal>deleteEnabled}}"
+		);
+
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_OP,
+					{
+						restrictions: DYNAMIC_DELETABLE_ONLY_ON_CURRENT
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual(
+			"{= %{dummyExpression} !== false && ((%{internal>deletableContexts} !== undefined && (%{internal>deletableContexts}.length) > 0) || (%{internal>unSavedContexts} !== undefined && (%{internal>unSavedContexts}.length) > 0)) && %{internal>deleteEnabled}}"
+		);
+
+		expect(
+			compileBinding(
+				getDeleteEnablement(
+					BASIC_CONTEXT_OP,
+					{
+						restrictions: DYNAMIC_DELETABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual("{= %{dummyExpression} !== false && %{internal>numberOfSelectedContexts} !== 0 && %{SomeDynamicDeletable}}");
+	});
+});
+
+describe("Table Converter - Standard actions - Paste visibility ", function() {
+	it("Paste disabled into the manifest", () => {
+		expect(
+			compileBinding(
+				getPasteVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enablePaste: false
+						},
+						restrictions: INSERTABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("Paste should be always disabled if we are not on Object Page", () => {
+		expect(
+			compileBinding(
+				getPasteVisibility(
+					BASIC_CONTEXT_LR,
+					{
+						tableManifestConfiguration: {
+							enablePaste: true
+						},
+						restrictions: INSERTABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getPasteVisibility(
+					BASIC_CONTEXT_ALP,
+					{
+						tableManifestConfiguration: {
+							enablePaste: true
+						},
+						restrictions: INSERTABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("Paste on Object Page depends of Create visibility and insertable restrictions", () => {
+		expect(
+			compileBinding(
+				getPasteVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enablePaste: true
+						},
+						restrictions: DYNAMIC_INSERTABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual("{= %{dummyExpression} === true && %{SomeDynamicInsertable}}");
+
+		expect(
+			compileBinding(
+				getPasteVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enablePaste: true
+						},
+						restrictions: DYNAMIC_INSERTABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("{SomeDynamicInsertable}");
+
+		expect(
+			compileBinding(
+				getPasteVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enablePaste: true
+						},
+						restrictions: INSERTABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getPasteVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enablePaste: true
+						},
+						restrictions: INSERTABLE
+					} as any,
+					constant(false)
+				)
+			)
+		).toEqual("false");
+	});
+});
+
+describe("Table Converter - Standard actions - Default Templating ", function() {
+	it("it should be only depending of action visibility", () => {
+		expect(getDefaultTemplating(constant(true))).toEqual(constant(true));
+
+		expect(getDefaultTemplating(constant(false))).toEqual(constant(false));
+
+		expect(getDefaultTemplating(bindingExpression("SomeDynamicExpression"))).toEqual(constant(true));
+	});
+});
+
+describe("Table Converter - Standard actions - MassEdit visibility ", function() {
+	it("MassEdit disabled into the manifest or not provided", () => {
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_LR,
+					{
+						tableManifestConfiguration: {},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: false
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_LR,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: false
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("MassEdit should be always disabled if restriction is constant", () => {
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: NOT_UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_LR,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: NOT_UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("MassEdit should be always disabled if selectionMode set to Single or selectionLimit < 2", () => {
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: UPDATABLE
+					} as any,
+					SelectionMode.Single
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true,
+							selectionLimit: 1
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_LR,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true,
+							selectionLimit: 1
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("MassEdit should be always disabled if we are not on Object Page/ListReport", () => {
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_ALP,
+					{
+						tableManifestConfiguration: {
+							enablePaste: true
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("Otherwise on Object Page, it should depends of hiddenAnnotation", () => {
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: DYNAMIC_UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("{= %{ui>/isEditable} === true}");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true
+						},
+						hiddenAnnotation: HIDDEN_UPDATE,
+						restrictions: DYNAMIC_UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_OP,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true
+						},
+						hiddenAnnotation: DYNAMIC_HIDDEN_UPDATE,
+						restrictions: DYNAMIC_UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("{= %{ui>/isEditable} === true && !%{SomeDynamicHiddenUpdate}}");
+	});
+
+	it("Otherwise in ListReport, it should be visible", () => {
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_LR,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true
+						},
+						hiddenAnnotation: NOT_HIDDEN_UPDATE,
+						restrictions: DYNAMIC_UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_LR,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true
+						},
+						hiddenAnnotation: HIDDEN_UPDATE,
+						restrictions: DYNAMIC_UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("true");
+
+		expect(
+			compileBinding(
+				getMassEditVisibility(
+					BASIC_CONTEXT_LR,
+					{
+						tableManifestConfiguration: {
+							enableMassEdit: true
+						},
+						hiddenAnnotation: DYNAMIC_HIDDEN_UPDATE,
+						restrictions: DYNAMIC_UPDATABLE
+					} as any,
+					SelectionMode.Multi
+				)
+			)
+		).toEqual("true");
+	});
+});
+
+describe("Table Converter - Standard actions - MassEdit Enablement ", function() {
+	it("MassEdit is not visible", () => {
+		expect(
+			compileBinding(
+				getMassEditEnablement(
+					{
+						restrictions: UPDATABLE
+					} as any,
+					constant(false)
+				)
+			)
+		).toEqual("false");
+	});
+
+	it("MassEdit is visible", () => {
+		expect(
+			compileBinding(
+				getMassEditEnablement(
+					{
+						restrictions: UPDATABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("{= %{internal>numberOfSelectedContexts} >= 2}");
+
+		expect(
+			compileBinding(
+				getMassEditEnablement(
+					{
+						restrictions: NOT_UPDATABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getMassEditEnablement(
+					{
+						restrictions: DYNAMIC_UPDATABLE
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("{= %{internal>numberOfSelectedContexts} >= 2 && %{SomeDynamicUpdatable}}");
+
+		expect(
+			compileBinding(
+				getMassEditEnablement(
+					{
+						restrictions: DYNAMIC_UPDATABLE_ONLY_ON_CURRENT
+					} as any,
+					constant(true)
+				)
+			)
+		).toEqual("{= %{internal>numberOfSelectedContexts} >= 2 && (%{internal>updatableContexts}.length) >= 2}");
+	});
+
+	it("MassEdit visibility is dynamic", () => {
+		expect(
+			compileBinding(
+				getMassEditEnablement(
+					{
+						restrictions: UPDATABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual("{= %{dummyExpression} !== false && %{internal>numberOfSelectedContexts} >= 2}");
+
+		expect(
+			compileBinding(
+				getMassEditEnablement(
+					{
+						restrictions: NOT_UPDATABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual("false");
+
+		expect(
+			compileBinding(
+				getMassEditEnablement(
+					{
+						restrictions: DYNAMIC_UPDATABLE
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual("{= %{dummyExpression} !== false && %{internal>numberOfSelectedContexts} >= 2 && %{SomeDynamicUpdatable}}");
+
+		expect(
+			compileBinding(
+				getMassEditEnablement(
+					{
+						restrictions: DYNAMIC_UPDATABLE_ONLY_ON_CURRENT
+					} as any,
+					DUMMY_DYNAMIC_BINDING
+				)
+			)
+		).toEqual(
+			"{= %{dummyExpression} !== false && %{internal>numberOfSelectedContexts} >= 2 && (%{internal>updatableContexts}.length) >= 2}"
+		);
+	});
+});
+
+describe("Table Converter - Standard actions - Gathering data from functions", function() {
+	//embedded functions are tested into previous tests so here we just check that the following functions collect the data
+
+	it("Generate Context for the standard actions", () => {
+		let context = generateStandardActionsContext(
+			BASIC_CONTEXT_LR_DYNAMIC_HIDDEN,
+			{
+				create: {
+					outbound: "outbound",
+					outboundDetail: {
+						semanticObject: "dummy",
+						action: "dummy"
+					}
+				}
+			},
+			{
+				dummyConfig: "dummy"
+			} as any,
+			{
+				primary: "dummyViewConfigPrimary",
+				secondary: "dummyViewConfigSecondary"
+			} as any
+		);
+		expect(context.collectionPath).toEqual("/TestDynamicActionsHidden");
+		expect(context.hiddenAnnotation).toEqual({
+			"create": bindingExpression("hiddenCreate"),
+			"delete": bindingExpression("hiddenDelete"),
+			"update": bindingExpression("hiddenUpdate")
+		});
+		expect(context.isDraftOrStickySupported).toEqual(false);
+		expect(context.isExternalCreateConfigured).toEqual(true);
+		expect(context.isViewWithMultipleVisualizations).toEqual(true);
+		expect(context.newAction).toEqual(undefined);
+		expect(context.restrictions).toEqual({
+			"isDeletable": { "expression": constant(true), "isOnlyCurrentEntityExpression": false },
+			"isInsertable": { "expression": constant(true), "isOnlyCurrentEntityExpression": false },
+			"isUpdatable": { "expression": constant(true), "isOnlyCurrentEntityExpression": false }
+		});
+		expect(context.tableManifestConfiguration).toEqual({ "dummyConfig": "dummy" });
+
+		context = generateStandardActionsContext(NEW_ACTION_OA_TRUE, {}, { dummyConfig: "dummy" } as any, {} as any);
+
+		expect(context.collectionPath).toEqual("/TestEntity");
+		expect(context.hiddenAnnotation).toEqual({ "create": constant(false), "delete": constant(false), "update": constant(false) });
+		expect(context.isDraftOrStickySupported).toEqual(true);
+		expect(context.isExternalCreateConfigured).toEqual(false);
+		expect(context.isViewWithMultipleVisualizations).toEqual(false);
+		expect(context.newAction).toEqual({ "available": constant(true), "name": "sap.fe.test.JestService.myNewAction" });
+		expect(context.restrictions).toEqual({
+			"isDeletable": { "expression": constant(true), "isOnlyCurrentEntityExpression": false },
+			"isInsertable": { "expression": constant(false), "isOnlyCurrentEntityExpression": true },
+			"isUpdatable": { "expression": constant(true), "isOnlyCurrentEntityExpression": false }
+		});
+		expect(context.tableManifestConfiguration).toEqual({ "dummyConfig": "dummy" });
+	});
+
+	it("Generate binding expression for Action Create", () => {
+		const bindingExpressions = getStandardActionCreate(BASIC_CONTEXT_OP, BASIC_ACTION_CONTEXT);
+		expect(bindingExpressions.isTemplated).toEqual("true");
+		expect(bindingExpressions.enabled).toEqual("{= %{ui>/isEditable} !== false}");
+		expect(bindingExpressions.visible).toEqual("{ui>/isEditable}");
+	});
+
+	it("Generate binding expression for Action Delete", () => {
+		const bindingExpressions = getStandardActionDelete(BASIC_CONTEXT_OP, BASIC_ACTION_CONTEXT);
+		expect(bindingExpressions.isTemplated).toEqual("true");
+		expect(bindingExpressions.enabled).toEqual(
+			"{= (%{ui>/editMode} === 'Editable') !== false && %{internal>numberOfSelectedContexts} !== 0}"
+		);
+		expect(bindingExpressions.visible).toEqual("{= %{ui>/editMode} === 'Editable'}");
+	});
+
+	it("Generate binding expression for Action Paste", () => {
+		const bindingExpressions = getStandardActionPaste(BASIC_CONTEXT_OP, BASIC_ACTION_CONTEXT);
+		expect(bindingExpressions.isTemplated).toEqual("true");
+		expect(bindingExpressions.enabled).toEqual("{= %{ui>/isEditable} === true}");
+		expect(bindingExpressions.visible).toEqual("{= %{ui>/isEditable} === true}");
+	});
+
+	it("Generate binding expression for Mass Edit", () => {
+		let bindingExpressions = getStandardActionMassEdit(BASIC_CONTEXT_OP, BASIC_ACTION_CONTEXT, "Multi");
+		expect(bindingExpressions.isTemplated).toEqual("false");
+		expect(bindingExpressions.enabled).toEqual("false");
+		expect(bindingExpressions.visible).toEqual("false");
+
+		bindingExpressions = getStandardActionMassEdit(BASIC_CONTEXT_OP, BASIC_MASS_EDIT_ACTION_CONTEXT, "Multi");
+		expect(bindingExpressions.isTemplated).toEqual("true");
+		expect(bindingExpressions.enabled).toEqual(
+			"{= (%{ui>/isEditable} === true) !== false && %{internal>numberOfSelectedContexts} >= 2}"
+		);
+		expect(bindingExpressions.visible).toEqual("{= %{ui>/isEditable} === true}");
+	});
+});