@finos/legend-application-studio 28.14.1 → 28.14.2

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

@@ -15,7 +15,6 @@
  */
 
 import {
-  type Binding,
   type ServiceTest,
   type Service,
   type ValueSpecification,
@@ -24,16 +23,7 @@ import {
   buildLambdaVariableExpressions,
   VariableExpression,
   PureMultiExecution,
-  PackageableElementImplicitReference,
-  matchFunctionName,
-  isStubbed_RawLambda,
-  InstanceValue,
-  LambdaFunctionInstanceValue,
-  SimpleFunctionExpression,
-  CollectionInstanceValue,
   resolveServiceQueryRawLambda,
-  PrimitiveInstanceValue,
-  PrimitiveType,
 } from '@finos/legend-graph';
 import { action, flow, makeObservable, observable } from 'mobx';
 import {
@@ -59,15 +49,9 @@ import {
   isNonNullable,
   returnUndefOnError,
   uuid,
-  getNullableFirstEntry,
-  LogEvent,
 } from '@finos/legend-shared';
 import type { EditorStore } from '../../../../EditorStore.js';
-import {
-  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
-  generateVariableExpressionMockValue,
-} from '@finos/legend-query-builder';
-import { LEGEND_STUDIO_APP_EVENT } from '../../../../../../__lib__/LegendStudioEvent.js';
+import { generateVariableExpressionMockValue } from '@finos/legend-query-builder';
 
 export enum SERIALIZATION_FORMAT {
   PURE = 'PURE',
@@ -199,7 +183,6 @@ export class ServiceTestSetupState {
       addServiceTestAssertKeys: action,
       syncWithQuery: action,
       removeParamValueState: action,
-      getContentTypeWithParamFromQuery: action,
     });
 
     this.testState = testState;
@@ -243,131 +226,6 @@ export class ServiceTestSetupState {
     }));
   }
 
-  getContentTypeWithParamFromQuery(): {
-    contentType: string;
-    param: string;
-  }[] {
-    const query = resolveServiceQueryRawLambda(this.testState.service);
-    if (query && !isStubbed_RawLambda(query)) {
-      // safely pass unsupported funtions when building ValueSpecification from Rawlambda
-      try {
-        const valueSpec =
-          this.editorStore.graphManagerState.graphManager.buildValueSpecification(
-            this.editorStore.graphManagerState.graphManager.serializeRawValueSpecification(
-              query,
-            ),
-            this.editorStore.graphManagerState.graph,
-          );
-        if (valueSpec instanceof LambdaFunctionInstanceValue) {
-          return this.getContentTypeWithParamRecursively(
-            valueSpec.values[0]?.expressionSequence.find(
-              (exp) =>
-                exp instanceof SimpleFunctionExpression &&
-                (matchFunctionName(
-                  exp.functionName,
-                  QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE,
-                ) ||
-                  matchFunctionName(
-                    exp.functionName,
-                    QUERY_BUILDER_SUPPORTED_FUNCTIONS.EXTERNALIZE,
-                  )),
-            ),
-          );
-        }
-      } catch (error) {
-        this.editorStore.applicationStore.logService.error(
-          LogEvent.create(LEGEND_STUDIO_APP_EVENT.SERVICE_TEST_SETUP_FAILURE),
-          error,
-        );
-      }
-    }
-    return [];
-  }
-
-  getContentTypeWithParamRecursively(
-    expression: ValueSpecification | undefined,
-  ): {
-    contentType: string;
-    param: string;
-  }[] {
-    let currentExpression = expression;
-    const res: {
-      contentType: string;
-      param: string;
-    }[] = [];
-    // use if statement to safely scan service query without breaking the app
-    while (currentExpression instanceof SimpleFunctionExpression) {
-      if (
-        matchFunctionName(
-          currentExpression.functionName,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.INTERNALIZE,
-        ) ||
-        matchFunctionName(
-          currentExpression.functionName,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_RUNTIME_WITH_MODEL_QUERY_CONNECTION,
-        )
-      ) {
-        if (currentExpression.parametersValues[1] instanceof InstanceValue) {
-          if (
-            currentExpression.parametersValues[1].values[0] instanceof
-              PackageableElementImplicitReference &&
-            currentExpression.parametersValues[2] instanceof VariableExpression
-          ) {
-            res.push({
-              contentType: (
-                currentExpression.parametersValues[1].values[0].value as Binding
-              ).contentType,
-              param: currentExpression.parametersValues[2].name,
-            });
-          } else if (
-            matchFunctionName(
-              currentExpression.functionName,
-              QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_RUNTIME_WITH_MODEL_QUERY_CONNECTION,
-            ) &&
-            currentExpression.parametersValues[1] instanceof
-              PrimitiveInstanceValue &&
-            currentExpression.parametersValues[1].genericType.value.rawType ===
-              PrimitiveType.STRING &&
-            currentExpression.parametersValues[2] instanceof VariableExpression
-          ) {
-            res.push({
-              contentType: currentExpression.parametersValues[1]
-                .values[0] as string,
-              param: currentExpression.parametersValues[2].name,
-            });
-          }
-        }
-        currentExpression = currentExpression.parametersValues[1];
-      } else if (
-        matchFunctionName(
-          currentExpression.functionName,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.FROM,
-        )
-      ) {
-        currentExpression = currentExpression.parametersValues[2];
-      } else if (
-        matchFunctionName(
-          currentExpression.functionName,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.MERGERUNTIMES,
-        )
-      ) {
-        const collection = currentExpression.parametersValues[0];
-        if (collection instanceof CollectionInstanceValue) {
-          collection.values
-            .map((v) => this.getContentTypeWithParamRecursively(v))
-            .flat()
-            .map((p) => res.push(p));
-        }
-        currentExpression = collection;
-      } else {
-        currentExpression = getNullableFirstEntry(
-          currentExpression.parametersValues,
-        );
-      }
-    }
-    return res;
-  }
-
   addServiceTestAssertKeys(val: string[]): void {
     service_addAssertKeyForTest(this.testState.test, val);
   }

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

