feat(ui5-test-writer): Generate tests for Form and Table content of Object Page Sections (#4593)

* (feat) ui5-test-writer: Generate tests for form and Table content of Object Page Sections

- generate checks for form fields in op sections
- genereate checks for table columns in op sections
- new tableUtils file for shared table-related stuff valid for both LR and OP

* Fix fallback and check when missing navigationProperty

* Adjust based on AI review, update test

* Clean up types

* Fix TS type issues caused by type adjustments

---------

Co-authored-by: David O'Connor <[email protected]>

Author: sap-sebelao

.changeset/breezy-candies-go.md

@@ -0,0 +1,5 @@
+---
+'@sap-ux/ui5-test-writer': patch
+---
+
+Generate tests for Form and Table content in Object Page Sections

packages/ui5-test-writer/src/types.ts

@@ -95,18 +95,34 @@ export type ObjectPageNavigationParents = {
     parentOPTableSection?: string;
 };
 
+export type SectionFormField = {
+    property: string;
+};
+
+export type TableColumn = {
+    header?: string;
+};
+
+export type TableColumnFeatureData = Record<string, TableColumn>;
+
 export type BodySubSectionFeatureData = {
     id: string;
+    navigationProperty?: string;
     isTable: boolean;
     custom: boolean;
     order: number;
+    fields: SectionFormField[];
+    tableColumns: TableColumnFeatureData;
 };
 
 export type BodySectionFeatureData = {
     id: string;
+    navigationProperty?: string;
     isTable: boolean;
     custom: boolean;
     order: number;
+    fields: SectionFormField[];
+    tableColumns: TableColumnFeatureData;
     subSections: BodySubSectionFeatureData[];
 };
 

packages/ui5-test-writer/src/utils/modelUtils.ts

@@ -14,6 +14,7 @@ import type {
 import type { AppFeatures, FPMFeatures } from '../types';
 import { getObjectPageFeatures, getObjectPages } from './objectPageUtils';
 import { getFilterFieldNames, getListReportFeatures } from './listReportUtils';
+import { extractTableColumnsFromNode } from './tableUtils';
 
 export interface AggregationItem extends TreeAggregation {
     description: string;
@@ -128,44 +129,6 @@ export async function getAppFeatures(
     return featureData;
 }
 
-/**
- * Gets identifier of a column for OPA5 tests.
- * If the column is custom, the identifier is taken from the 'Key' entry in the schema keys.
- * If the column is not custom, the identifier is taken from the 'Value' entry in the schema keys.
- * If no such entry is found, undefined is returned.
- *
- * @param column - column module from ux specification
- * @param column.custom boolean indicating whether the column is custom
- * @param column.schema schema of the column
- * @param column.schema.keys keys of the column; expected to have an entry with the name 'Key' or 'Value'
- * @returns identifier of the column for OPA5 tests; can be the name or index
- */
-function getColumnIdentifier(column: {
-    custom: boolean;
-    schema: { keys: { name: string; value: string }[] };
-}): string | undefined {
-    const key = column.custom ? 'Key' : 'Value';
-    const keyEntry = column.schema.keys.find((entry: { name: string; value: string }) => entry.name === key);
-    return keyEntry?.value;
-}
-
-/**
- * Transforms column aggregations from the ux specification model into a map of columns for OPA5 tests.
- *
- * @param columnAggregations column aggregations from the ux specification model
- * @returns a map of columns for OPA5 tests
- */
-function transformTableColumns(columnAggregations: Record<string, any>): Record<string, any> {
-    const columns: Record<string, any> = {};
-    Object.values(columnAggregations).forEach((columnAggregation, index) => {
-        columns[getColumnIdentifier(columnAggregation) ?? index] = {
-            header: columnAggregation.description
-            // TODO possibly more reliable properties could be used?
-        };
-    });
-    return columns;
-}
-
 /**
  * Retrieves table column data from the page model using ux-specification.
  *
@@ -180,8 +143,7 @@ export function getTableColumnData(
     let tableColumns: Record<string, Record<string, string | number | boolean>> = {};
 
     try {
-        const columnAggregations = getTableColumns(pageModel);
-        tableColumns = transformTableColumns(columnAggregations);
+        tableColumns = extractTableColumnsFromNode(pageModel.root);
     } catch (error) {
         log?.debug(error);
     }
@@ -292,17 +254,3 @@ export function getFilterFields(pageModel: TreeModel): TreeAggregations {
     const selectionFieldsAggregations = getAggregations(selectionFields);
     return selectionFieldsAggregations;
 }
-
-/**
- * Retrieves the table columns aggregation from the given tree model.
- *
- * @param pageModel - The tree model containing table column definitions.
- * @returns The table columns aggregation object.
- */
-export function getTableColumns(pageModel: TreeModel): TreeAggregations {
-    const table = getAggregations(pageModel.root)['table'];
-    const tableAggregations = getAggregations(table);
-    const columns = tableAggregations['columns'];
-    const columnAggregations = getAggregations(columns);
-    return columnAggregations;
-}

packages/ui5-test-writer/src/utils/objectPageUtils.ts

@@ -2,6 +2,7 @@ import type { Logger } from '@sap-ux/logger';
 import type { ApplicationModel } from '@sap/ux-specification/dist/types/src/parser';
 import type {
     FormField,
+    SectionFormField,
     BodySectionFeatureData,
     BodySubSectionFeatureData,
     HeaderSectionFeatureData,
@@ -17,6 +18,7 @@ import {
     type SectionItem,
     getAggregations
 } from './modelUtils';
+import { extractTableColumnsFromNode } from './tableUtils';
 import { PageTypeV4 } from '@sap/ux-specification/dist/types/src/common/page';
 
 /**
@@ -158,9 +160,12 @@ function extractObjectPageBodySectionsData(objectPage: PageWithModelV4): BodySec
             const subSections = extractBodySubSectionsData(section, sectionId);
             bodySections.push({
                 id: sectionId,
+                navigationProperty: getNavigationPropertyFromKey(sectionKey),
                 isTable: !!section.isTable,
                 custom: !!section.custom,
                 order: section?.order ?? -1, // put a negative order number to signal that order was not in spec
+                fields: section.custom || section.isTable ? [] : extractFormFields(section),
+                tableColumns: section.custom || !section.isTable ? {} : extractTableColumnsFromNode(section),
                 subSections
             });
         });
@@ -184,14 +189,53 @@ function extractBodySubSectionsData(section: SectionItem, parentSectionId: strin
         const subSectionId = getSectionIdentifier(subSection) ?? `${parentSectionId}_${subSectionKey}`;
         subSections.push({
             id: subSectionId,
+            navigationProperty: getNavigationPropertyFromKey(subSectionKey),
             isTable: !!subSection.isTable,
             custom: !!subSection.custom,
-            order: subSection?.order ?? -1 // put a negative order number to signal that order was not in spec
+            order: subSection?.order ?? -1, // put a negative order number to signal that order was not in spec
+            fields: subSection.custom || subSection.isTable ? [] : extractFormFields(subSection),
+            tableColumns: subSection.custom || !subSection.isTable ? {} : extractTableColumnsFromNode(subSection)
         });
     });
     return subSections;
 }
 
+/**
+ * Extracts form field property paths from a body sub-section's form aggregation.
+ *
+ * @param subSection - body sub-section entry from the application model
+ * @returns array of form field property paths for use with iCheckField({ property })
+ */
+function extractFormFields(subSection: BodySectionItem): SectionFormField[] {
+    const fields: SectionFormField[] = [];
+    const formAggregation = getAggregations(subSection)['form'] as AggregationItem;
+    if (!formAggregation) {
+        return fields;
+    }
+    const fieldsAggregation = getAggregations(formAggregation)['fields'] as AggregationItem;
+    const fieldItems = getAggregations(fieldsAggregation) as Record<string, FieldItem>;
+    Object.values(fieldItems).forEach((field) => {
+        const property = field.schema?.keys?.find((key) => key.name === 'Value')?.value;
+        if (property) {
+            fields.push({ property });
+        }
+    });
+    return fields;
+}
+
+/**
+ * Extracts the OData navigation property from a spec model section key.
+ * Section keys for table sections follow the pattern `_NavProperty::@annotation`, so the
+ * navigation property is the part before `::` when it starts with an underscore.
+ *
+ * @param sectionKey - the key of the section in the spec model aggregations
+ * @returns navigation property (e.g. '_Booking'), or undefined for non-navigation sections
+ */
+function getNavigationPropertyFromKey(sectionKey: string): string | undefined {
+    const prefix = sectionKey.split('::')[0];
+    return prefix.startsWith('_') ? prefix : undefined;
+}
+
 /**
  * Gets the identifier of a section for OPA5 tests.
  *

packages/ui5-test-writer/src/utils/tableUtils.ts

@@ -0,0 +1,66 @@
+import type { TreeAggregation, TreeAggregations } from '@sap/ux-specification/dist/types/src/parser';
+import { getAggregations } from './modelUtils';
+import type { TableColumn, TableColumnFeatureData } from '../types';
+
+type ColumnModelItem = {
+    custom?: boolean;
+    description?: string;
+    schema: { keys: { name: string; value: string }[] };
+};
+
+export type ColumnAggregations = TreeAggregations & {
+    [key: string]: ColumnModelItem;
+};
+
+/**
+ * Gets the identifier of a column for OPA5 tests.
+ * Custom columns use the 'Key' entry; standard columns use the 'Value' entry from the schema keys.
+ *
+ * @param column - column item from ux specification
+ * @returns identifier of the column for OPA5 tests; undefined if no matching key entry is found
+ */
+export function getColumnIdentifier(column: ColumnModelItem): string | undefined {
+    const key = column.custom ? 'Key' : 'Value';
+    return column.schema.keys.find((k) => k.name === key)?.value;
+}
+
+/**
+ * Transforms column aggregations from the ux specification model into a map of columns for OPA5 tests.
+ * Each column entry includes the column header label for display verification.
+ *
+ * @param columnAggregations - column aggregations from the ux specification model
+ * @returns a map of column identifiers to column state objects for use with iCheckColumns()
+ */
+export function transformTableColumns(columnAggregations: ColumnAggregations): TableColumnFeatureData {
+    const columns: TableColumnFeatureData = {};
+    Object.values(columnAggregations).forEach((column, index) => {
+        const id = getColumnIdentifier(column) ?? String(index);
+        const state: TableColumn = {};
+        if (column.description) {
+            state['header'] = column.description;
+        }
+        columns[id] = state;
+    });
+    return columns;
+}
+
+/**
+ * Extracts table column data from a spec model node that contains a 'table' aggregation.
+ * Covers both page-level nodes (List Report, FPM) via their root and section-level nodes
+ * (Object Page body sections) — both are TreeAggregation nodes that expose a 'table' aggregation.
+ *
+ * @param node - tree aggregation node that exposes a 'table' aggregation
+ * @returns a map of column identifiers to column state objects for use with iCheckColumns()
+ */
+export function extractTableColumnsFromNode(node: TreeAggregation): TableColumnFeatureData {
+    const tableAggregation = getAggregations(node)['table'];
+    if (!tableAggregation) {
+        return {};
+    }
+    const columnsAggregation = getAggregations(tableAggregation)['columns'];
+    if (!columnsAggregation) {
+        return {};
+    }
+    const columnItems = getAggregations(columnsAggregation);
+    return transformTableColumns(columnItems as ColumnAggregations);
+}

packages/ui5-test-writer/templates/v4/integration/ObjectPageJourney.js

@@ -74,8 +74,25 @@ sap.ui.define([
 <% section.subSections.forEach(function(subSection) { -%>
             //When.onThe<%- name%>.iGoToSection({ section: "<%- section.id %>", subSection: "<%- subSection.id %>" });
             Then.onThe<%- name%>.iCheckSubSection({ section: "<%- subSection.id %>" });
+<% if (subSection.fields && subSection.fields.length > 0) { -%>
+<% subSection.fields.forEach(function(field) { -%>
+            Then.onThe<%- name%>.onForm({ section: "<%- subSection.id %>" }).iCheckField({ property: "<%- field.property %>" });
 <% }) -%>
 <% } -%>
+<% if (subSection.tableColumns && Object.keys(subSection.tableColumns).length > 0 && subSection.navigationProperty) { -%>
+            Then.onThe<%- name%>.onTable({ property: "<%- subSection.navigationProperty %>" }).iCheckColumns(<%- JSON.stringify(subSection.tableColumns) %>);
+<% } -%>
+<% }) -%>
+<% } else { -%>
+<% if (section.fields && section.fields.length > 0) { -%>
+<% section.fields.forEach(function(field) { -%>
+            Then.onThe<%- name%>.onForm({ section: "<%- section.id %>" }).iCheckField({ property: "<%- field.property %>" });
+<% }) -%>
+<% } -%>
+<% if (section.tableColumns && Object.keys(section.tableColumns).length > 0 && section.navigationProperty) { -%>
+            Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckColumns(<%- JSON.stringify(section.tableColumns) %>);
+<% } -%>
+<% } -%>
 <% }) -%>
        });
 <% } -%>

packages/ui5-test-writer/test/test-input/constants.ts

@@ -506,6 +506,15 @@ describe('ui5-test-writer', () => {
             expect(bookingObjPageJourneyContent).toContain('iCheckSection({ section: "FlightData" })');
             expect(bookingObjPageJourneyContent).toContain('iPressSectionIconTabFilterButton("PriceData")');
             expect(bookingObjPageJourneyContent).toContain('iCheckSection({ section: "PriceData" })');
+            expect(bookingObjPageJourneyContent).toContain(
+                'onForm({ section: "BookingData" }).iCheckField({ property: "BookingId" })'
+            );
+            expect(bookingObjPageJourneyContent).toContain(
+                'onForm({ section: "BookingData" }).iCheckField({ property: "FlightDate" })'
+            );
+            expect(bookingObjPageJourneyContent).toContain('onTable({ property: "_Supplements" }).iCheckColumns(');
+            expect(bookingObjPageJourneyContent).toContain('"ConnectionId":{"header":"Connection"}');
+            expect(bookingObjPageJourneyContent).toContain('"AirportCode":{"header":"Airport"}');
         });
     });
 });