@sap/open.fe 1.98.0 → 1.99.0

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

@@ -14,6 +14,7 @@ import {
 } from "sap/fe/core/converters/templates/ListReportConverter";
 import { getSelectionFields } from "sap/fe/core/converters/controls/ListReport/FilterBar";
 import { TableVisualization } from "sap/fe/core/converters/controls/Common/Table";
+import { ChartVisualization } from "sap/fe/core/converters/controls/Common/Chart";
 
 describe("ListReportConverter", function() {
 	let convertedTypes: ConverterOutput;
@@ -103,6 +104,52 @@ describe("ListReportConverter", function() {
 			expect(convertedPage.useSemanticDateRange).toEqual(false);
 		}
 	);
+
+	it(
+		"#convertPage - will set hideFilterBar",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-21061"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "DraftEntity",
+				hideFilterBar: true
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.hideFilterBar).toEqual(true);
+			// filter bar id should not be part of the target control ids of VM if there is no filter bar
+			expect(convertedPage.variantManagement.targetControlIds.includes("fe::FilterBar")).toBe(false);
+		}
+	);
+
+	it(
+		"#convertPage - will set hideFilterBar false",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-21061"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "DraftEntity",
+				hideFilterBar: false
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.hideFilterBar).toEqual(false);
+			// filter bar id should be part of the target control ids of VM if there is a filter bar
+			expect(convertedPage.variantManagement.targetControlIds.includes("fe::FilterBar")).toBe(true);
+		}
+	);
 	it("#convertPage - will set showPinnableToggle to true when the LR table is responsive", function() {
 		const converterContext = getConverterContextForTest(convertedTypes, {
 			converterType: TemplateType.ListReport,
@@ -413,12 +460,12 @@ describe("ListReportConverter with analytical service", function() {
 					paths: [
 						{
 							key: "tab1",
-							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#forEntity1"
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity1"
 						},
 						{
 							key: "tab2",
 							entitySet: "TestEntity3",
-							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#forEntity3"
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity3"
 						}
 					]
 				},
@@ -469,12 +516,12 @@ describe("ListReportConverter with analytical service", function() {
 					paths: [
 						{
 							key: "tab1",
-							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#forEntity4"
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity4"
 						},
 						{
 							key: "tab2",
 							entitySet: "TestEntity3",
-							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#forEntity3"
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity3"
 						}
 					]
 				},
@@ -525,12 +572,12 @@ describe("ListReportConverter with analytical service", function() {
 					paths: [
 						{
 							key: "tab1",
-							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#forEntity4"
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity4"
 						},
 						{
 							key: "tab2",
 							entitySet: "TestEntity3",
-							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#forEntity3"
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity3"
 						}
 					]
 				},
@@ -562,4 +609,420 @@ describe("ListReportConverter with analytical service", function() {
 			expect(tableViz2.enableAnalyticsSearch).toEqual(undefined); // Search works for the second table
 		}
 	);
+
+	it(
+		"#convertPage - will show basic search with table and chart if only table allows search",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-19687"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "TestEntity",
+				views: {
+					paths: [
+						{
+							key: "tab1",
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity1"
+						},
+						{
+							key: "tab2",
+							entitySet: "TestEntity3",
+							annotationPath: "com.sap.vocabularies.UI.v1.PresentationVariant#chartForEntity3"
+						}
+					]
+				},
+				"controlConfiguration": {
+					"@com.sap.vocabularies.UI.v1.LineItem#forEntity1": {
+						"tableSettings": {
+							"type": "AnalyticalTable"
+						}
+					}
+				}
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.filterBar.hideBasicSearch).toEqual(false);
+
+			expect(convertedPage.views).toHaveLength(2);
+			const visualizations1 = (convertedPage.views[0] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations1).toHaveLength(1);
+			const tableViz1 = visualizations1[0] as TableVisualization;
+			expect(tableViz1.enableAnalyticsSearch).toEqual(true);
+
+			const visualizations2 = (convertedPage.views[1] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations2).toHaveLength(1);
+			const chartViz2 = visualizations2[0] as ChartVisualization;
+			expect(chartViz2.applySupported.enableSearch).toEqual(false); // The chart doesn't allow search
+		}
+	);
+
+	it(
+		"#convertPage - will show basic search with table and chart if only chart allows search (no list of allowed transformations)",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-19687"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "TestEntity3",
+				views: {
+					paths: [
+						{
+							key: "tab1",
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity3"
+						},
+						{
+							key: "tab2",
+							entitySet: "TestEntity",
+							annotationPath: "com.sap.vocabularies.UI.v1.PresentationVariant#chartForEntity1"
+						}
+					]
+				},
+				"controlConfiguration": {
+					"@com.sap.vocabularies.UI.v1.LineItem#forEntity3": {
+						"tableSettings": {
+							"type": "AnalyticalTable"
+						}
+					}
+				}
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.filterBar.hideBasicSearch).toEqual(false);
+
+			expect(convertedPage.views).toHaveLength(2);
+			const visualizations1 = (convertedPage.views[0] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations1).toHaveLength(1);
+			const tableViz1 = visualizations1[0] as TableVisualization;
+			expect(tableViz1.enableAnalyticsSearch).toEqual(false); // The table doesn't allow search
+
+			const visualizations2 = (convertedPage.views[1] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations2).toHaveLength(1);
+			const chartViz2 = visualizations2[0] as ChartVisualization;
+			expect(chartViz2.applySupported.enableSearch).toEqual(true); // The chart allows search
+		}
+	);
+
+	it(
+		"#convertPage - will show basic search with table and chart if only chart allows search (allowed transformations contains search)",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-19687"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "TestEntity3",
+				views: {
+					paths: [
+						{
+							key: "tab1",
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity3"
+						},
+						{
+							key: "tab2",
+							entitySet: "TestEntity2",
+							annotationPath: "com.sap.vocabularies.UI.v1.PresentationVariant#chartForEntity2"
+						}
+					]
+				},
+				"controlConfiguration": {
+					"@com.sap.vocabularies.UI.v1.LineItem#forEntity3": {
+						"tableSettings": {
+							"type": "AnalyticalTable"
+						}
+					}
+				}
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.filterBar.hideBasicSearch).toEqual(false);
+
+			expect(convertedPage.views).toHaveLength(2);
+			const visualizations1 = (convertedPage.views[0] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations1).toHaveLength(1);
+			const tableViz1 = visualizations1[0] as TableVisualization;
+			expect(tableViz1.enableAnalyticsSearch).toEqual(false); // The table doesn't allow search
+
+			const visualizations2 = (convertedPage.views[1] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations2).toHaveLength(1);
+			const chartViz2 = visualizations2[0] as ChartVisualization;
+			expect(chartViz2.applySupported.enableSearch).toEqual(true); // The chart allows search
+		}
+	);
+
+	it(
+		"#convertPage - will show basic search with one table and several charts if one chart allows search",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-19687"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "TestEntity3",
+				views: {
+					paths: [
+						{
+							key: "tab1",
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity3"
+						},
+						{
+							key: "tab2",
+							entitySet: "TestEntity2",
+							annotationPath: "com.sap.vocabularies.UI.v1.PresentationVariant#chartForEntity2"
+						},
+						{
+							key: "tab3",
+							entitySet: "TestEntity3",
+							annotationPath: "com.sap.vocabularies.UI.v1.PresentationVariant#chartForEntity3"
+						}
+					]
+				},
+				"controlConfiguration": {
+					"@com.sap.vocabularies.UI.v1.LineItem#forEntity3": {
+						"tableSettings": {
+							"type": "AnalyticalTable"
+						}
+					}
+				}
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.filterBar.hideBasicSearch).toEqual(false);
+
+			expect(convertedPage.views).toHaveLength(3);
+			const visualizations1 = (convertedPage.views[0] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations1).toHaveLength(1);
+			const tableViz1 = visualizations1[0] as TableVisualization;
+			expect(tableViz1.enableAnalyticsSearch).toEqual(false); // The table doesn't allow search
+
+			const visualizations2 = (convertedPage.views[1] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations2).toHaveLength(1);
+			const chartViz2 = visualizations2[0] as ChartVisualization;
+			expect(chartViz2.applySupported.enableSearch).toEqual(true); // The first chart allows search
+
+			const visualizations3 = (convertedPage.views[2] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations3).toHaveLength(1);
+			const chartViz3 = visualizations3[0] as ChartVisualization;
+			expect(chartViz3.applySupported.enableSearch).toEqual(false); // The second chart doesn't allow search
+		}
+	);
+
+	it(
+		"#convertPage - will not show basic search with table and chart if none allows search",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-19687"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "TestEntity3",
+				views: {
+					paths: [
+						{
+							key: "tab1",
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity3"
+						},
+						{
+							key: "tab2",
+							annotationPath: "com.sap.vocabularies.UI.v1.PresentationVariant#chartForEntity3"
+						}
+					]
+				},
+				"controlConfiguration": {
+					"@com.sap.vocabularies.UI.v1.LineItem#forEntity3": {
+						"tableSettings": {
+							"type": "AnalyticalTable"
+						}
+					}
+				}
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.filterBar.hideBasicSearch).toEqual(true);
+
+			expect(convertedPage.views).toHaveLength(2);
+			const visualizations1 = (convertedPage.views[0] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations1).toHaveLength(1);
+			const tableViz1 = visualizations1[0] as TableVisualization;
+			expect(tableViz1.enableAnalyticsSearch).toEqual(false); // The table doesn't allow search
+
+			const visualizations2 = (convertedPage.views[1] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations2).toHaveLength(1);
+			const chartViz2 = visualizations2[0] as ChartVisualization;
+			expect(chartViz2.applySupported.enableSearch).toEqual(false); // The chart doesn't allow search
+		}
+	);
+});
+
+describe("ListReportConverter with analytical service annotated at container level (ApplySupportedDefault)", function() {
+	let convertedTypes: ConverterOutput;
+
+	beforeAll(async function() {
+		const sMetadataUrl = compileCDS(path.join(__dirname, "../data/AnalyticalService2.cds"));
+		const metaModel = await getMetaModel(sMetadataUrl);
+		convertedTypes = convertTypes(metaModel);
+	});
+
+	it(
+		"#convertPage - will show basic search with analytical table when search is allowed at container level",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-19687"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "TestEntity",
+				controlConfiguration: {
+					"@com.sap.vocabularies.UI.v1.LineItem": {
+						"tableSettings": {
+							"type": "AnalyticalTable"
+						}
+					}
+				}
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.filterBar.hideBasicSearch).toEqual(false);
+
+			expect(convertedPage.views).toHaveLength(1);
+			const visualizations = (convertedPage.views[0] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations).toHaveLength(1);
+			const tableViz = visualizations[0] as TableVisualization;
+			expect(tableViz.enableAnalyticsSearch).toEqual(true);
+		}
+	);
+
+	it(
+		"#convertPage - will not show basic search with analytical table search is not allowed at the entity level",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-19687"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "TestEntity2",
+				controlConfiguration: {
+					"@com.sap.vocabularies.UI.v1.LineItem": {
+						"tableSettings": {
+							"type": "AnalyticalTable"
+						}
+					}
+				}
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.filterBar.hideBasicSearch).toEqual(true);
+
+			expect(convertedPage.views).toHaveLength(1);
+			const visualizations = (convertedPage.views[0] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations).toHaveLength(1);
+			const tableViz = visualizations[0] as TableVisualization;
+			expect(tableViz.enableAnalyticsSearch).toEqual(false);
+		}
+	);
+
+	it(
+		"#convertPage - will show basic search with a mix of tables and charts",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-19687"
+				}
+			]
+		},
+		function() {
+			const converterContext = getConverterContextForTest(convertedTypes, {
+				converterType: TemplateType.ListReport,
+				entitySet: "TestEntity",
+				views: {
+					paths: [
+						{
+							key: "tab1",
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity1"
+						},
+						{
+							key: "tab3",
+							entitySet: "TestEntity2",
+							annotationPath: "com.sap.vocabularies.UI.v1.SelectionPresentationVariant#tableForEntity2"
+						},
+						{
+							key: "tab2",
+							annotationPath: "com.sap.vocabularies.UI.v1.PresentationVariant#chartForEntity1"
+						},
+						{
+							key: "tab3",
+							entitySet: "TestEntity2",
+							annotationPath: "com.sap.vocabularies.UI.v1.PresentationVariant#chartForEntity2"
+						}
+					]
+				},
+				"controlConfiguration": {
+					"@com.sap.vocabularies.UI.v1.LineItem#forEntity1": {
+						"tableSettings": {
+							"type": "AnalyticalTable"
+						}
+					},
+					"@com.sap.vocabularies.UI.v1.LineItem#forEntity2": {
+						"tableSettings": {
+							"type": "AnalyticalTable"
+						}
+					}
+				}
+			});
+			const convertedPage = convertPage(converterContext);
+			expect(convertedPage.filterBar.hideBasicSearch).toEqual(false);
+
+			expect(convertedPage.views).toHaveLength(4);
+
+			const visualizations1 = (convertedPage.views[0] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations1).toHaveLength(1);
+			const tableViz1 = visualizations1[0] as TableVisualization;
+			expect(tableViz1.enableAnalyticsSearch).toEqual(true); // The first table allows search
+
+			const visualizations2 = (convertedPage.views[1] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations2).toHaveLength(1);
+			const chartViz2 = visualizations2[0] as TableVisualization;
+			expect(chartViz2.enableAnalyticsSearch).toEqual(false); // The second table doesn't allow search
+
+			const visualizations3 = (convertedPage.views[2] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations3).toHaveLength(1);
+			const chartViz3 = visualizations3[0] as ChartVisualization;
+			expect(chartViz3.applySupported.enableSearch).toEqual(true); // The first chart allows search
+
+			const visualizations4 = (convertedPage.views[3] as BaseSingleViewDefinition).presentation.visualizations;
+			expect(visualizations4).toHaveLength(1);
+			const chartViz4 = visualizations4[0] as ChartVisualization;
+			expect(chartViz4.applySupported.enableSearch).toEqual(false); // The second chart doesn't allow search
+		}
+	);
 });

