@finos/legend-application-studio 27.0.0 → 27.1.1

package/src/stores/editor/editor-state/element-editor-state/mapping/testable/MappingTestingHelper.ts

@@ -0,0 +1,243 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  LambdaFunction,
+  type Class,
+  type GraphManagerState,
+  type RawLambda,
+  type SetImplementation,
+  type MappingTestSuite,
+  type GraphFetchTree,
+  type MappingModelCoverageAnalysisResult,
+  RootGraphFetchTree,
+  PackageableElementExplicitReference,
+  FunctionType,
+  CORE_PURE_PATH,
+  Multiplicity,
+  buildRawLambdaFromLambdaFunction,
+  StoreTestData,
+  RelationalInstanceSetImplementation,
+  EmbeddedRelationalInstanceSetImplementation,
+  TableAlias,
+  RelationalCSVData,
+  Table,
+  RelationalCSVDataTable,
+  PureInstanceSetImplementation,
+  MappingTest,
+  ModelStore,
+  EntityMappedProperty,
+  getAllClassProperties,
+  getAllClassDerivedProperties,
+  PropertyGraphFetchTree,
+  PropertyExplicitReference,
+} from '@finos/legend-graph';
+import {
+  buildGetAllFunction,
+  buildSerialzieFunctionWithGraphFetch,
+} from '@finos/legend-query-builder';
+import type { EditorStore } from '../../../../EditorStore.js';
+import { getMappingElementSource } from '../MappingEditorState.js';
+import { createMockDataForTable } from '../../../../utils/MockDataUtils.js';
+import {
+  DEFAULT_TEST_ASSERTION_ID,
+  createBareModelStoreData,
+  createDefaultEqualToJSONTestAssertion,
+} from '../../../../utils/TestableUtils.js';
+import {
+  assertErrorThrown,
+  assertTrue,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+
+export const createGraphFetchRawLambda = (
+  mainClass: Class,
+  graphManagerState: GraphManagerState,
+  root: RootGraphFetchTree,
+): RawLambda => {
+  const lambdaFunction = new LambdaFunction(
+    new FunctionType(
+      PackageableElementExplicitReference.create(
+        graphManagerState.graph.getType(CORE_PURE_PATH.ANY),
+      ),
+      Multiplicity.ONE,
+    ),
+  );
+  const getAllFunction = buildGetAllFunction(mainClass, Multiplicity.ONE);
+  const serialize = buildSerialzieFunctionWithGraphFetch(
+    root,
+    false,
+    getAllFunction,
+    undefined,
+  );
+  lambdaFunction.expressionSequence = [serialize];
+  return buildRawLambdaFromLambdaFunction(lambdaFunction, graphManagerState);
+};
+
+export const createStoreBareModelStoreData = (
+  _class: Class,
+  editorStore: EditorStore,
+): StoreTestData => {
+  const modelStoreData = createBareModelStoreData(_class, editorStore);
+  const testData = new StoreTestData();
+  testData.data = modelStoreData;
+  testData.store = PackageableElementExplicitReference.create(
+    ModelStore.INSTANCE,
+  );
+  return testData;
+};
+
+export const generateStoreTestDataFromSetImpl = (
+  setImpl: SetImplementation,
+  editorStore: EditorStore,
+  tryAndMockTable?: boolean,
+): StoreTestData | undefined => {
+  if (
+    setImpl instanceof RelationalInstanceSetImplementation ||
+    setImpl instanceof EmbeddedRelationalInstanceSetImplementation ||
+    setImpl instanceof EmbeddedRelationalInstanceSetImplementation
+  ) {
+    const _table = getMappingElementSource(
+      setImpl,
+      editorStore.pluginManager.getApplicationPlugins(),
+    );
+    if (_table instanceof TableAlias) {
+      const relation = _table.relation.value;
+      const owner = relation.schema._OWNER;
+      const val = new RelationalCSVData();
+      if (tryAndMockTable && relation instanceof Table) {
+        const mockTable = new RelationalCSVDataTable();
+        const values = createMockDataForTable(relation);
+        mockTable.table = relation.name;
+        mockTable.schema = relation.schema.name;
+        mockTable.values = values;
+        val.tables.push(mockTable);
+      }
+      const testData = new StoreTestData();
+      testData.data = val;
+      testData.store = PackageableElementExplicitReference.create(owner);
+      return testData;
+    }
+  } else if (setImpl instanceof PureInstanceSetImplementation) {
+    const srcClass = setImpl.srcClass;
+    if (srcClass) {
+      return createStoreBareModelStoreData(srcClass.value, editorStore);
+    }
+  }
+  return undefined;
+};
+
+export const createBareMappingTest = (
+  id: string,
+  storeTestData: StoreTestData | undefined,
+  suite?: MappingTestSuite | undefined,
+): MappingTest => {
+  const mappingTest = new MappingTest();
+  mappingTest.id = id;
+  mappingTest.storeTestData = storeTestData ? [storeTestData] : [];
+  mappingTest.assertions = [
+    createDefaultEqualToJSONTestAssertion(DEFAULT_TEST_ASSERTION_ID),
+  ];
+  if (suite) {
+    mappingTest.__parent = suite;
+    suite.tests.push(mappingTest);
+  }
+  const assertion = createDefaultEqualToJSONTestAssertion(`expectedAssertion`);
+  mappingTest.assertions = [assertion];
+  assertion.parentTest = mappingTest;
+  return mappingTest;
+};
+
+const addPropertySubTreeIfPossible = (
+  rootTree: GraphFetchTree,
+  _class: Class,
+  propertyName: string,
+): PropertyGraphFetchTree | undefined => {
+  const property = getAllClassProperties(_class)
+    .concat(
+      // we fetch mapped derived properties without parameters
+      getAllClassDerivedProperties(_class).filter(
+        (p) => !p.parameters || !(p.parameters as object[]).length,
+      ),
+    )
+    .find((prop) => prop.name === propertyName);
+  if (property) {
+    const subTree = new PropertyGraphFetchTree(
+      PropertyExplicitReference.create(property),
+      undefined,
+    );
+    rootTree.subTrees.push(subTree);
+    return subTree;
+  }
+  return undefined;
+};
+
+export const createGraphFetchQueryFromMappingAnalysis = (
+  _class: Class,
+  graphManagerState: GraphManagerState,
+  mappingModelCoverageAnalysisResult:
+    | MappingModelCoverageAnalysisResult
+    | undefined,
+): RawLambda => {
+  try {
+    const anaylsis = guaranteeNonNullable(mappingModelCoverageAnalysisResult);
+    const mappedEntity = guaranteeNonNullable(
+      anaylsis.mappedEntities.find((e) => e.path === _class.path),
+    );
+    const rootTree = new RootGraphFetchTree(
+      PackageableElementExplicitReference.create(_class),
+    );
+    // TODO: allow complex properties
+    mappedEntity.properties.forEach((mapped) => {
+      const subTree = addPropertySubTreeIfPossible(
+        rootTree,
+        _class,
+        mapped.name,
+      );
+      if (mapped instanceof EntityMappedProperty && subTree) {
+        const entityPath = mapped.entityPath;
+        const entityClass =
+          graphManagerState.graph.getNullableClass(entityPath);
+        const firstLevelEntity = anaylsis.mappedEntities.find(
+          (e) => e.path === entityPath,
+        );
+        if (entityClass && firstLevelEntity) {
+          firstLevelEntity.properties.forEach((e) => {
+            if (!(e instanceof EntityMappedProperty)) {
+              addPropertySubTreeIfPossible(subTree, entityClass, e.name);
+            }
+          });
+        }
+      }
+    });
+    assertTrue(!rootTree.isEmpty);
+    return createGraphFetchRawLambda(_class, graphManagerState, rootTree);
+  } catch (error) {
+    assertErrorThrown(error);
+    const lambdaFunction = new LambdaFunction(
+      new FunctionType(
+        PackageableElementExplicitReference.create(
+          graphManagerState.graph.getType(CORE_PURE_PATH.ANY),
+        ),
+        Multiplicity.ONE,
+      ),
+    );
+    lambdaFunction.expressionSequence = [
+      buildGetAllFunction(_class, Multiplicity.ONE),
+    ];
+    return buildRawLambdaFromLambdaFunction(lambdaFunction, graphManagerState);
+  }
+};

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

@@ -76,7 +76,9 @@ export const resolveServiceQueryReturnType = (
   service: Service,
   editorStore: EditorStore,
 ): Type | undefined => {
-  const valueSpec = resolveServiceQueryValueSpec(service, editorStore);
+  const valueSpec = returnUndefOnError(() =>
+    resolveServiceQueryValueSpec(service, editorStore),
+  );
   if (valueSpec) {
     return returnUndefOnError(() => getValueSpecificationReturnType(valueSpec));
   }
@@ -87,7 +89,9 @@ export const isServiceQueryTDS = (
   service: Service,
   editorStore: EditorStore,
 ): boolean => {
-  const valueSpec = resolveServiceQueryValueSpec(service, editorStore);
+  const valueSpec = returnUndefOnError(() =>
+    resolveServiceQueryValueSpec(service, editorStore),
+  );
   return Boolean(
     valueSpec
       ? valueSpecReturnTDS(valueSpec, editorStore.graphManagerState.graph)

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

@@ -36,6 +36,7 @@ import {
   observe_ValueSpecification,
   getAllIdentifiedConnectionsFromRuntime,
   getAllIdentifiedServiceConnections,
+  Database,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -63,7 +64,10 @@ import {
   type EmbeddedDataTypeOption,
   EmbeddedDataEditorState,
 } from '../../data/DataEditorState.js';
-import { createEmbeddedData } from '../../data/EmbeddedDataState.js';
+import {
+  RelationalCSVDataState,
+  createEmbeddedData,
+} from '../../data/EmbeddedDataState.js';
 import type { ServiceTestSuiteState } from './ServiceTestableState.js';
 import { LegendStudioTelemetryHelper } from '../../../../../../__lib__/LegendStudioTelemetryHelper.js';
 import {
@@ -168,6 +172,7 @@ export class ConnectionTestDataState {
       anonymizeGeneratedData: observable,
       setAnonymizeGeneratedData: action,
       changeEmbeddedData: action,
+      buildEmbeddedEditorState: action,
       generateTestData: flow,
       generateTestDataForDatabaseConnection: flow,
     });
@@ -179,6 +184,7 @@ export class ConnectionTestDataState {
       connectionData.testData,
     );
     this.parametersState = new ServiceTestDataParametersState(this);
+    this.buildEmbeddedEditorState();
   }
   get identifiedConnection(): IdentifiedConnection | undefined {
     return this.getAllIdentifiedConnections().find(
@@ -186,6 +192,17 @@ export class ConnectionTestDataState {
     );
   }
 
+  buildEmbeddedEditorState(): void {
+    const val = this.identifiedConnection?.connection.store.value;
+    if (
+      this.embeddedEditorState.embeddedDataState instanceof
+        RelationalCSVDataState &&
+      val instanceof Database
+    ) {
+      this.embeddedEditorState.embeddedDataState.setDatabase(val);
+    }
+  }
+
   setUseSharedModal(val: boolean): void {
     this.useSharedModal = val;
   }

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

@@ -81,10 +81,10 @@ const createEmptyServiceTestSuite = (
   );
   // data
   suite.testData = new TestData();
-  const connections = getAllIdentifiedServiceConnections(service);
-  if (connections.length === 1) {
-    const iVal = guaranteeNonNullable(connections[0]);
-    const connectionValue = iVal.connection;
+  const identifiedConnections = getAllIdentifiedServiceConnections(service);
+  if (identifiedConnections.length === 1) {
+    const connectionVal = guaranteeNonNullable(identifiedConnections[0]);
+    const connectionValue = connectionVal.connection;
     const type = returnUndefOnError(() =>
       connectionValue.accept_ConnectionVisitor(
         new EmbeddedDataConnectionTypeVisitor(serviceEditorState.editorStore),
@@ -92,7 +92,7 @@ const createEmptyServiceTestSuite = (
     );
     if (type) {
       const testData = createConnectionTestData(
-        iVal,
+        connectionVal,
         type,
         serviceEditorState.editorStore,
       );
@@ -341,12 +341,20 @@ export class ServiceTestableState {
   }
 
   addTestSuite(): void {
-    const suite = createEmptyServiceTestSuite(this);
-    service_addTestSuite(
-      this.serviceEditorState.service,
-      suite,
-      this.serviceEditorState.editorStore.changeDetectionState.observerContext,
-    );
-    this.selectedSuiteState = new ServiceTestSuiteState(suite, this);
+    try {
+      const suite = createEmptyServiceTestSuite(this);
+      service_addTestSuite(
+        this.serviceEditorState.service,
+        suite,
+        this.serviceEditorState.editorStore.changeDetectionState
+          .observerContext,
+      );
+      this.selectedSuiteState = new ServiceTestSuiteState(suite, this);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Unable to create service test suite: ${error.message}`,
+      );
+    }
   }
 }

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

@@ -34,8 +34,13 @@ import {
   assertErrorThrown,
   ContentType,
   UnsupportedOperationError,
+  assertTrue,
+  isNonNullable,
+  IllegalStateError,
+  guaranteeNonNullable,
+  guaranteeType,
 } from '@finos/legend-shared';
-import { action, flow, makeObservable, observable } from 'mobx';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../EditorStore.js';
 import { externalFormatData_setData } from '../../../../graph-modifier/DSL_Data_GraphModifierHelper.js';
 import {
@@ -43,9 +48,10 @@ import {
   TESTABLE_RESULT,
 } from '../../../sidebar-state/testable/GlobalTestRunnerState.js';
 import type { TestableTestEditorState } from './TestableEditorState.js';
+import { isTestPassing } from '../../../utils/TestableUtils.js';
 
 export enum TEST_ASSERTION_TAB {
-  SETUP = 'SETUP',
+  EXPECTED = 'EXPECTED',
   RESULT = 'RESULT',
 }
 
@@ -221,11 +227,13 @@ export abstract class TestAssertionState {
     this.result = new TestAssertionResultState(editorStore, assertionState);
   }
 
-  abstract generateExpected(status: AssertFail): void;
+  abstract generateExpected(status: AssertFail): boolean;
 
   abstract generateBare(): TestAssertion;
 
   abstract label(): string;
+
+  abstract get supportsGeneratingAssertion(): boolean;
 }
 
 export class EqualToJsonAssertionState extends TestAssertionState {
@@ -235,11 +243,17 @@ export class EqualToJsonAssertionState extends TestAssertionState {
     externalFormatData_setData(this.assertion.expected, val);
   }
 
-  generateExpected(status: AssertFail): void {
+  override get supportsGeneratingAssertion(): boolean {
+    return true;
+  }
+
+  generateExpected(status: AssertFail): boolean {
     if (status instanceof EqualToJsonAssertFail) {
       const expected = status.actual;
       this.setExpectedValue(expected);
+      return true;
     }
+    return false;
   }
   generateBare(): TestAssertion {
     const bareAssertion = new EqualToJson();
@@ -255,11 +269,14 @@ export class EqualToJsonAssertionState extends TestAssertionState {
 }
 
 export class UnsupportedAssertionState extends TestAssertionState {
+  override get supportsGeneratingAssertion(): boolean {
+    return false;
+  }
   generateBare(): TestAssertion {
     throw new UnsupportedOperationError();
   }
-  generateExpected(status: AssertFail): void {
-    return;
+  generateExpected(status: AssertFail): boolean {
+    return false;
   }
 
   label(): string {
@@ -273,7 +290,7 @@ export class TestAssertionEditorState {
   assertionState: TestAssertionState;
   assertionResultState: TestAssertionResultState;
   assertion: TestAssertion;
-  selectedTab = TEST_ASSERTION_TAB.SETUP;
+  selectedTab = TEST_ASSERTION_TAB.EXPECTED;
   generatingExpectedAction = ActionState.create();
   constructor(
     editorStore: EditorStore,
@@ -299,18 +316,59 @@ export class TestAssertionEditorState {
 
   *generateExpected(): GeneratorFn<void> {
     try {
+      assertTrue(
+        this.assertionState.supportsGeneratingAssertion,
+        'Assertion does not support generation',
+      );
       this.generatingExpectedAction.inProgress();
-      const bare = this.assertionState.generateBare();
-      bare.parentTest = this.assertion.parentTest;
-      const assertFail =
-        (yield this.editorStore.graphManagerState.graphManager.generateExpectedResult(
-          this.testState.testable,
-          this.testState.test,
+      const result = (yield flowResult(
+        this.testState.fetchTestResult(),
+      )) as TestResult;
+      let testExecuted: TestExecuted;
+      if (result instanceof TestExecuted) {
+        testExecuted = result;
+      } else if (result instanceof MultiExecutionServiceTestResult) {
+        testExecuted = guaranteeNonNullable(
+          Array.from(result.keyIndexedTestResults.values())
+            .map((testResult) => {
+              if (testResult instanceof TestExecuted) {
+                return testResult;
+              } else if (testResult instanceof TestError) {
+                throw new IllegalStateError(testResult.error);
+              }
+              return undefined;
+            })
+            .filter(isNonNullable)[0],
+          'Unable to derive expected result from test result',
+        );
+      } else {
+        throw new UnsupportedOperationError(
+          'Unable to derive expected result from test result',
+        );
+      }
+      // if test is passing, update UI and return
+      // if test errors report error
+      if (isTestPassing(testExecuted)) {
+        this.testState.handleTestResult(testExecuted);
+        return;
+      } else if (testExecuted instanceof TestError) {
+        throw new IllegalStateError(testExecuted.error);
+      }
+      const assertionStatus = testExecuted.assertStatuses.find(
+        (aStatus) =>
+          aStatus.assertion.id === this.assertion.id &&
+          aStatus instanceof AssertFail,
+      );
+      const assertFail = guaranteeType(
+        assertionStatus,
+        AssertFail,
+        'Unable to derive expected result from test result',
+      );
+      const generated = this.assertionState.generateExpected(assertFail);
 
-          bare,
-          this.editorStore.graphManagerState.graph,
-        )) as AssertFail;
-      this.assertionState.generateExpected(assertFail);
+      if (generated) {
+        this.setSelectedTab(TEST_ASSERTION_TAB.EXPECTED);
+      }
       this.generatingExpectedAction.complete();
       this.editorStore.applicationStore.notificationService.notifySuccess(
         `Expected results generated!`,
@@ -320,7 +378,7 @@ export class TestAssertionEditorState {
       this.editorStore.applicationStore.notificationService.notifyError(
         `Error generating expected result, please check data input: ${error.message}.`,
       );
-      this.setSelectedTab(TEST_ASSERTION_TAB.SETUP);
+      this.setSelectedTab(TEST_ASSERTION_TAB.EXPECTED);
       this.generatingExpectedAction.fail();
     }
   }

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

@@ -36,7 +36,7 @@ import {
   deleteEntry,
   isNonNullable,
 } from '@finos/legend-shared';
-import { action, makeObservable, observable } from 'mobx';
+import { action, flowResult, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../EditorStore.js';
 import { atomicTest_addAssertion } from '../../../../graph-modifier/Testable_GraphModifierHelper.js';
 import { createEmptyEqualToJsonAssertion } from '../../../utils/TestableUtils.js';
@@ -141,22 +141,7 @@ export class TestableTestEditorState {
     try {
       this.resetResult();
       this.runningTestAction.inProgress();
-      const input = new RunTestsTestableInput(this.testable);
-      const suite =
-        this.test.__parent instanceof TestSuite
-          ? this.test.__parent
-          : undefined;
-      input.unitTestIds.push(new UniqueTestId(suite, this.test));
-      const testResults =
-        (yield this.editorStore.graphManagerState.graphManager.runTests(
-          [input],
-          this.editorStore.graphManagerState.graph,
-        )) as TestResult[];
-      const result = guaranteeNonNullable(testResults[0]);
-      assertTrue(
-        result.testable === this.testable && result.atomicTest === this.test,
-        'Unexpected test result',
-      );
+      const result = (yield flowResult(this.fetchTestResult())) as TestResult;
       this.handleTestResult(result);
       this.runningTestAction.complete();
     } catch (error) {
@@ -168,6 +153,26 @@ export class TestableTestEditorState {
     }
   }
 
+  // Fetches test results. Caller of test should catch the error
+  async fetchTestResult(): Promise<TestResult> {
+    const input = new RunTestsTestableInput(this.testable);
+    const suite =
+      this.test.__parent instanceof TestSuite ? this.test.__parent : undefined;
+    input.unitTestIds.push(new UniqueTestId(suite, this.test));
+    const testResults =
+      await this.editorStore.graphManagerState.graphManager.runTests(
+        [input],
+        this.editorStore.graphManagerState.graph,
+      );
+    const result = guaranteeNonNullable(testResults[0]);
+    assertTrue(
+      result.testable === this.testable &&
+        result.atomicTest.id === this.test.id,
+      'Unexpected test result',
+    );
+    return result;
+  }
+
   resetResult(): void {
     this.testResultState.setResult(undefined);
     this.assertionEditorStates.forEach((assertionState) =>
@@ -220,7 +225,7 @@ export class TestableTestSuiteEditorState {
   suite: TestSuite;
   isReadOnly: boolean;
   testStates: TestableTestEditorState[] = [];
-  isRunningTest = ActionState.create();
+  runningSuiteState = ActionState.create();
   selectTestState: TestableTestEditorState | undefined;
 
   constructor(
@@ -237,7 +242,7 @@ export class TestableTestSuiteEditorState {
 
   *runSuite(): GeneratorFn<void> {
     try {
-      this.isRunningTest.inProgress();
+      this.runningSuiteState.inProgress();
       this.testStates.forEach((t) => t.resetResult());
       this.testStates.forEach((t) => t.runningTestAction.inProgress());
       const input = new RunTestsTestableInput(this.testable);
@@ -253,11 +258,11 @@ export class TestableTestSuiteEditorState {
         const state = this.testStates.find((t) => t.test === result.atomicTest);
         state?.handleTestResult(result);
       });
-      this.isRunningTest.complete();
+      this.runningSuiteState.complete();
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
-      this.isRunningTest.fail();
+      this.runningSuiteState.fail();
     } finally {
       this.testStates.forEach((t) => t.runningTestAction.complete());
     }
@@ -265,7 +270,7 @@ export class TestableTestSuiteEditorState {
 
   *runFailingTests(): GeneratorFn<void> {
     try {
-      this.isRunningTest.inProgress();
+      this.runningSuiteState.inProgress();
       const input = new RunTestsTestableInput(this.testable);
       input.unitTestIds = this.testStates
         .map((testState) => {
@@ -290,11 +295,11 @@ export class TestableTestSuiteEditorState {
         const state = this.testStates.find((t) => t.test === result.atomicTest);
         state?.handleTestResult(result);
       });
-      this.isRunningTest.complete();
+      this.runningSuiteState.complete();
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
-      this.isRunningTest.fail();
+      this.runningSuiteState.fail();
     } finally {
       this.testStates.forEach((t) => t.runningTestAction.complete());
     }