@finos/legend-application-studio 26.1.8 → 26.1.9

package/src/stores/editor/editor-state/element-editor-state/service/ServiceEditorState.ts

@@ -20,6 +20,7 @@ import {
   type PlainObject,
   assertErrorThrown,
   guaranteeType,
+  returnUndefOnError,
 } from '@finos/legend-shared';
 import type { EditorStore } from '../../../EditorStore.js';
 import {
@@ -33,16 +34,19 @@ import { ServiceRegistrationState } from '../../../editor-state/element-editor-s
 import { ElementEditorState } from '../../../editor-state/element-editor-state/ElementEditorState.js';
 import {
   type PackageableElement,
-  type RawLambda,
+  type ValueSpecification,
   Service,
   PureSingleExecution,
   PureMultiExecution,
-  PureExecution,
   isStubbed_RawLambda,
+  getValueSpecificationReturnType,
+  type Type,
+  resolveServiceQueryRawLambda,
 } from '@finos/legend-graph';
 import { ServiceTestableState } from './testable/ServiceTestableState.js';
 import { User } from '@finos/legend-server-sdlc';
 import { ServicePostValidationsState } from './ServicePostValidationState.js';
+import { valueSpecReturnTDS } from '@finos/legend-query-builder';
 
 export enum SERVICE_TAB {
   GENERAL = 'GENERAL',
@@ -52,6 +56,45 @@ export enum SERVICE_TAB {
   POST_VALIDATION = 'POST_VALIDATION',
 }
 
+export const resolveServiceQueryValueSpec = (
+  service: Service,
+  editorStore: EditorStore,
+): ValueSpecification | undefined => {
+  const rawLambda = resolveServiceQueryRawLambda(service);
+  if (rawLambda) {
+    return editorStore.graphManagerState.graphManager.buildValueSpecification(
+      editorStore.graphManagerState.graphManager.serializeRawValueSpecification(
+        rawLambda,
+      ),
+      editorStore.graphManagerState.graph,
+    );
+  }
+  return undefined;
+};
+
+export const resolveServiceQueryReturnType = (
+  service: Service,
+  editorStore: EditorStore,
+): Type | undefined => {
+  const valueSpec = resolveServiceQueryValueSpec(service, editorStore);
+  if (valueSpec) {
+    return returnUndefOnError(() => getValueSpecificationReturnType(valueSpec));
+  }
+  return undefined;
+};
+
+export const isServiceQueryTDS = (
+  service: Service,
+  editorStore: EditorStore,
+): boolean => {
+  const valueSpec = resolveServiceQueryValueSpec(service, editorStore);
+  return Boolean(
+    valueSpec
+      ? valueSpecReturnTDS(valueSpec, editorStore.graphManagerState.graph)
+      : undefined,
+  );
+};
+
 export const MINIMUM_SERVICE_OWNERS = 2;
 export class ServiceEditorState extends ElementEditorState {
   executionState: ServiceExecutionState;
@@ -146,14 +189,6 @@ export class ServiceEditorState extends ElementEditorState {
     );
   }
 
-  get serviceQuery(): RawLambda | undefined {
-    const execution = this.service.execution;
-    if (execution instanceof PureExecution) {
-      return execution.func;
-    }
-    return undefined;
-  }
-
   *searchUsers(name: string): GeneratorFn<User[]> {
     try {
       return (

package/src/stores/editor/editor-state/element-editor-state/service/testable/ServiceTestDataState.ts

@@ -34,6 +34,8 @@ import {
   ConnectionPointer,
   reportGraphAnalytics,
   observe_ValueSpecification,
+  getAllIdentifiedConnectionsFromRuntime,
+  getAllIdentifiedServiceConnections,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -44,7 +46,6 @@ import {
   guaranteeNonNullable,
   returnUndefOnError,
   getNullableFirstEntry,
-  uniq,
 } from '@finos/legend-shared';
 import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../../EditorStore.js';
@@ -55,7 +56,6 @@ import {
 import {
   TEMPORARY__createRelationalDataFromCSV,
   EmbeddedDataConnectionTypeVisitor,
-  getAllIdentifiedConnectionsFromRuntime,
   TEMPORARY__EmbeddedDataConnectionVisitor,
 } from '../../../../utils/TestableUtils.js';
 import { EmbeddedDataType } from '../../../ExternalFormatState.js';
@@ -74,6 +74,18 @@ import {
   getExecutionQueryFromRawLambda,
 } from '@finos/legend-query-builder';
 
+export const createConnectionTestData = (
+  val: IdentifiedConnection,
+  embeddedDataType: string,
+  editorStore: EditorStore,
+): ConnectionTestData => {
+  const connectionTestData = new ConnectionTestData();
+  connectionTestData.connectionId = val.id;
+  const testData = createEmbeddedData(embeddedDataType, editorStore);
+  connectionTestData.testData = testData;
+  return connectionTestData;
+};
+
 export class ServiceTestDataParametersState extends LambdaParametersState {
   connectionTestDataState: ConnectionTestDataState;
 
@@ -140,6 +152,7 @@ export class ConnectionTestDataState {
   readonly connectionData: ConnectionTestData;
   readonly parametersState: ServiceTestDataParametersState;
   readonly generatingTestDataState = ActionState.create();
+  useSharedModal = false;
 
   embeddedEditorState: EmbeddedDataEditorState;
   anonymizeGeneratedData = true;
@@ -151,8 +164,10 @@ export class ConnectionTestDataState {
     makeObservable(this, {
       generatingTestDataState: observable,
       embeddedEditorState: observable,
+      useSharedModal: observable,
       anonymizeGeneratedData: observable,
       setAnonymizeGeneratedData: action,
+      changeEmbeddedData: action,
       generateTestData: flow,
       generateTestDataForDatabaseConnection: flow,
     });
@@ -171,6 +186,10 @@ export class ConnectionTestDataState {
     );
   }
 
+  setUseSharedModal(val: boolean): void {
+    this.useSharedModal = val;
+  }
+
   setAnonymizeGeneratedData(val: boolean): void {
     this.anonymizeGeneratedData = val;
   }
@@ -290,6 +309,18 @@ export class ConnectionTestDataState {
     }
   }
 
+  changeEmbeddedData(val: EmbeddedData): void {
+    service_setConnectionTestDataEmbeddedData(
+      this.connectionData,
+      val,
+      this.editorStore.changeDetectionState.observerContext,
+    );
+    this.embeddedEditorState = new EmbeddedDataEditorState(
+      this.testDataState.editorStore,
+      this.connectionData.testData,
+    );
+  }
+
   resolveConnectionValue(id: string): Connection | undefined {
     const connection = this.getAllIdentifiedConnections().find(
       (c) => c.id === id,
@@ -358,7 +389,10 @@ export class NewConnectionDataState {
 
   openModal(): void {
     this.setModal(true);
-    this.connection = this.testSuiteState.allIdentifiedConnections[0];
+    const service =
+      this.testSuiteState.testSuiteState.testableState.serviceEditorState
+        .service;
+    this.connection = getAllIdentifiedServiceConnections(service)[0];
     if (this.connection) {
       this.handleConnectionChange(this.connection);
     }
@@ -469,16 +503,4 @@ export class ServiceTestDataState {
       this.setSelectedDataState(new ConnectionTestDataState(this, val));
     }
   }
-  get allIdentifiedConnections(): IdentifiedConnection[] {
-    const service =
-      this.testSuiteState.testableState.serviceEditorState.service;
-    const execution = service.execution;
-    let runtimes: Runtime[] = [];
-    if (execution instanceof PureSingleExecution && execution.runtime) {
-      runtimes = [execution.runtime];
-    } else if (execution instanceof PureMultiExecution) {
-      runtimes = execution.executionParameters.map((t) => t.runtime);
-    }
-    return uniq(runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime));
-  }
 }

package/src/stores/editor/editor-state/element-editor-state/service/testable/ServiceTestEditorState.ts

@@ -31,9 +31,13 @@ import {
   LambdaFunctionInstanceValue,
   SimpleFunctionExpression,
   CollectionInstanceValue,
+  resolveServiceQueryRawLambda,
 } from '@finos/legend-graph';
 import { action, flow, makeObservable, observable } from 'mobx';
-import { TestableTestEditorState } from '../../testable/TestableEditorState.js';
+import {
+  TESTABLE_TEST_TAB,
+  TestableTestEditorState,
+} from '../../testable/TestableEditorState.js';
 import type { ServiceTestSuiteState } from './ServiceTestableState.js';
 import {
   service_addAssertKeyForTest,
@@ -70,9 +74,9 @@ export enum SERIALIZATION_FORMAT {
 }
 
 export enum SERIALIZATION_FORMAT_LABEL {
-  DEFAULT = 'DEFAULT',
   PURE = 'PURE',
-  TDS = 'TDS',
+  TABULAR_DATA = 'TABULAR DATA',
+  DEFAULT = 'DEFAULT',
 }
 
 const getSerializationFormatLabel = (val: string): string => {
@@ -82,7 +86,7 @@ const getSerializationFormatLabel = (val: string): string => {
     case SERIALIZATION_FORMAT.PURE:
       return SERIALIZATION_FORMAT.PURE;
     case SERIALIZATION_FORMAT.PURE_TDSOBJECT:
-      return SERIALIZATION_FORMAT_LABEL.TDS;
+      return SERIALIZATION_FORMAT_LABEL.TABULAR_DATA;
     default:
       return val;
   }
@@ -200,8 +204,7 @@ export class ServiceTestSetupState {
   }
 
   get queryVariableExpressions(): VariableExpression[] {
-    const query =
-      this.testState.suiteState.testableState.serviceEditorState.serviceQuery;
+    const query = resolveServiceQueryRawLambda(this.testState.service);
     return query
       ? buildLambdaVariableExpressions(
           query,
@@ -240,8 +243,7 @@ export class ServiceTestSetupState {
     binding: Binding;
     param: string;
   }[] {
-    const query =
-      this.testState.suiteState.testableState.serviceEditorState.serviceQuery;
+    const query = resolveServiceQueryRawLambda(this.testState.service);
     if (query && !isStubbed_RawLambda(query)) {
       // safely pass unsupported funtions when building ValueSpecification from Rawlambda
       try {
@@ -560,5 +562,10 @@ export class ServiceTestState extends TestableTestEditorState {
     this.suiteState = suiteState;
     this.testable = suiteState.testableState.serviceEditorState.service;
     this.setupState = new ServiceTestSetupState(this);
+    this.selectedTab = TESTABLE_TEST_TAB.SETUP;
+  }
+
+  get service(): Service {
+    return this.suiteState.testableState.service;
   }
 }

package/src/stores/editor/editor-state/element-editor-state/service/testable/ServiceTestableState.ts

@@ -28,6 +28,7 @@ import {
   TestError,
   MultiExecutionServiceTestResult,
   TestExecutionStatus,
+  getAllIdentifiedServiceConnections,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -39,31 +40,77 @@ import {
   isNonNullable,
   generateEnumerableNameFromToken,
   getNullableFirstEntry,
+  guaranteeNonNullable,
+  returnUndefOnError,
 } from '@finos/legend-shared';
 import { action, flow, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../../EditorStore.js';
 import {
+  service_addConnectionTestData,
   service_addTest,
   service_addTestSuite,
   service_deleteTestSuite,
 } from '../../../../../graph-modifier/DSL_Service_GraphModifierHelper.js';
-import { createEmptyEqualToJsonAssertion } from '../../../../utils/TestableUtils.js';
-import type { ServiceEditorState } from '../ServiceEditorState.js';
-import { ServiceTestDataState } from './ServiceTestDataState.js';
+import {
+  EmbeddedDataConnectionTypeVisitor,
+  createEmptyEqualToJsonAssertion,
+} from '../../../../utils/TestableUtils.js';
+import {
+  isServiceQueryTDS,
+  type ServiceEditorState,
+} from '../ServiceEditorState.js';
+import {
+  ServiceTestDataState,
+  createConnectionTestData,
+} from './ServiceTestDataState.js';
 import {
   SERIALIZATION_FORMAT,
   ServiceTestState,
 } from './ServiceTestEditorState.js';
 
-const createEmptyServiceTestSuite = (service: Service): ServiceTestSuite => {
+const createEmptyServiceTestSuite = (
+  serviceTestableState: ServiceTestableState,
+): ServiceTestSuite => {
+  // setup
+  const serviceEditorState = serviceTestableState.serviceEditorState;
+  const service = serviceEditorState.service;
   const suite = new ServiceTestSuite();
   suite.id = generateEnumerableNameFromToken(
     service.tests.map((s) => s.id),
     DEFAULT_TEST_SUITE_PREFIX,
   );
+  // data
   suite.testData = new TestData();
+  const connections = getAllIdentifiedServiceConnections(service);
+  if (connections.length === 1) {
+    const iVal = guaranteeNonNullable(connections[0]);
+    const connectionValue = iVal.connection;
+    const type = returnUndefOnError(() =>
+      connectionValue.accept_ConnectionVisitor(
+        new EmbeddedDataConnectionTypeVisitor(serviceEditorState.editorStore),
+      ),
+    );
+    if (type) {
+      const testData = createConnectionTestData(
+        iVal,
+        type,
+        serviceEditorState.editorStore,
+      );
+      service_addConnectionTestData(
+        suite,
+        testData,
+        serviceEditorState.editorStore.changeDetectionState.observerContext,
+      );
+    }
+  }
+  //
   const test = new ServiceTest();
-  test.serializationFormat = SERIALIZATION_FORMAT.PURE;
+  test.serializationFormat = isServiceQueryTDS(
+    serviceEditorState.service,
+    serviceEditorState.editorStore,
+  )
+    ? SERIALIZATION_FORMAT.PURE_TDSOBJECT
+    : SERIALIZATION_FORMAT.PURE;
   test.id = generateEnumerableNameFromToken([], DEFAULT_TEST_PREFIX);
   test.__parent = suite;
   suite.tests = [test];
@@ -258,6 +305,10 @@ export class ServiceTestableState {
     this.initSuites();
   }
 
+  get service(): Service {
+    return this.serviceEditorState.service;
+  }
+
   setSuiteToRename(testSuite: ServiceTestSuite | undefined): void {
     this.suiteToRename = testSuite;
   }
@@ -290,7 +341,7 @@ export class ServiceTestableState {
   }
 
   addTestSuite(): void {
-    const suite = createEmptyServiceTestSuite(this.serviceEditorState.service);
+    const suite = createEmptyServiceTestSuite(this);
     service_addTestSuite(
       this.serviceEditorState.service,
       suite,

package/src/stores/editor/editor-state/element-editor-state/testable/TestAssertionState.ts

@@ -45,8 +45,8 @@ import {
 import type { TestableTestEditorState } from './TestableEditorState.js';
 
 export enum TEST_ASSERTION_TAB {
-  ASSERTION_SETUP = 'ASSERTION_SETUP',
-  ASSERTION_RESULT = 'ASSERTION_RESULT',
+  SETUP = 'SETUP',
+  RESULT = 'RESULT',
 }
 
 export abstract class TestAssertionStatusState {
@@ -273,7 +273,7 @@ export class TestAssertionEditorState {
   assertionState: TestAssertionState;
   assertionResultState: TestAssertionResultState;
   assertion: TestAssertion;
-  selectedTab = TEST_ASSERTION_TAB.ASSERTION_SETUP;
+  selectedTab = TEST_ASSERTION_TAB.SETUP;
   generatingExpectedAction = ActionState.create();
   constructor(
     editorStore: EditorStore,
@@ -302,7 +302,7 @@ export class TestAssertionEditorState {
       this.generatingExpectedAction.inProgress();
       const bare = this.assertionState.generateBare();
       bare.parentTest = this.assertion.parentTest;
-      const status =
+      const assertFail =
         (yield this.editorStore.graphManagerState.graphManager.generateExpectedResult(
           this.testState.testable,
           this.testState.test,
@@ -310,13 +310,17 @@ export class TestAssertionEditorState {
           bare,
           this.editorStore.graphManagerState.graph,
         )) as AssertFail;
-      this.assertionState.generateExpected(status);
+      this.assertionState.generateExpected(assertFail);
       this.generatingExpectedAction.complete();
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `Expected results generated!`,
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(
-        `Error generating expected result: ${error.message}`,
+        `Error generating expected result, please check data input: ${error.message}.`,
       );
+      this.setSelectedTab(TEST_ASSERTION_TAB.SETUP);
       this.generatingExpectedAction.fail();
     }
   }

package/src/stores/editor/editor-state/element-editor-state/testable/TestableEditorState.ts

@@ -24,6 +24,7 @@ import {
   RunTestsTestableInput,
   TestSuite,
   TestExecutionStatus,
+  TestError,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -33,6 +34,7 @@ import {
   ActionState,
   addUniqueEntry,
   deleteEntry,
+  isNonNullable,
 } from '@finos/legend-shared';
 import { action, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../EditorStore.js';
@@ -66,7 +68,7 @@ export class TestableTestResultState {
 
 export enum TESTABLE_TEST_TAB {
   SETUP = 'SETUP',
-  ASSERTIONS = 'ASSERTIONS',
+  ASSERTION = 'ASSERTION',
 }
 
 export class TestableTestEditorState {
@@ -75,7 +77,7 @@ export class TestableTestEditorState {
   test: AtomicTest;
   selectedAsertionState: TestAssertionEditorState | undefined;
   assertionEditorStates: TestAssertionEditorState[] = [];
-  selectedTab = TESTABLE_TEST_TAB.ASSERTIONS;
+  selectedTab = TESTABLE_TEST_TAB.ASSERTION;
   assertionToRename: TestAssertion | undefined;
   runningTestAction = ActionState.create();
   testResultState: TestableTestResultState;
@@ -177,7 +179,7 @@ export class TestableTestEditorState {
     this.testResultState.setResult(testResult);
     this.assertionEditorStates.forEach((assertionState) => {
       assertionState.assertionResultState.setTestResult(testResult);
-      assertionState.setSelectedTab(TEST_ASSERTION_TAB.ASSERTION_RESULT);
+      assertionState.setSelectedTab(TEST_ASSERTION_TAB.RESULT);
     });
   }
 
@@ -211,3 +213,90 @@ export class TestableTestEditorState {
     ).length;
   }
 }
+
+export class TestableTestSuiteEditorState {
+  readonly editorStore: EditorStore;
+  testable: Testable;
+  suite: TestSuite;
+  isReadOnly: boolean;
+  testStates: TestableTestEditorState[] = [];
+  isRunningTest = ActionState.create();
+  selectTestState: TestableTestEditorState | undefined;
+
+  constructor(
+    testable: Testable,
+    suite: TestSuite,
+    isReadOnly: boolean,
+    editorStore: EditorStore,
+  ) {
+    this.testable = testable;
+    this.suite = suite;
+    this.isReadOnly = isReadOnly;
+    this.editorStore = editorStore;
+  }
+
+  *runSuite(): GeneratorFn<void> {
+    try {
+      this.isRunningTest.inProgress();
+      this.testStates.forEach((t) => t.resetResult());
+      this.testStates.forEach((t) => t.runningTestAction.inProgress());
+      const input = new RunTestsTestableInput(this.testable);
+      input.unitTestIds = this.suite.tests.map(
+        (t) => new UniqueTestId(this.suite, t),
+      );
+      const testResults =
+        (yield this.editorStore.graphManagerState.graphManager.runTests(
+          [input],
+          this.editorStore.graphManagerState.graph,
+        )) as TestResult[];
+      testResults.forEach((result) => {
+        const state = this.testStates.find((t) => t.test === result.atomicTest);
+        state?.handleTestResult(result);
+      });
+      this.isRunningTest.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      this.isRunningTest.fail();
+    } finally {
+      this.testStates.forEach((t) => t.runningTestAction.complete());
+    }
+  }
+
+  *runFailingTests(): GeneratorFn<void> {
+    try {
+      this.isRunningTest.inProgress();
+      const input = new RunTestsTestableInput(this.testable);
+      input.unitTestIds = this.testStates
+        .map((testState) => {
+          const result = testState.testResultState.result;
+          if (
+            (result instanceof TestExecuted &&
+              result.testExecutionStatus === TestExecutionStatus.FAIL) ||
+            result instanceof TestError
+          ) {
+            testState.runningTestAction.inProgress();
+            return new UniqueTestId(this.suite, testState.test);
+          }
+          return undefined;
+        })
+        .filter(isNonNullable);
+      const testResults =
+        (yield this.editorStore.graphManagerState.graphManager.runTests(
+          [input],
+          this.editorStore.graphManagerState.graph,
+        )) as TestResult[];
+      testResults.forEach((result) => {
+        const state = this.testStates.find((t) => t.test === result.atomicTest);
+        state?.handleTestResult(result);
+      });
+      this.isRunningTest.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      this.isRunningTest.fail();
+    } finally {
+      this.testStates.forEach((t) => t.runningTestAction.complete());
+    }
+  }
+}

package/src/stores/editor/utils/MockDataUtils.ts

@@ -21,10 +21,12 @@ import {
   Randomizer,
   UnsupportedOperationError,
   type PlainObject,
+  isNonNullable,
+  filterByType,
 } from '@finos/legend-shared';
 import type { EditorStore } from '../EditorStore.js';
 import {
-  type PrimitiveType,
+  PrimitiveType,
   type Enumeration,
   PRIMITIVE_TYPE,
   Class,
@@ -32,6 +34,28 @@ import {
   DATE_FORMAT,
   DATE_TIME_FORMAT,
   classHasCycle,
+  TableAlias,
+  Table,
+  Column,
+  VarChar,
+  type RelationalDataType,
+  Char,
+  VarBinary,
+  TinyInt,
+  Float,
+  Timestamp,
+  Binary,
+  Bit,
+  Other,
+  Numeric,
+  Decimal,
+  Double,
+  Integer,
+  Real,
+  SmallInt,
+  Date as ColumnDate,
+  SemiStructured,
+  Json,
 } from '@finos/legend-graph';
 import {
   CLASS_PROPERTY_TYPE,
@@ -182,6 +206,85 @@ export const createMockDataForClassWithFormat = (
   }
 };
 
+export const getPrimitiveTypeFromRelationalType = (
+  type: RelationalDataType,
+): PrimitiveType | undefined => {
+  if (
+    type instanceof VarChar ||
+    type instanceof Char ||
+    type instanceof VarBinary ||
+    type instanceof Binary ||
+    type instanceof Bit ||
+    type instanceof Other
+  ) {
+    return PrimitiveType.STRING;
+  } else if (type instanceof Numeric) {
+    return PrimitiveType.NUMBER;
+  } else if (type instanceof Decimal) {
+    return PrimitiveType.DECIMAL;
+  } else if (
+    type instanceof Double ||
+    type instanceof Integer ||
+    type instanceof Real ||
+    type instanceof SmallInt ||
+    type instanceof TinyInt
+  ) {
+    return PrimitiveType.INTEGER;
+  } else if (type instanceof Float) {
+    return PrimitiveType.FLOAT;
+  } else if (type instanceof ColumnDate) {
+    return PrimitiveType.DATE;
+  } else if (type instanceof Timestamp) {
+    return PrimitiveType.DATETIME;
+  }
+  return undefined;
+};
+export const createMockDataForColumn = (
+  col: Column,
+  isPrimaryKey: boolean,
+  idx?: number | number,
+): string | undefined => {
+  const type = col.type;
+
+  if (
+    (type instanceof Double ||
+      type instanceof Integer ||
+      type instanceof Real ||
+      type instanceof SmallInt ||
+      type instanceof TinyInt) &&
+    isPrimaryKey &&
+    idx
+  ) {
+    return idx.toString();
+  }
+  const primitive = getPrimitiveTypeFromRelationalType(type);
+  if (primitive) {
+    return createMockPrimitiveProperty(primitive, col.name).toString();
+  } else if (type instanceof Json || type instanceof SemiStructured) {
+    return '{}';
+  }
+  return undefined;
+};
+
+export const createMockDataForTable = (
+  table: Table,
+  ITERATIONS = 1,
+): string => {
+  const targetedCols = table.columns.filter(filterByType(Column));
+  const colNames = targetedCols.map((e) => e.name).join(',');
+  const vals = Array.from(Array(ITERATIONS).keys())
+    .map((idx) =>
+      targetedCols
+        .map((col) =>
+          createMockDataForColumn(col, table.primaryKey.includes(col), idx),
+        )
+        .filter(isNonNullable)
+        .join(','),
+    )
+    .join('\n');
+  return `${colNames}\n${vals}`;
+};
+
 export const createMockDataForMappingElementSource = (
   srcElement: MappingElementSource,
   editorStore: EditorStore,
@@ -200,6 +303,11 @@ export const createMockDataForMappingElementSource = (
       );
       return '';
     }
+  } else if (
+    srcElement instanceof TableAlias &&
+    srcElement.relation instanceof Table
+  ) {
+    return createMockDataForTable(srcElement.relation);
   }
   editorStore.applicationStore.notificationService.notifyWarning(
     new UnsupportedOperationError(