@finos/legend-application-studio 28.21.23 → 28.21.24

package/src/stores/editor/editor-state/element-editor-state/dataProduct/testable/DataProductTestableState.ts

@@ -20,7 +20,6 @@ import {
   type PackageableElement,
   type TestSuite,
   type RawLambda,
-  type AccessorOwner,
   type ValueSpecification,
   DataProduct,
   FunctionAccessPoint,
@@ -46,9 +45,7 @@ import {
   observe_DataProductTestSuite,
   observe_ValueSpecification,
   buildLambdaVariableExpressions,
-  IngestDefinition,
-  getAccessorItemLabelForElement,
-  type AbstractPureGraphManager,
+  type IngestDefinition,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -73,10 +70,7 @@ import {
 } from 'mobx';
 import type { EditorStore } from '../../../../EditorStore.js';
 import type { DataProductEditorState } from '../DataProductEditorState.js';
-import {
-  RelationElementsDataState,
-  RelationElementState,
-} from '../../data/EmbeddedDataState.js';
+import { RelationElementState } from '../../data/EmbeddedDataState.js';
 import { TESTABLE_RESULT } from '../../../../sidebar-state/testable/GlobalTestRunnerState.js';
 import { testSuite_addTest } from '../../../../../graph-modifier/Testable_GraphModifierHelper.js';
 import {
@@ -84,19 +78,16 @@ import {
   TestableTestSuiteEditorState,
 } from '../../testable/TestableEditorState.js';
 import { generateVariableExpressionMockValue } from '@finos/legend-query-builder';
+import {
+  buildRelationElementsDataWithColumns,
+  createEmptyRelationElement,
+  isIngestOrDataProductAccessor,
+  LakehouseElementTestDataState,
+} from '../../testable/LakehouseTestableUtils.js';
 
-const createEmptyRelationElement = (
-  itemId: string,
-  columns: string[] = [],
-): RelationElement => {
-  const row = observe_RelationRowTestData(new RelationRowTestData());
-  row.values = columns.map(() => '');
-  const relationElement = new RelationElement();
-  relationElement.paths = [itemId];
-  relationElement.columns = columns;
-  relationElement.rows = [row];
-  return observe_RelationElement(relationElement);
-};
+export type { LakehouseElementTestDataState as DataProductElementTestDataState };
+
+// ─── Data-product-specific helpers ───────────────────────────────────────────
 
 /**
  * Returns the lambda for an access point (handles both LakehouseAccessPoint
@@ -111,59 +102,9 @@ const getAccessPointLambda = (
       ? accessPoint.query
       : undefined;
 
-/**
- * Builds a RelationElementsData from resolved accessors using the accessor
- * relation type as the source of truth for column definitions.
- */
-const buildRelationElementsDataWithColumns = (
-  accs: Accessor[],
-): RelationElementsData => {
-  const relData = new RelationElementsData();
-  relData.relationElements = accs.map((acc) => {
-    const itemId = acc.accessor || 'UNKNOWN';
-    const columns = acc.relationType.columns.map((column) => column.name);
-    return createEmptyRelationElement(itemId, columns);
-  });
-  return relData;
-};
-
-const isIngestOrDataProductAccessor = (
-  accessor: Accessor,
-): accessor is Accessor =>
-  accessor.parentElement instanceof DataProduct ||
-  accessor.parentElement instanceof IngestDefinition;
-
 const getAccessPointDisplayLabel = (accessPoint: AccessPoint): string =>
   accessPoint.id;
 
-interface ElementDataItem {
-  id: string;
-  label: string;
-}
-
-const getElementDataItems = (
-  element: PackageableElement,
-  graphManager: AbstractPureGraphManager,
-): ElementDataItem[] => {
-  if (element instanceof DataProduct) {
-    return element.accessPointGroups
-      .flatMap((g) => g.accessPoints)
-      .map((ap) => ({
-        id: ap.id,
-        label: getAccessPointDisplayLabel(ap),
-      }));
-  }
-  if (element instanceof IngestDefinition) {
-    return graphManager
-      .getIngestDefinitionDatasetNames(element)
-      .map((name) => ({
-        id: name,
-        label: name,
-      }));
-  }
-  return [];
-};
-
 const inferDataProductItemColumns = async (
   editorStore: EditorStore,
   dataProduct: DataProduct,
@@ -576,119 +517,8 @@ export class DataProductTestState extends TestableTestEditorState {
 }
 
 // ─── Per-element test data state ─────────────────────────────────────────────
-
-export class DataProductElementTestDataState {
-  readonly testDataState: DataProductTestDataState;
-  readonly testData: BaseDataResolver;
-  readonly editorStore: EditorStore;
-  readonly relationElementsDataState: RelationElementsDataState | undefined;
-
-  constructor(
-    testDataState: DataProductTestDataState,
-    testData: BaseDataResolver,
-  ) {
-    this.testDataState = testDataState;
-    this.testData = testData;
-    this.editorStore = testDataState.editorStore;
-    if (testData.data instanceof RelationElementsData) {
-      this.relationElementsDataState = new RelationElementsDataState(
-        this.editorStore,
-        testData.data,
-      );
-      this.initAccessorOptions();
-    }
-  }
-
-  get element(): PackageableElement {
-    return this.testData.element.value;
-  }
-
-  get elementName(): string {
-    return this.testData.element.value.name;
-  }
-
-  get itemLabel(): string {
-    return getAccessorItemLabelForElement(this.element as AccessorOwner);
-  }
-
-  private initAccessorOptions(): void {
-    const dataState = this.relationElementsDataState;
-    if (!dataState) {
-      return;
-    }
-    this.refreshAccessorOptions(dataState).catch(noop);
-    dataState.setRefreshAccessorOptions(() =>
-      this.refreshAccessorOptions(dataState),
-    );
-  }
-
-  private async refreshAccessorOptions(
-    dataState: RelationElementsDataState,
-  ): Promise<void> {
-    const element = this.element;
-    const graphManager = this.editorStore.graphManagerState.graphManager;
-    const graph = this.editorStore.graphManagerState.graph;
-    const items = getElementDataItems(element, graphManager);
-    if (items.length === 0) {
-      dataState.setAccessorOptions(undefined, undefined);
-      return;
-    }
-    const typeLabel = this.itemLabel;
-    const options = await Promise.all(
-      items.map(async (item) => {
-        let columns: string[] = [];
-        try {
-          if (element instanceof IngestDefinition) {
-            const accessor =
-              await graphManager.createAccessorFromPackageableElement(
-                element,
-                graph,
-                { schemaName: undefined, tableName: item.id },
-              );
-            if (accessor) {
-              columns = accessor.relationType.columns.map((c) => c.name);
-            }
-          } else if (element instanceof DataProduct) {
-            const accessor = await graphManager.buildDataProductAccessor(
-              element,
-              graph,
-              { tableName: item.id },
-            );
-            if (accessor) {
-              columns = accessor.relationType.columns.map((c) => c.name);
-            }
-          }
-        } catch {
-          // best-effort column resolution
-        }
-        return {
-          label: item.label,
-          value: item.id,
-          columns,
-        };
-      }),
-    );
-    runInAction(() => {
-      dataState.setAccessorOptions(options, typeLabel);
-      // Back-fill columns on existing relation elements that have none
-      const columnsByItem = new Map(
-        options
-          .filter((o) => o.columns.length > 0)
-          .map((o) => [o.value, o.columns]),
-      );
-      for (const relState of dataState.relationElementStates) {
-        const rel = relState.relationElement;
-        if (rel.columns.length === 0) {
-          const key = rel.paths[rel.paths.length - 1];
-          const cols = key ? columnsByItem.get(key) : undefined;
-          if (cols) {
-            rel.columns = cols;
-          }
-        }
-      }
-    });
-  }
-}
+// Replaced by the shared LakehouseElementTestDataState from LakehouseTestableUtils.
+// The type alias above maintains backward compatibility for any existing imports.
 
 // ─── Test data state for a suite ─────────────────────────────────────────────
 
@@ -696,8 +526,8 @@ export class DataProductTestDataState {
   readonly editorStore: EditorStore;
   readonly suiteState: DataProductTestSuiteState;
 
-  elementTestDataStates: DataProductElementTestDataState[] = [];
-  selectedElementTestDataState: DataProductElementTestDataState | undefined;
+  elementTestDataStates: LakehouseElementTestDataState[] = [];
+  selectedElementTestDataState: LakehouseElementTestDataState | undefined;
   showAddElementModal = false;
 
   constructor(
@@ -765,7 +595,7 @@ export class DataProductTestDataState {
     this.refreshElementTestDataStates({ selectedElementPath: path });
   }
 
-  deleteElement(elementState: DataProductElementTestDataState): void {
+  deleteElement(elementState: LakehouseElementTestDataState): void {
     const suite = this.suiteState.suite;
     if (suite.testData) {
       const idx = suite.testData.indexOf(elementState.testData);
@@ -783,7 +613,7 @@ export class DataProductTestDataState {
     const suite = this.suiteState.suite;
     this.elementTestDataStates = (suite.testData ?? [])
       .filter((td): td is BaseDataResolver => td instanceof BaseDataResolver)
-      .map((td) => new DataProductElementTestDataState(this, td));
+      .map((td) => new LakehouseElementTestDataState(td, this.editorStore));
 
     this.selectedElementTestDataState =
       this.elementTestDataStates.find(
@@ -792,7 +622,7 @@ export class DataProductTestDataState {
   }
 
   setSelectedElementTestDataState(
-    val: DataProductElementTestDataState | undefined,
+    val: LakehouseElementTestDataState | undefined,
   ): void {
     this.selectedElementTestDataState = val;
   }
@@ -1069,10 +899,6 @@ export class DataProductTestableState {
     }
   }
 
-  /**
-   * Build suite states from the DataProduct.tests array.
-   * Call this on init and after grammar→form roundtrip.
-   */
   init(): void {
     const dp = this.dataProduct;
     this.suiteStates = dp.tests.map(
@@ -1081,13 +907,11 @@ export class DataProductTestableState {
     this.selectedSuiteState = this.suiteStates[0];
   }
 
-  /** Returns all graph ingest elements available in the model. */
   get availableIngestSources(): IngestDefinition[] {
     const graph = this.editorStore.graphManagerState.graph;
     return graph.ingests;
   }
 
-  /** Access points on the DataProduct being edited (used for test's accessPointId). */
   get ownAccessPoints(): AccessPoint[] {
     return this.dataProduct.accessPointGroups.flatMap((g) => g.accessPoints);
   }
@@ -1101,12 +925,6 @@ export class DataProductTestableState {
       : accessPointId;
   }
 
-  /**
-   * Create a new test suite with one initial test on the DataProduct.
-   * Test data is auto-seeded for the selected access point on the current
-   * DataProduct (no element picker required).
-   * Columns are inferred via the engine when possible.
-   */
   *createSuite(
     suiteName: string,
     testName: string,
@@ -1119,7 +937,6 @@ export class DataProductTestableState {
     const suite = new DataProductTestSuite();
     suite.id = suiteName;
 
-    // Try to infer columns from the access-point lambda
     let inferredColumns: string[] = [];
     try {
       const cols = (yield inferDataProductItemColumns(
@@ -1134,7 +951,6 @@ export class DataProductTestableState {
       // Column inference is best-effort; continue with empty columns
     }
 
-    // Resolve INPUT sources via the graph (follows function calls, avoids self-refs)
     const accessPointForSuite = dp.accessPointGroups
       .flatMap((g) => g.accessPoints)
       .find((ap) => ap.id === accessPointId);
@@ -1174,14 +990,12 @@ export class DataProductTestableState {
         suite.testData.push(resolver);
       }
     }
-    // If no external sources were resolved, notify the user and leave test data empty
     if (suite.testData.length === 0) {
       this.editorStore.applicationStore.notificationService.notifyWarning(
         'Access Point accessors cannot be resolved',
       );
     }
 
-    // Create one initial test with EqualToRelation assertion
     const test = new DataProductAccessPointTest();
     test.id = testName;
     test.__parent = suite;

package/src/stores/editor/editor-state/element-editor-state/function-activator/testable/FunctionTestableState.ts

@@ -68,6 +68,7 @@ import {
   Database,
   DataProduct,
   IngestDefinition,
+  LakehouseRuntime,
   PackageableElementExplicitReference,
   observe_ValueSpecification,
   observe_RelationElementsData,
@@ -1032,44 +1033,48 @@ export class FunctionTestableState extends TestablePackageableElementEditorState
             `Function Test Suite Only supports One Runtime at this time. Found ${engineRuntimes.length}`,
           );
           const engineRuntime = guaranteeNonNullable(engineRuntimes[0]);
-          assertTrue(
-            !(
-              engineRuntime.connectionStores.length &&
-              engineRuntime.connections.length
-            ),
-            `Runtime found has two connection types defined. Please use connection stores only`,
-          );
-          const stores = [
-            ...engineRuntime.connections
-              .map((e) =>
-                e.storeConnections.map((s) => s.connection.store?.value).flat(),
-              )
-              .flat(),
-            ...engineRuntime.connectionStores
-              .map((e) => e.storePointers.map((sPt) => sPt.value))
-              .flat(),
-          ].filter(isNonNullable);
-          assertTrue(Boolean(stores.length), 'No runtime store found');
-          assertTrue(
-            stores.length === 1,
-            'Only one store supported in runtime for function tests',
-          );
-          const store = guaranteeNonNullable(stores[0]);
-          const data = new FunctionTestData();
-          if (store instanceof Database) {
-            const relation = new RelationElementsData();
-            data.element = PackageableElementExplicitReference.create(store);
-            data.data = relation;
-          } else if (store instanceof ModelStore) {
-            const modelStoreData = createBareExternalFormat();
-            data.element = PackageableElementExplicitReference.create(store);
-            data.data = modelStoreData;
-          } else {
-            throw new UnsupportedOperationError(
-              `function test store data does not support store: ${store.path}`,
+          if (!(engineRuntime instanceof LakehouseRuntime)) {
+            assertTrue(
+              !(
+                engineRuntime.connectionStores.length &&
+                engineRuntime.connections.length
+              ),
+              `Runtime found has two connection types defined. Please use connection stores only`,
+            );
+            const stores = [
+              ...engineRuntime.connections
+                .map((e) =>
+                  e.storeConnections
+                    .map((s) => s.connection.store?.value)
+                    .flat(),
+                )
+                .flat(),
+              ...engineRuntime.connectionStores
+                .map((e) => e.storePointers.map((sPt) => sPt.value))
+                .flat(),
+            ].filter(isNonNullable);
+            assertTrue(Boolean(stores.length), 'No runtime store found');
+            assertTrue(
+              stores.length === 1,
+              'Only one store supported in runtime for function tests',
             );
+            const store = guaranteeNonNullable(stores[0]);
+            const data = new FunctionTestData();
+            if (store instanceof Database) {
+              const relation = new RelationElementsData();
+              data.element = PackageableElementExplicitReference.create(store);
+              data.data = relation;
+            } else if (store instanceof ModelStore) {
+              const modelStoreData = createBareExternalFormat();
+              data.element = PackageableElementExplicitReference.create(store);
+              data.data = modelStoreData;
+            } else {
+              throw new UnsupportedOperationError(
+                `function test store data does not support store: ${store.path}`,
+              );
+            }
+            functionSuite.testData = [data];
           }
-          functionSuite.testData = [data];
         } else {
           const type = this.function.returnType.value.rawType;
           if (

package/src/stores/editor/editor-state/element-editor-state/ingest/IngestDefinitionEditorState.ts

@@ -55,6 +55,12 @@ import type { AuthContextProps } from 'react-oidc-context';
 import { EXTERNAL_APPLICATION_NAVIGATION__generateUrlWithEditorConfig } from '../../../../../__lib__/LegendStudioNavigation.js';
 import { LineageState } from '@finos/legend-query-builder';
 import { LegendStudioTelemetryHelper } from '../../../../../__lib__/LegendStudioTelemetryHelper.js';
+import { IngestTestableState } from './IngestTestableState.js';
+
+export enum INGEST_DEFINITION_TAB {
+  DEFINITION = 'Definition',
+  TESTING = 'Testing',
+}
 
 const createEditorInitialConfiguration = (): EditorInitialConfiguration => {
   const config = new EditorInitialConfiguration();
@@ -80,11 +86,13 @@ export const generateUrlToDeployOnOpen = (
 
 const PARSER_SECTION = `###Lakehouse`;
 export class IngestDefinitionEditorState extends ElementEditorState {
+  selectedTab = INGEST_DEFINITION_TAB.DEFINITION;
   validateAndDeployResponse: ValidateAndDeploymentResponse | undefined;
   deploymentState = ActionState.create();
   lineageGenerationState = ActionState.create();
   deployOnOpen = false;
   lineageState: LineageState;
+  ingestTestableState: IngestTestableState;
 
   constructor(
     editorStore: EditorStore,
@@ -94,11 +102,13 @@ export class IngestDefinitionEditorState extends ElementEditorState {
     super(editorStore, element);
 
     makeObservable(this, {
+      selectedTab: observable,
       deploymentState: observable,
       deployOnOpen: observable,
       setDeployOnOpen: observable,
       validateAndDeployResponse: observable,
       deploymentResponse: computed,
+      setSelectedTab: action,
       setValidateAndDeployResponse: action,
       init_with_deploy: flow,
       deploy: flow,
@@ -112,6 +122,12 @@ export class IngestDefinitionEditorState extends ElementEditorState {
         config.elementEditorConfiguration.deployOnOpen ?? false;
     }
     this.lineageState = new LineageState(this.editorStore.applicationStore);
+    this.ingestTestableState = new IngestTestableState(this);
+    this.ingestTestableState.init();
+  }
+
+  setSelectedTab(val: INGEST_DEFINITION_TAB): void {
+    this.selectedTab = val;
   }
 
   get deploymentResponse():