@@ -36,6 +36,7 @@ import {
   addUniqueEntry,
   deleteEntry,
   isNonNullable,
+  filterByType,
 } from '@finos/legend-shared';
 import { action, flowResult, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../EditorStore.js';
@@ -45,7 +46,10 @@ import {
   testable_deleteTest,
   testable_setId,
 } from '../../../../graph-modifier/Testable_GraphModifierHelper.js';
-import { createEmptyEqualToJsonAssertion } from '../../../utils/TestableUtils.js';
+import {
+  createEmptyEqualToJsonAssertion,
+  isTestPassing,
+} from '../../../utils/TestableUtils.js';
 import { TESTABLE_RESULT } from '../../../sidebar-state/testable/GlobalTestRunnerState.js';
 import {
   TestAssertionEditorState,
@@ -144,22 +148,6 @@ export abstract class TestableTestEditorState {
     }
   }
 
-  *runTest(): GeneratorFn<void> {
-    try {
-      this.resetResult();
-      this.runningTestAction.inProgress();
-      const result = (yield flowResult(this.fetchTestResult())) as TestResult;
-      this.handleTestResult(result);
-      this.runningTestAction.complete();
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.notificationService.notifyError(
-        `Error running test: ${error.message}`,
-      );
-      this.runningTestAction.fail();
-    }
-  }
-
   // Fetches test results. Caller of test should catch the error
   async fetchTestResult(): Promise<TestResult> {
     const input = new RunTestsTestableInput(this.testable);
@@ -195,6 +183,18 @@ export abstract class TestableTestEditorState {
     });
   }
 
+  correspondsToTestResult(val: TestResult): boolean {
+    const atomicTest = this.test;
+    if (atomicTest.id === val.atomicTest.id) {
+      const parent = atomicTest.__parent;
+      if (parent instanceof TestSuite) {
+        return parent.id === val.parentSuite?.id;
+      }
+      return val.parentSuite === undefined && val.testable === this.testable;
+    }
+    return false;
+  }
+
   get assertionCount(): number {
     return this.assertionEditorStates.length;
   }
@@ -224,6 +224,21 @@ export abstract class TestableTestEditorState {
       (state) => state.assertionResultState.result !== TESTABLE_RESULT.PASSED,
     ).length;
   }