package/packages/sap.fe.core/test/sap/fe/core/jest/converters/MetaModelConverter.spec.js

@@ -57,7 +57,7 @@ sap.ui.define(["path", "sap/fe/test/JestTemplatingHelper", "sap/fe/core/converte
       expect((_convertedType$entity2 = convertedType.entitySets[0].annotations.Common) === null || _convertedType$entity2 === void 0 ? void 0 : _convertedType$entity2.DraftRoot).not.toBeUndefined();
       expect(convertedType.entityTypes.length).toEqual(2);
       expect(convertedType.entityTypes[0].name).toEqual("TestEntity");
-      expect(convertedType.entityTypes[0].entityProperties.length).toEqual(29);
+      expect(convertedType.entityTypes[0].entityProperties.length).toEqual(30);
     });
     it("can call prepareEntityTypes the types for some services", function () {
       var parsedTypes = prepareEntityTypes(metaModel, {
@@ -227,4 +227,4 @@ sap.ui.define(["path", "sap/fe/test/JestTemplatingHelper", "sap/fe/core/converte
     });
   });
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["MetaModelConverter.spec.ts"],"names":["describe","getTestMetamodel","filePath","sMetadataUrl","compileCDS","getMetaModel","metaModel","sdMetaModel","metaModelWithIf","manageSettlement","extendedTypes","beforeAll","path","join","__dirname","it","convertedType","convertTypes","expect","entitySets","length","toEqual","annotations","Common","DraftRoot","not","toBeNull","toBeUndefined","entityTypes","name","entityProperties","parsedTypes","prepareEntityTypes","Chart","MicroChart","IntentBasedNavigation","UShell","Situations","toMatchSnapshot","parsedTypes2","parsedTypes3","parsedTypes4","parsedTypes5","console","time","i","timeEnd","oMetaModel","actions","find","x","fullyQualifiedName","sourceEntityType","context","createBindingContext","convertedContext","convertMetaModelContext"],"mappings":"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","sourceRoot":".","sourcesContent":["import path from \"path\";\nimport { getMetaModel, compileCDS } from \"sap/fe/test/JestTemplatingHelper\";\nimport { ODataMetaModel } from \"sap/ui/model/odata/v4\";\nimport { convertTypes, prepareEntityTypes, convertMetaModelContext } from \"sap/fe/core/converters/MetaModelConverter\";\n\ndescribe(\"MetaModel Converter can transform the metamodel into a pure object construct\", function() {\n\tlet metaModel: ODataMetaModel;\n\tlet sdMetaModel: ODataMetaModel;\n\tlet metaModelWithIf: ODataMetaModel;\n\tlet manageSettlement: ODataMetaModel;\n\tlet extendedTypes: ODataMetaModel;\n\tbeforeAll(async function() {\n\t\tconst sMetadataUrl = compileCDS(path.join(__dirname, \"../data/MetaModelConverter.cds\"));\n\t\tmetaModel = await getMetaModel(sMetadataUrl);\n\t\tsdMetaModel = await getMetaModel(path.join(__dirname, \"../data/salesOrderMetadata.xml\"));\n\t\tmetaModelWithIf = await getMetaModel(path.join(__dirname, \"../data/BindingExpression-AnnotationExpression.xml\"));\n\t\tmanageSettlement = await getMetaModel(path.join(__dirname, \"../data/ManageSettlement.xml\"));\n\t\textendedTypes = await getMetaModel(path.join(__dirname, \"../data/extendedTypes.xml\"));\n\t});\n\n\tasync function getTestMetamodel(filePath: string) {\n\t\tconst sMetadataUrl = compileCDS(filePath);\n\t\treturn await getMetaModel(sMetadataUrl);\n\t}\n\n\tit(\"can convert it\", function() {\n\t\tconst convertedType = convertTypes(metaModel);\n\t\texpect(convertedType.entitySets.length).toEqual(1);\n\t\texpect(convertedType.entitySets[0].annotations.Common?.DraftRoot).not.toBeNull();\n\t\texpect(convertedType.entitySets[0].annotations.Common?.DraftRoot).not.toBeUndefined();\n\t\texpect(convertedType.entityTypes.length).toEqual(2);\n\t\texpect(convertedType.entityTypes[0].name).toEqual(\"TestEntity\");\n\t\texpect(convertedType.entityTypes[0].entityProperties.length).toEqual(29);\n\t});\n\n\tit(\"can call prepareEntityTypes the types for some services\", function() {\n\t\tconst parsedTypes = prepareEntityTypes(metaModel, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes).toMatchSnapshot();\n\n\t\tconst parsedTypes2 = prepareEntityTypes(sdMetaModel, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes2).toMatchSnapshot();\n\n\t\tconst parsedTypes3 = prepareEntityTypes(metaModelWithIf, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes3).toMatchSnapshot();\n\n\t\tconst parsedTypes4 = prepareEntityTypes(manageSettlement, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes4).toMatchSnapshot();\n\n\t\tconst parsedTypes5 = prepareEntityTypes(extendedTypes, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes5).toMatchSnapshot();\n\t});\n\n\tit(\"is not so slow - 1b\", function() {\n\t\t// 792ms -> 267ms for 100\n\t\tconsole.time(\"slow\");\n\t\tfor (let i = 0; i < 100; i++) {\n\t\t\tconst parsedTypes2 = prepareEntityTypes(sdMetaModel, {\n\t\t\t\tChart: true,\n\t\t\t\tMicroChart: true,\n\t\t\t\tIntentBasedNavigation: true,\n\t\t\t\tUShell: true,\n\t\t\t\tSituations: false\n\t\t\t});\n\t\t}\n\t\tconsole.timeEnd(\"slow\");\n\t});\n\n\tit(\"is slow 3\", function() {\n\t\tconsole.time(\"slow\");\n\t\t//1547ms -> 589 for 100\n\t\tfor (let i = 0; i < 100; i++) {\n\t\t\tconst parsedTypes2 = prepareEntityTypes(manageSettlement, {\n\t\t\t\tChart: true,\n\t\t\t\tMicroChart: true,\n\t\t\t\tIntentBasedNavigation: true,\n\t\t\t\tUShell: true,\n\t\t\t\tSituations: false\n\t\t\t});\n\t\t}\n\t\tconsole.timeEnd(\"slow\");\n\t});\n});\n\ndescribe(\"MetaModel Converter - handling of bound actions \", function() {\n\tlet oMetaModel: ODataMetaModel;\n\n\tbeforeAll(async function() {\n\t\tconst sMetadataUrl = compileCDS(path.join(__dirname, \"../data/MetaModelConverterBoundAction.cds\"));\n\t\toMetaModel = await getMetaModel(sMetadataUrl);\n\t});\n\n\tit(\"builds the fully qualified name of bound actions correctly\", () => {\n\t\tconst convertedType = convertTypes(oMetaModel);\n\t\texpect(convertedType.actions.find(x => x.name === \"myNewAction\")?.fullyQualifiedName).toEqual(\n\t\t\t\"sap.fe.test.JestService.myNewAction(Collection(sap.fe.test.JestService.TestEntity))\"\n\t\t);\n\t\texpect(convertedType.actions.find(x => x.name === \"myNewAction\")?.sourceEntityType).not.toBeUndefined();\n\t\texpect(convertedType.actions.find(x => x.name === \"myBoundAction\")?.fullyQualifiedName).toEqual(\n\t\t\t\"sap.fe.test.JestService.myBoundAction(sap.fe.test.JestService.SecondEntity)\"\n\t\t);\n\t\texpect(convertedType.actions.find(x => x.name === \"myBoundAction\")?.sourceEntityType).not.toBeUndefined();\n\t});\n});\n\ndescribe(\"MetaModel Converter - convert metamodel context \", function() {\n\tlet oMetaModel: ODataMetaModel;\n\n\tbeforeAll(async function() {\n\t\tconst sMetadataUrl = compileCDS(path.join(__dirname, \"../data/MetaModelConverterContext.cds\"));\n\t\toMetaModel = await getMetaModel(sMetadataUrl);\n\t});\n\n\tit(\n\t\t\"converts level 0 property\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\"/RootEntity/rootName\");\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.RootEntity/rootName\");\n\t\t}\n\t);\n\n\tit(\n\t\t\"converts level 1 entity\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\"/RootEntity/$NavigationPropertyBinding/_children/$\");\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.EntityContainer/ChildEntity\");\n\t\t}\n\t);\n\n\tit(\n\t\t\"converts level 1 property\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\"/RootEntity/$NavigationPropertyBinding/_children/$/childName\");\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.ChildEntity/childName\");\n\t\t}\n\t);\n\n\tit(\n\t\t\"converts level 2 entity\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\n\t\t\t\t\"/RootEntity/$NavigationPropertyBinding/_children/$/$NavigationPropertyBinding/_related/$\"\n\t\t\t);\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.EntityContainer/RelatedEntity\");\n\t\t}\n\t);\n\n\tit(\n\t\t\"converts level 2 property\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\n\t\t\t\t\"/RootEntity/$NavigationPropertyBinding/_children/$/$NavigationPropertyBinding/_related/$/relatedName\"\n\t\t\t);\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.RelatedEntity/relatedName\");\n\t\t}\n\t);\n});\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["MetaModelConverter.spec.ts"],"names":["describe","getTestMetamodel","filePath","sMetadataUrl","compileCDS","getMetaModel","metaModel","sdMetaModel","metaModelWithIf","manageSettlement","extendedTypes","beforeAll","path","join","__dirname","it","convertedType","convertTypes","expect","entitySets","length","toEqual","annotations","Common","DraftRoot","not","toBeNull","toBeUndefined","entityTypes","name","entityProperties","parsedTypes","prepareEntityTypes","Chart","MicroChart","IntentBasedNavigation","UShell","Situations","toMatchSnapshot","parsedTypes2","parsedTypes3","parsedTypes4","parsedTypes5","console","time","i","timeEnd","oMetaModel","actions","find","x","fullyQualifiedName","sourceEntityType","context","createBindingContext","convertedContext","convertMetaModelContext"],"mappings":";AAAA;AACA;AACA;;;;;;;;;;AAGAA,EAAAA,QAAQ,CAAC,8EAAD,EAAiF,YAAW;AAAA,QAepFC,gBAfoF,aAenEC,QAfmE;AAAA,UAejD;AACjD,YAAMC,YAAY,GAAGC,UAAU,CAACF,QAAD,CAA/B;AADiD,+BAEpCG,YAAY,CAACF,YAAD,CAFwB;AAGjD,OAlBkG;AAAA;AAAA;AAAA;;AACnG,QAAIG,SAAJ;AACA,QAAIC,WAAJ;AACA,QAAIC,eAAJ;AACA,QAAIC,gBAAJ;AACA,QAAIC,aAAJ;AACAC,IAAAA,SAAS;AAAA,UAAkB;AAC1B,YAAMR,YAAY,GAAGC,UAAU,CAACQ,IAAI,CAACC,IAAL,CAAUC,SAAV,EAAqB,gCAArB,CAAD,CAA/B;AAD0B,+BAERT,YAAY,CAACF,YAAD,CAFJ;AAE1BG,UAAAA,SAAS,gBAAT;AAF0B,iCAGND,YAAY,CAACO,IAAI,CAACC,IAAL,CAAUC,SAAV,EAAqB,gCAArB,CAAD,CAHN;AAG1BP,YAAAA,WAAW,iBAAX;AAH0B,mCAIFF,YAAY,CAACO,IAAI,CAACC,IAAL,CAAUC,SAAV,EAAqB,oDAArB,CAAD,CAJV;AAI1BN,cAAAA,eAAe,iBAAf;AAJ0B,qCAKDH,YAAY,CAACO,IAAI,CAACC,IAAL,CAAUC,SAAV,EAAqB,8BAArB,CAAD,CALX;AAK1BL,gBAAAA,gBAAgB,iBAAhB;AAL0B,uCAMJJ,YAAY,CAACO,IAAI,CAACC,IAAL,CAAUC,SAAV,EAAqB,2BAArB,CAAD,CANR;AAM1BJ,kBAAAA,aAAa,iBAAb;AAN0B;AAAA;AAAA;AAAA;AAAA;AAO1B,OAPQ;AAAA;AAAA;AAAA,MAAT;AAcAK,IAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAW;AAAA;;AAC/B,UAAMC,aAAa,GAAGC,YAAY,CAACX,SAAD,CAAlC;AACAY,MAAAA,MAAM,CAACF,aAAa,CAACG,UAAd,CAAyBC,MAA1B,CAAN,CAAwCC,OAAxC,CAAgD,CAAhD;AACAH,MAAAA,MAAM,0BAACF,aAAa,CAACG,UAAd,CAAyB,CAAzB,EAA4BG,WAA5B,CAAwCC,MAAzC,0DAAC,sBAAgDC,SAAjD,CAAN,CAAkEC,GAAlE,CAAsEC,QAAtE;AACAR,MAAAA,MAAM,2BAACF,aAAa,CAACG,UAAd,CAAyB,CAAzB,EAA4BG,WAA5B,CAAwCC,MAAzC,2DAAC,uBAAgDC,SAAjD,CAAN,CAAkEC,GAAlE,CAAsEE,aAAtE;AACAT,MAAAA,MAAM,CAACF,aAAa,CAACY,WAAd,CAA0BR,MAA3B,CAAN,CAAyCC,OAAzC,CAAiD,CAAjD;AACAH,MAAAA,MAAM,CAACF,aAAa,CAACY,WAAd,CAA0B,CAA1B,EAA6BC,IAA9B,CAAN,CAA0CR,OAA1C,CAAkD,YAAlD;AACAH,MAAAA,MAAM,CAACF,aAAa,CAACY,WAAd,CAA0B,CAA1B,EAA6BE,gBAA7B,CAA8CV,MAA/C,CAAN,CAA6DC,OAA7D,CAAqE,EAArE;AACA,KARC,CAAF;AAUAN,IAAAA,EAAE,CAAC,yDAAD,EAA4D,YAAW;AACxE,UAAMgB,WAAW,GAAGC,kBAAkB,CAAC1B,SAAD,EAAY;AACjD2B,QAAAA,KAAK,EAAE,IAD0C;AAEjDC,QAAAA,UAAU,EAAE,IAFqC;AAGjDC,QAAAA,qBAAqB,EAAE,IAH0B;AAIjDC,QAAAA,MAAM,EAAE,IAJyC;AAKjDC,QAAAA,UAAU,EAAE;AALqC,OAAZ,CAAtC;AAOAnB,MAAAA,MAAM,CAACa,WAAD,CAAN,CAAoBO,eAApB;AAEA,UAAMC,YAAY,GAAGP,kBAAkB,CAACzB,WAAD,EAAc;AACpD0B,QAAAA,KAAK,EAAE,IAD6C;AAEpDC,QAAAA,UAAU,EAAE,IAFwC;AAGpDC,QAAAA,qBAAqB,EAAE,IAH6B;AAIpDC,QAAAA,MAAM,EAAE,IAJ4C;AAKpDC,QAAAA,UAAU,EAAE;AALwC,OAAd,CAAvC;AAOAnB,MAAAA,MAAM,CAACqB,YAAD,CAAN,CAAqBD,eAArB;AAEA,UAAME,YAAY,GAAGR,kBAAkB,CAACxB,eAAD,EAAkB;AACxDyB,QAAAA,KAAK,EAAE,IADiD;AAExDC,QAAAA,UAAU,EAAE,IAF4C;AAGxDC,QAAAA,qBAAqB,EAAE,IAHiC;AAIxDC,QAAAA,MAAM,EAAE,IAJgD;AAKxDC,QAAAA,UAAU,EAAE;AAL4C,OAAlB,CAAvC;AAOAnB,MAAAA,MAAM,CAACsB,YAAD,CAAN,CAAqBF,eAArB;AAEA,UAAMG,YAAY,GAAGT,kBAAkB,CAACvB,gBAAD,EAAmB;AACzDwB,QAAAA,KAAK,EAAE,IADkD;AAEzDC,QAAAA,UAAU,EAAE,IAF6C;AAGzDC,QAAAA,qBAAqB,EAAE,IAHkC;AAIzDC,QAAAA,MAAM,EAAE,IAJiD;AAKzDC,QAAAA,UAAU,EAAE;AAL6C,OAAnB,CAAvC;AAOAnB,MAAAA,MAAM,CAACuB,YAAD,CAAN,CAAqBH,eAArB;AAEA,UAAMI,YAAY,GAAGV,kBAAkB,CAACtB,aAAD,EAAgB;AACtDuB,QAAAA,KAAK,EAAE,IAD+C;AAEtDC,QAAAA,UAAU,EAAE,IAF0C;AAGtDC,QAAAA,qBAAqB,EAAE,IAH+B;AAItDC,QAAAA,MAAM,EAAE,IAJ8C;AAKtDC,QAAAA,UAAU,EAAE;AAL0C,OAAhB,CAAvC;AAOAnB,MAAAA,MAAM,CAACwB,YAAD,CAAN,CAAqBJ,eAArB;AACA,KA7CC,CAAF;AA+CAvB,IAAAA,EAAE,CAAC,qBAAD,EAAwB,YAAW;AACpC;AACA4B,MAAAA,OAAO,CAACC,IAAR,CAAa,MAAb;;AACA,WAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,GAApB,EAAyBA,CAAC,EAA1B,EAA8B;AAC7B,YAAMN,YAAY,GAAGP,kBAAkB,CAACzB,WAAD,EAAc;AACpD0B,UAAAA,KAAK,EAAE,IAD6C;AAEpDC,UAAAA,UAAU,EAAE,IAFwC;AAGpDC,UAAAA,qBAAqB,EAAE,IAH6B;AAIpDC,UAAAA,MAAM,EAAE,IAJ4C;AAKpDC,UAAAA,UAAU,EAAE;AALwC,SAAd,CAAvC;AAOA;;AACDM,MAAAA,OAAO,CAACG,OAAR,CAAgB,MAAhB;AACA,KAbC,CAAF;AAeA/B,IAAAA,EAAE,CAAC,WAAD,EAAc,YAAW;AAC1B4B,MAAAA,OAAO,CAACC,IAAR,CAAa,MAAb,EAD0B,CAE1B;;AACA,WAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,GAApB,EAAyBA,CAAC,EAA1B,EAA8B;AAC7B,YAAMN,YAAY,GAAGP,kBAAkB,CAACvB,gBAAD,EAAmB;AACzDwB,UAAAA,KAAK,EAAE,IADkD;AAEzDC,UAAAA,UAAU,EAAE,IAF6C;AAGzDC,UAAAA,qBAAqB,EAAE,IAHkC;AAIzDC,UAAAA,MAAM,EAAE,IAJiD;AAKzDC,UAAAA,UAAU,EAAE;AAL6C,SAAnB,CAAvC;AAOA;;AACDM,MAAAA,OAAO,CAACG,OAAR,CAAgB,MAAhB;AACA,KAbC,CAAF;AAcA,GA1GO,CAAR;AA4GA9C,EAAAA,QAAQ,CAAC,kDAAD,EAAqD,YAAW;AACvE,QAAI+C,UAAJ;AAEApC,IAAAA,SAAS;AAAA,UAAkB;AAC1B,YAAMR,YAAY,GAAGC,UAAU,CAACQ,IAAI,CAACC,IAAL,CAAUC,SAAV,EAAqB,2CAArB,CAAD,CAA/B;AAD0B,+BAEPT,YAAY,CAACF,YAAD,CAFL;AAE1B4C,UAAAA,UAAU,iBAAV;AAF0B;AAG1B,OAHQ;AAAA;AAAA;AAAA,MAAT;AAKAhC,IAAAA,EAAE,CAAC,4DAAD,EAA+D,YAAM;AAAA;;AACtE,UAAMC,aAAa,GAAGC,YAAY,CAAC8B,UAAD,CAAlC;AACA7B,MAAAA,MAAM,0BAACF,aAAa,CAACgC,OAAd,CAAsBC,IAAtB,CAA2B,UAAAC,CAAC;AAAA,eAAIA,CAAC,CAACrB,IAAF,KAAW,aAAf;AAAA,OAA5B,CAAD,0DAAC,sBAA2DsB,kBAA5D,CAAN,CAAsF9B,OAAtF,CACC,qFADD;AAGAH,MAAAA,MAAM,2BAACF,aAAa,CAACgC,OAAd,CAAsBC,IAAtB,CAA2B,UAAAC,CAAC;AAAA,eAAIA,CAAC,CAACrB,IAAF,KAAW,aAAf;AAAA,OAA5B,CAAD,2DAAC,uBAA2DuB,gBAA5D,CAAN,CAAoF3B,GAApF,CAAwFE,aAAxF;AACAT,MAAAA,MAAM,2BAACF,aAAa,CAACgC,OAAd,CAAsBC,IAAtB,CAA2B,UAAAC,CAAC;AAAA,eAAIA,CAAC,CAACrB,IAAF,KAAW,eAAf;AAAA,OAA5B,CAAD,2DAAC,uBAA6DsB,kBAA9D,CAAN,CAAwF9B,OAAxF,CACC,6EADD;AAGAH,MAAAA,MAAM,2BAACF,aAAa,CAACgC,OAAd,CAAsBC,IAAtB,CAA2B,UAAAC,CAAC;AAAA,eAAIA,CAAC,CAACrB,IAAF,KAAW,eAAf;AAAA,OAA5B,CAAD,2DAAC,uBAA6DuB,gBAA9D,CAAN,CAAsF3B,GAAtF,CAA0FE,aAA1F;AACA,KAVC,CAAF;AAWA,GAnBO,CAAR;AAqBA3B,EAAAA,QAAQ,CAAC,kDAAD,EAAqD,YAAW;AACvE,QAAI+C,UAAJ;AAEApC,IAAAA,SAAS;AAAA,UAAkB;AAC1B,YAAMR,YAAY,GAAGC,UAAU,CAACQ,IAAI,CAACC,IAAL,CAAUC,SAAV,EAAqB,uCAArB,CAAD,CAA/B;AAD0B,+BAEPT,YAAY,CAACF,YAAD,CAFL;AAE1B4C,UAAAA,UAAU,iBAAV;AAF0B;AAG1B,OAHQ;AAAA;AAAA;AAAA,MAAT;AAKAhC,IAAAA,EAAE,CACD,2BADC,EAED;AACC,oBAAc,CACb;AACC,gBAAQ,KADT;AAEC,cAAM;AAFP,OADa;AADf,KAFC,EAUD,YAAM;AACL,UAAMsC,OAAO,GAAGN,UAAU,CAACO,oBAAX,CAAgC,sBAAhC,CAAhB;AACA,UAAMC,gBAAgB,GAAGC,uBAAuB,CAACH,OAAD,CAAhD;AAEAnC,MAAAA,MAAM,CAACqC,gBAAgB,CAACJ,kBAAlB,CAAN,CAA4C9B,OAA5C,CAAoD,6CAApD;AACA,KAfA,CAAF;AAkBAN,IAAAA,EAAE,CACD,yBADC,EAED;AACC,oBAAc,CACb;AACC,gBAAQ,KADT;AAEC,cAAM;AAFP,OADa;AADf,KAFC,EAUD,YAAM;AACL,UAAMsC,OAAO,GAAGN,UAAU,CAACO,oBAAX,CAAgC,oDAAhC,CAAhB;AACA,UAAMC,gBAAgB,GAAGC,uBAAuB,CAACH,OAAD,CAAhD;AAEAnC,MAAAA,MAAM,CAACqC,gBAAgB,CAACJ,kBAAlB,CAAN,CAA4C9B,OAA5C,CAAoD,qDAApD;AACA,KAfA,CAAF;AAkBAN,IAAAA,EAAE,CACD,2BADC,EAED;AACC,oBAAc,CACb;AACC,gBAAQ,KADT;AAEC,cAAM;AAFP,OADa;AADf,KAFC,EAUD,YAAM;AACL,UAAMsC,OAAO,GAAGN,UAAU,CAACO,oBAAX,CAAgC,8DAAhC,CAAhB;AACA,UAAMC,gBAAgB,GAAGC,uBAAuB,CAACH,OAAD,CAAhD;AAEAnC,MAAAA,MAAM,CAACqC,gBAAgB,CAACJ,kBAAlB,CAAN,CAA4C9B,OAA5C,CAAoD,+CAApD;AACA,KAfA,CAAF;AAkBAN,IAAAA,EAAE,CACD,yBADC,EAED;AACC,oBAAc,CACb;AACC,gBAAQ,KADT;AAEC,cAAM;AAFP,OADa;AADf,KAFC,EAUD,YAAM;AACL,UAAMsC,OAAO,GAAGN,UAAU,CAACO,oBAAX,CACf,0FADe,CAAhB;AAGA,UAAMC,gBAAgB,GAAGC,uBAAuB,CAACH,OAAD,CAAhD;AAEAnC,MAAAA,MAAM,CAACqC,gBAAgB,CAACJ,kBAAlB,CAAN,CAA4C9B,OAA5C,CAAoD,uDAApD;AACA,KAjBA,CAAF;AAoBAN,IAAAA,EAAE,CACD,2BADC,EAED;AACC,oBAAc,CACb;AACC,gBAAQ,KADT;AAEC,cAAM;AAFP,OADa;AADf,KAFC,EAUD,YAAM;AACL,UAAMsC,OAAO,GAAGN,UAAU,CAACO,oBAAX,CACf,sGADe,CAAhB;AAGA,UAAMC,gBAAgB,GAAGC,uBAAuB,CAACH,OAAD,CAAhD;AAEAnC,MAAAA,MAAM,CAACqC,gBAAgB,CAACJ,kBAAlB,CAAN,CAA4C9B,OAA5C,CAAoD,mDAApD;AACA,KAjBA,CAAF;AAmBA,GArGO,CAAR","sourceRoot":".","sourcesContent":["import path from \"path\";\nimport { getMetaModel, compileCDS } from \"sap/fe/test/JestTemplatingHelper\";\nimport ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport { convertTypes, prepareEntityTypes, convertMetaModelContext } from \"sap/fe/core/converters/MetaModelConverter\";\n\ndescribe(\"MetaModel Converter can transform the metamodel into a pure object construct\", function() {\n\tlet metaModel: ODataMetaModel;\n\tlet sdMetaModel: ODataMetaModel;\n\tlet metaModelWithIf: ODataMetaModel;\n\tlet manageSettlement: ODataMetaModel;\n\tlet extendedTypes: ODataMetaModel;\n\tbeforeAll(async function() {\n\t\tconst sMetadataUrl = compileCDS(path.join(__dirname, \"../data/MetaModelConverter.cds\"));\n\t\tmetaModel = await getMetaModel(sMetadataUrl);\n\t\tsdMetaModel = await getMetaModel(path.join(__dirname, \"../data/salesOrderMetadata.xml\"));\n\t\tmetaModelWithIf = await getMetaModel(path.join(__dirname, \"../data/BindingExpression-AnnotationExpression.xml\"));\n\t\tmanageSettlement = await getMetaModel(path.join(__dirname, \"../data/ManageSettlement.xml\"));\n\t\textendedTypes = await getMetaModel(path.join(__dirname, \"../data/extendedTypes.xml\"));\n\t});\n\n\tasync function getTestMetamodel(filePath: string) {\n\t\tconst sMetadataUrl = compileCDS(filePath);\n\t\treturn await getMetaModel(sMetadataUrl);\n\t}\n\n\tit(\"can convert it\", function() {\n\t\tconst convertedType = convertTypes(metaModel);\n\t\texpect(convertedType.entitySets.length).toEqual(1);\n\t\texpect(convertedType.entitySets[0].annotations.Common?.DraftRoot).not.toBeNull();\n\t\texpect(convertedType.entitySets[0].annotations.Common?.DraftRoot).not.toBeUndefined();\n\t\texpect(convertedType.entityTypes.length).toEqual(2);\n\t\texpect(convertedType.entityTypes[0].name).toEqual(\"TestEntity\");\n\t\texpect(convertedType.entityTypes[0].entityProperties.length).toEqual(30);\n\t});\n\n\tit(\"can call prepareEntityTypes the types for some services\", function() {\n\t\tconst parsedTypes = prepareEntityTypes(metaModel, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes).toMatchSnapshot();\n\n\t\tconst parsedTypes2 = prepareEntityTypes(sdMetaModel, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes2).toMatchSnapshot();\n\n\t\tconst parsedTypes3 = prepareEntityTypes(metaModelWithIf, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes3).toMatchSnapshot();\n\n\t\tconst parsedTypes4 = prepareEntityTypes(manageSettlement, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes4).toMatchSnapshot();\n\n\t\tconst parsedTypes5 = prepareEntityTypes(extendedTypes, {\n\t\t\tChart: true,\n\t\t\tMicroChart: true,\n\t\t\tIntentBasedNavigation: true,\n\t\t\tUShell: true,\n\t\t\tSituations: false\n\t\t});\n\t\texpect(parsedTypes5).toMatchSnapshot();\n\t});\n\n\tit(\"is not so slow - 1b\", function() {\n\t\t// 792ms -> 267ms for 100\n\t\tconsole.time(\"slow\");\n\t\tfor (let i = 0; i < 100; i++) {\n\t\t\tconst parsedTypes2 = prepareEntityTypes(sdMetaModel, {\n\t\t\t\tChart: true,\n\t\t\t\tMicroChart: true,\n\t\t\t\tIntentBasedNavigation: true,\n\t\t\t\tUShell: true,\n\t\t\t\tSituations: false\n\t\t\t});\n\t\t}\n\t\tconsole.timeEnd(\"slow\");\n\t});\n\n\tit(\"is slow 3\", function() {\n\t\tconsole.time(\"slow\");\n\t\t//1547ms -> 589 for 100\n\t\tfor (let i = 0; i < 100; i++) {\n\t\t\tconst parsedTypes2 = prepareEntityTypes(manageSettlement, {\n\t\t\t\tChart: true,\n\t\t\t\tMicroChart: true,\n\t\t\t\tIntentBasedNavigation: true,\n\t\t\t\tUShell: true,\n\t\t\t\tSituations: false\n\t\t\t});\n\t\t}\n\t\tconsole.timeEnd(\"slow\");\n\t});\n});\n\ndescribe(\"MetaModel Converter - handling of bound actions \", function() {\n\tlet oMetaModel: ODataMetaModel;\n\n\tbeforeAll(async function() {\n\t\tconst sMetadataUrl = compileCDS(path.join(__dirname, \"../data/MetaModelConverterBoundAction.cds\"));\n\t\toMetaModel = await getMetaModel(sMetadataUrl);\n\t});\n\n\tit(\"builds the fully qualified name of bound actions correctly\", () => {\n\t\tconst convertedType = convertTypes(oMetaModel);\n\t\texpect(convertedType.actions.find(x => x.name === \"myNewAction\")?.fullyQualifiedName).toEqual(\n\t\t\t\"sap.fe.test.JestService.myNewAction(Collection(sap.fe.test.JestService.TestEntity))\"\n\t\t);\n\t\texpect(convertedType.actions.find(x => x.name === \"myNewAction\")?.sourceEntityType).not.toBeUndefined();\n\t\texpect(convertedType.actions.find(x => x.name === \"myBoundAction\")?.fullyQualifiedName).toEqual(\n\t\t\t\"sap.fe.test.JestService.myBoundAction(sap.fe.test.JestService.SecondEntity)\"\n\t\t);\n\t\texpect(convertedType.actions.find(x => x.name === \"myBoundAction\")?.sourceEntityType).not.toBeUndefined();\n\t});\n});\n\ndescribe(\"MetaModel Converter - convert metamodel context \", function() {\n\tlet oMetaModel: ODataMetaModel;\n\n\tbeforeAll(async function() {\n\t\tconst sMetadataUrl = compileCDS(path.join(__dirname, \"../data/MetaModelConverterContext.cds\"));\n\t\toMetaModel = await getMetaModel(sMetadataUrl);\n\t});\n\n\tit(\n\t\t\"converts level 0 property\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\"/RootEntity/rootName\");\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.RootEntity/rootName\");\n\t\t}\n\t);\n\n\tit(\n\t\t\"converts level 1 entity\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\"/RootEntity/$NavigationPropertyBinding/_children/$\");\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.EntityContainer/ChildEntity\");\n\t\t}\n\t);\n\n\tit(\n\t\t\"converts level 1 property\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\"/RootEntity/$NavigationPropertyBinding/_children/$/childName\");\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.ChildEntity/childName\");\n\t\t}\n\t);\n\n\tit(\n\t\t\"converts level 2 entity\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\n\t\t\t\t\"/RootEntity/$NavigationPropertyBinding/_children/$/$NavigationPropertyBinding/_related/$\"\n\t\t\t);\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.EntityContainer/RelatedEntity\");\n\t\t}\n\t);\n\n\tit(\n\t\t\"converts level 2 property\",\n\t\t{\n\t\t\t\"references\": [\n\t\t\t\t{\n\t\t\t\t\t\"type\": \"BCP\",\n\t\t\t\t\t\"ID\": \"2180402182\"\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t() => {\n\t\t\tconst context = oMetaModel.createBindingContext(\n\t\t\t\t\"/RootEntity/$NavigationPropertyBinding/_children/$/$NavigationPropertyBinding/_related/$/relatedName\"\n\t\t\t);\n\t\t\tconst convertedContext = convertMetaModelContext(context);\n\n\t\t\texpect(convertedContext.fullyQualifiedName).toEqual(\"sap.fe.test.JestService.RelatedEntity/relatedName\");\n\t\t}\n\t);\n});\n"]}

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

@@ -1,6 +1,6 @@
 import path from "path";
 import { getMetaModel, compileCDS } from "sap/fe/test/JestTemplatingHelper";
-import { ODataMetaModel } from "sap/ui/model/odata/v4";
+import ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
 import { convertTypes, prepareEntityTypes, convertMetaModelContext } from "sap/fe/core/converters/MetaModelConverter";
 
 describe("MetaModel Converter can transform the metamodel into a pure object construct", function() {
@@ -30,7 +30,7 @@ describe("MetaModel Converter can transform the metamodel into a pure object con
 		expect(convertedType.entitySets[0].annotations.Common?.DraftRoot).not.toBeUndefined();
 		expect(convertedType.entityTypes.length).toEqual(2);
 		expect(convertedType.entityTypes[0].name).toEqual("TestEntity");
-		expect(convertedType.entityTypes[0].entityProperties.length).toEqual(29);
+		expect(convertedType.entityTypes[0].entityProperties.length).toEqual(30);
 	});
 
 	it("can call prepareEntityTypes the types for some services", function() {