+  *runTest(): GeneratorFn<void> {
+    try {
+      this.resetResult();
+      this.runningTestAction.inProgress();
+      const result = (yield flowResult(this.fetchTestResult())) as TestResult;
+      this.handleTestResult(result);
+      this.runningTestAction.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Error running test: ${error.message}`,
+      );
+      this.runningTestAction.fail();
+    }
+  }
 }
 
 export abstract class TestableTestSuiteEditorState {
@@ -339,6 +354,7 @@ export abstract class TestablePackageableElementEditorState {
   readonly testable: Testable;
   testableResults: TestResult[] | undefined;
   selectedTestSuite: TestableTestSuiteEditorState | undefined;
+  runningSuite: TestSuite | undefined;
 
   testableComponentToRename: Test | undefined;
 
@@ -353,12 +369,58 @@ export abstract class TestablePackageableElementEditorState {
 
   abstract init(): void;
 
-  abstract handleNewResults(results: TestResult[]): void;
-
   get suiteCount(): number {
     return this.testable.tests.length;
   }
 
+  get suites(): TestSuite[] {
+    return this.testable.tests.filter(filterByType(TestSuite));
+  }
+
+  get passingSuites(): TestSuite[] {
+    const results = this.testableResults;
+    if (results?.length) {
+      return this.suites.filter((suite) =>
+        results
+          .filter((res) => res.parentSuite?.id === suite.id)
+          .every((e) => isTestPassing(e)),
+      );
+    }
+    return [];
+  }
+
+  get failingSuites(): TestSuite[] {
+    const results = this.testableResults;
+    if (results?.length) {
+      return this.suites.filter((suite) =>
+        results
+          .filter((res) => res.parentSuite?.id === suite.id)
+          .some((e) => !isTestPassing(e)),
+      );
+    }
+    return [];
+  }
+
+  resolveSuiteResults(suite: TestSuite): TestResult[] | undefined {
+    return this.testableResults?.filter((t) => t.parentSuite?.id === suite.id);
+  }
+
+  clearTestResultsForSuite(suite: TestSuite): void {
+    this.testableResults = this.testableResults?.filter(
+      (t) => !(this.resolveSuiteResults(suite) ?? []).includes(t),
+    );
+  }
+
+  get staticSuites(): TestSuite[] {
+    const results = this.testableResults;
+    if (results?.length) {
+      return this.suites.filter((suite) =>
+        results.every((res) => res.parentSuite?.id !== suite.id),
+      );
+    }
+    return this.suites;
+  }
+
   setTestableResults(val: TestResult[] | undefined): void {
     this.testableResults = val;
   }
@@ -377,9 +439,36 @@ export abstract class TestablePackageableElementEditorState {
   deleteTestSuite(testSuite: TestSuite): void {
     testable_deleteTest(this.testable, testSuite);
     if (this.selectedTestSuite?.suite === testSuite) {
+      this.selectedTestSuite = undefined;
       this.init();
     }
   }
+
+  *runAllFailingSuites(): GeneratorFn<void> {
+    try {
+      this.isRunningFailingSuitesState.inProgress();
+      const input = new RunTestsTestableInput(this.testable);
+      this.failingSuites.forEach((s) => {
+        s.tests.forEach((t) => input.unitTestIds.push(new UniqueTestId(s, t)));
+      });
+      const testResults =
+        (yield this.editorStore.graphManagerState.graphManager.runTests(
+          [input],
+          this.editorStore.graphManagerState.graph,
+        )) as TestResult[];
+      this.handleNewResults(testResults);
+      this.isRunningFailingSuitesState.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      this.isRunningFailingSuitesState.fail();
+    } finally {
+      this.selectedTestSuite?.testStates.forEach((t) =>
+        t.runningTestAction.complete(),
+      );
+    }
+  }
+
   *runTestable(): GeneratorFn<void> {
     try {
       this.setTestableResults(undefined);
@@ -406,4 +495,55 @@ export abstract class TestablePackageableElementEditorState {
       );
     }
   }
+
+  *runSuite(suite: TestSuite): GeneratorFn<void> {
+    try {
+      this.runningSuite = suite;
+      this.clearTestResultsForSuite(suite);
+      this.selectedTestSuite?.testStates.forEach((t) => t.resetResult());
+      this.selectedTestSuite?.testStates.forEach((t) =>
+        t.runningTestAction.inProgress(),
+      );
+      const input = new RunTestsTestableInput(this.testable);
+      suite.tests.forEach((t) =>
+        input.unitTestIds.push(new UniqueTestId(suite, t)),
+      );
+      const testResults =
+        (yield this.editorStore.graphManagerState.graphManager.runTests(
+          [input],
+          this.editorStore.graphManagerState.graph,
+        )) as TestResult[];
+
+      this.handleNewResults(testResults);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      this.isRunningTestableSuitesState.fail();
+    } finally {
+      this.selectedTestSuite?.testStates.forEach((t) =>
+        t.runningTestAction.complete(),
+      );
+      this.runningSuite = undefined;
+    }
+  }
+
+  handleNewResults(results: TestResult[]): void {
+    if (this.testableResults?.length) {
+      const newSuitesResults = results
+        .map((e) => e.parentSuite?.id)
+        .filter(isNonNullable);
+      const reducedFilters = this.testableResults.filter(
+        (res) => !newSuitesResults.includes(res.parentSuite?.id ?? ''),
+      );
+      this.setTestableResults([...reducedFilters, ...results]);
+    } else {
+      this.setTestableResults(results);
+    }
+    this.testableResults?.forEach((result) => {
+      const state = this.selectedTestSuite?.testStates.find((testState) =>
+        testState.correspondsToTestResult(result),
+      );
+      state?.handleTestResult(result);
+    });
+  }
 }

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

@@ -29,29 +29,44 @@ import {
   type AtomicTest,
   type Class,
   type EmbeddedDataVisitor,
+  type INTERNAL__UnknownConnection,
+  type DataElementReference,
+  type INTERNAL__UnknownEmbeddedData,
+  type TestResult,
+  type ValueSpecification,
+  type Binding,
+  type RawLambda,
   ExternalFormatData,
   RelationalCSVData,
   ConnectionTestData,
   EqualToJson,
   DEFAULT_TEST_ASSERTION_PREFIX,
   RelationalCSVDataTable,
-  type INTERNAL__UnknownConnection,
   getAllIdentifiedConnectionsFromRuntime,
   ModelStoreData,
   ModelEmbeddedData,
   PackageableElementExplicitReference,
-  type DataElementReference,
-  type INTERNAL__UnknownEmbeddedData,
-  type TestResult,
   TestExecuted,
   TestExecutionStatus,
+  isStubbed_RawLambda,
+  SimpleFunctionExpression,
+  InstanceValue,
+  CollectionInstanceValue,
+  matchFunctionName,
+  PackageableElementImplicitReference,
+  VariableExpression,
+  PrimitiveInstanceValue,
+  PrimitiveType,
+  LambdaFunctionInstanceValue,
 } from '@finos/legend-graph';
 import {
   assertTrue,
   ContentType,
   generateEnumerableNameFromToken,
+  getNullableFirstEntry,
   guaranteeNonEmptyString,
   isNonNullable,
+  LogEvent,
   returnUndefOnError,
   UnsupportedOperationError,
   uuid,
@@ -60,6 +75,8 @@ import { EmbeddedDataType } from '../editor-state/ExternalFormatState.js';
 import type { EditorStore } from '../EditorStore.js';
 import { createMockDataForMappingElementSource } from './MockDataUtils.js';
 import type { DSL_Data_LegendStudioApplicationPlugin_Extension } from '../../extensions/DSL_Data_LegendStudioApplicationPlugin_Extension.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '@finos/legend-query-builder';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
 
 export const DEFAULT_TEST_ASSERTION_ID = 'assertion_1';
 export const DEFAULT_TEST_ID = 'test_1';
@@ -359,3 +376,126 @@ export const TEMPORARY__createRelationalDataFromCSV = (
 export const isTestPassing = (testResult: TestResult): boolean =>
   testResult instanceof TestExecuted &&
   testResult.testExecutionStatus === TestExecutionStatus.PASS;
+
+// external format param type
+export interface TestParamContentType {
+  contentType: string;
+  param: string;
+}
+export const getContentTypeWithParamRecursively = (
+  expression: ValueSpecification | undefined,
+): TestParamContentType[] => {
+  let currentExpression = expression;
+  const res: TestParamContentType[] = [];
+  // use if statement to safely scan service query without breaking the app
+  while (currentExpression instanceof SimpleFunctionExpression) {
+    if (
+      matchFunctionName(
+        currentExpression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.INTERNALIZE,
+      ) ||
+      matchFunctionName(
+        currentExpression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_RUNTIME_WITH_MODEL_QUERY_CONNECTION,
+      )
+    ) {
+      if (currentExpression.parametersValues[1] instanceof InstanceValue) {
+        if (
+          currentExpression.parametersValues[1].values[0] instanceof
+            PackageableElementImplicitReference &&
+          currentExpression.parametersValues[2] instanceof VariableExpression
+        ) {
+          res.push({
+            contentType: (
+              currentExpression.parametersValues[1].values[0].value as Binding
+            ).contentType,
+            param: currentExpression.parametersValues[2].name,
+          });
+        } else if (
+          matchFunctionName(
+            currentExpression.functionName,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_RUNTIME_WITH_MODEL_QUERY_CONNECTION,
+          ) &&
+          currentExpression.parametersValues[1] instanceof
+            PrimitiveInstanceValue &&
+          currentExpression.parametersValues[1].genericType.value.rawType ===
+            PrimitiveType.STRING &&
+          currentExpression.parametersValues[2] instanceof VariableExpression
+        ) {
+          res.push({
+            contentType: currentExpression.parametersValues[1]
+              .values[0] as string,
+            param: currentExpression.parametersValues[2].name,
+          });
+        }
+      }
+      currentExpression = currentExpression.parametersValues[1];
+    } else if (
+      matchFunctionName(
+        currentExpression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.FROM,
+      )
+    ) {
+      currentExpression = currentExpression.parametersValues[2];
+    } else if (
+      matchFunctionName(
+        currentExpression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.MERGERUNTIMES,
+      )
+    ) {
+      const collection = currentExpression.parametersValues[0];
+      if (collection instanceof CollectionInstanceValue) {
+        collection.values
+          .map((v) => getContentTypeWithParamRecursively(v))
+          .flat()
+          .map((p) => res.push(p));
+      }
+      currentExpression = collection;
+    } else {
+      currentExpression = getNullableFirstEntry(
+        currentExpression.parametersValues,
+      );
+    }
+  }
+  return res;
+};
+
+export const getContentTypeWithParamFromQuery = (
+  query: RawLambda | undefined,
+  editorStore: EditorStore,
+): TestParamContentType[] => {
+  if (query && !isStubbed_RawLambda(query)) {
+    // safely pass unsupported funtions when building ValueSpecification from Rawlambda
+    try {
+      const valueSpec =
+        editorStore.graphManagerState.graphManager.buildValueSpecification(
+          editorStore.graphManagerState.graphManager.serializeRawValueSpecification(
+            query,
+          ),
+          editorStore.graphManagerState.graph,
+        );
+      if (valueSpec instanceof LambdaFunctionInstanceValue) {
+        return getContentTypeWithParamRecursively(
+          valueSpec.values[0]?.expressionSequence.find(
+            (exp) =>
+              exp instanceof SimpleFunctionExpression &&
+              (matchFunctionName(
+                exp.functionName,
+                QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE,
+              ) ||
+                matchFunctionName(
+                  exp.functionName,
+                  QUERY_BUILDER_SUPPORTED_FUNCTIONS.EXTERNALIZE,
+                )),
+          ),
+        );
+      }
+    } catch (error) {
+      editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.SERVICE_TEST_SETUP_FAILURE),
+        error,
+      );
+    }
+  }
+  return [];
+};

package/src/stores/graph-modifier/DomainGraphModifierHelper.ts

@@ -50,6 +50,8 @@ import {
   type INTERNAL__UnknownFunctionActivator,
   type FunctionStoreTestData,
   type ObserverContext,
+  type FunctionParameterValue,
+  type FunctionTest,
   type FunctionTestSuite,
   type AggregationKind,
   type EmbeddedData,
@@ -73,6 +75,7 @@ import {
   getOtherAssociatedProperty,
   observe_EmbeddedData,
   observe_FunctionTestSuite,
+  observe_FunctionParameterValue,
 } from '@finos/legend-graph';
 
 // --------------------------------------------- Packageable Element -------------------------------------
@@ -415,6 +418,36 @@ export const function_addTestSuite = action(
   },
 );
 
+export const function_setParameterValueSpec = action(
+  (parameterValue: FunctionParameterValue, val: object) => {
+    parameterValue.value = val;
+  },
+);
+
+export const function_setParameterValues = action(
+  (test: FunctionTest, values: FunctionParameterValue[]) => {
+    test.parameters = values.map(observe_FunctionParameterValue);
+  },
+);
+
+export const function_deleteParameterValue = action(
+  (test: FunctionTest, value: FunctionParameterValue) => {
+    deleteEntry(test.parameters ?? [], value);
+  },
+);
+
+export const function_addParameterValue = action(
+  (test: FunctionTest, value: FunctionParameterValue) => {
+    test.parameters?.push(observe_FunctionParameterValue(value));
+  },
+);
+
+export const function_setParameterName = action(
+  (parameterValue: FunctionParameterValue, val: string) => {
+    parameterValue.name = val;
+  },
+);
+
 // --------------------------------------------- Enumeration -------------------------------------
 
 export const enum_setName = action((val: Enum, value: string): void => {