@finos/legend-application-studio 28.14.7 → 28.14.9

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

@@ -39,6 +39,7 @@ import {
   type EngineRuntime,
   type ObserverContext,
   type ValueSpecification,
+  type TestAssertion,
   FunctionParameterValue,
   VariableExpression,
   FunctionTest,
@@ -57,6 +58,7 @@ import {
   PackageableElementExplicitReference,
   observe_ValueSpecification,
   buildLambdaVariableExpressions,
+  EqualTo,
 } from '@finos/legend-graph';
 import {
   TestablePackageableElementEditorState,
@@ -80,7 +82,10 @@ import {
 } from '../../../../utils/TestableUtils.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../../__lib__/LegendStudioEvent.js';
 import { testSuite_addTest } from '../../../../../graph-modifier/Testable_GraphModifierHelper.js';
-import { generateVariableExpressionMockValue } from '@finos/legend-query-builder';
+import {
+  buildDefaultInstanceValue,
+  generateVariableExpressionMockValue,
+} from '@finos/legend-query-builder';
 
 const addToFunctionMap = (
   val: SimpleFunctionExpression,
@@ -567,20 +572,41 @@ class FunctionTestDataState {
 export const createFunctionTest = (
   id: string,
   observerContext: ObserverContext,
+  containsRuntime: boolean,
+  functionDefinition: ConcreteFunctionDefinition,
+  editorStore: EditorStore,
   suite?: FunctionTestSuite | undefined,
 ): FunctionTest => {
   const funcionTest = new FunctionTest();
   funcionTest.id = id;
-  funcionTest.assertions = [
-    createDefaultEqualToJSONTestAssertion(DEFAULT_TEST_ASSERTION_ID),
-  ];
+  funcionTest.assertions = [];
+  let _assertion: TestAssertion;
+  if (containsRuntime) {
+    _assertion = createDefaultEqualToJSONTestAssertion(
+      DEFAULT_TEST_ASSERTION_ID,
+    );
+  } else {
+    const equalTo = new EqualTo();
+    equalTo.id = DEFAULT_TEST_ASSERTION_ID;
+    const type = functionDefinition.returnType.value;
+    const valSpec = buildDefaultInstanceValue(
+      editorStore.graphManagerState.graph,
+      type,
+      editorStore.changeDetectionState.observerContext,
+    );
+    const expected =
+      editorStore.graphManagerState.graphManager.serializeValueSpecification(
+        valSpec,
+      );
+    equalTo.expected = expected;
+    _assertion = equalTo;
+  }
+  funcionTest.assertions = [_assertion];
+  _assertion.parentTest = funcionTest;
   if (suite) {
     funcionTest.__parent = suite;
     testSuite_addTest(suite, funcionTest, observerContext);
   }
-  const assertion = createDefaultEqualToJSONTestAssertion(`expectedAssertion`);
-  funcionTest.assertions = [assertion];
-  assertion.parentTest = funcionTest;
   return funcionTest;
 };
 export class FunctionTestSuiteState extends TestableTestSuiteEditorState {
@@ -608,6 +634,8 @@ export class FunctionTestSuiteState extends TestableTestSuiteEditorState {
       showCreateModal: observable,
       selectTestState: observable,
       changeTest: observable,
+      runSuite: flow,
+      runFailingTests: flow,
       buildTestState: action,
       deleteTest: action,
       buildTestStates: action,
@@ -646,9 +674,11 @@ export class FunctionTestSuiteState extends TestableTestSuiteEditorState {
     const test = createFunctionTest(
       id,
       this.editorStore.changeDetectionState.observerContext,
+      this.functionTestableState.containsRuntime,
+      this.functionTestableState.function,
+      this.editorStore,
       this.suite,
     );
-
     testSuite_addTest(
       this.suite,
       test,
@@ -700,6 +730,14 @@ export class FunctionTestableState extends TestablePackageableElementEditorState
     return this.functionEditorState.functionElement;
   }
 
+  get associatedRuntimes(): EngineRuntime[] | undefined {
+    return resolveRuntimesFromQuery(this.function, this.editorStore);
+  }
+
+  get containsRuntime(): boolean {
+    return Boolean(this.associatedRuntimes?.length);
+  }
+
   override init(): void {
     if (!this.selectedTestSuite) {
       const suite = this.function.tests[0];
@@ -716,10 +754,7 @@ export class FunctionTestableState extends TestablePackageableElementEditorState
   createSuite(suiteName: string, testName: string): void {
     const functionSuite = new FunctionTestSuite();
     functionSuite.id = suiteName;
-    const engineRuntimes = resolveRuntimesFromQuery(
-      this.function,
-      this.editorStore,
-    );
+    const engineRuntimes = this.associatedRuntimes;
     if (engineRuntimes?.length) {
       try {
         assertTrue(
@@ -771,6 +806,9 @@ export class FunctionTestableState extends TestablePackageableElementEditorState
     createFunctionTest(
       testName,
       this.editorStore.changeDetectionState.observerContext,
+      this.containsRuntime,
+      this.function,
+      this.editorStore,
       functionSuite,
     );
     // set test suite

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

@@ -17,6 +17,7 @@
 import {
   type TestAssertion,
   type AssertionStatus,
+  type ValueSpecification,
   AssertFail,
   type TestResult,
   TestExecuted,
@@ -27,6 +28,8 @@ import {
   MultiExecutionServiceTestResult,
   AssertPass,
   TestExecutionStatus,
+  EqualTo,
+  observe_ValueSpecification,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -39,6 +42,8 @@ import {
   IllegalStateError,
   guaranteeNonNullable,
   guaranteeType,
+  returnUndefOnError,
+  type PlainObject,
 } from '@finos/legend-shared';
 import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../../EditorStore.js';
@@ -49,6 +54,7 @@ import {
 } from '../../../sidebar-state/testable/GlobalTestRunnerState.js';
 import type { TestableTestEditorState } from './TestableEditorState.js';
 import { isTestPassing } from '../../../utils/TestableUtils.js';
+import { equalTo_setExpected } from '../../../../graph-modifier/Testable_GraphModifierHelper.js';
 
 export enum TEST_ASSERTION_TAB {
   EXPECTED = 'EXPECTED',
@@ -268,6 +274,55 @@ export class EqualToJsonAssertionState extends TestAssertionState {
   }
 }
 
+export class EqualToAssertionState extends TestAssertionState {
+  declare assertion: EqualTo;
+  valueSpec: ValueSpecification;
+
+  constructor(
+    editorStore: EditorStore,
+    assertionState: TestAssertionEditorState,
+    valueSpec: ValueSpecification,
+  ) {
+    super(editorStore, assertionState);
+    makeObservable(this, {
+      valueSpec: observable,
+      assertion: observable,
+      updateValueSpec: action,
+    });
+    this.valueSpec = observe_ValueSpecification(
+      valueSpec,
+      this.editorStore.changeDetectionState.observerContext,
+    );
+  }
+
+  updateValueSpec(val: ValueSpecification): void {
+    this.valueSpec = observe_ValueSpecification(
+      val,
+      this.editorStore.changeDetectionState.observerContext,
+    );
+    const object =
+      this.editorStore.graphManagerState.graphManager.serializeValueSpecification(
+        val,
+      );
+    equalTo_setExpected(this.assertion, object);
+  }
+
+  override generateExpected(status: AssertFail): boolean {
+    throw new Error('Method not implemented.');
+  }
+  override generateBare(): TestAssertion {
+    const equal = new EqualTo();
+    equal.expected = {};
+    return equal;
+  }
+  override label(): string {
+    return 'Equal To';
+  }
+  override get supportsGeneratingAssertion(): boolean {
+    return false;
+  }
+}
+
 export class UnsupportedAssertionState extends TestAssertionState {
   override get supportsGeneratingAssertion(): boolean {
     return false;
@@ -387,6 +442,16 @@ export class TestAssertionEditorState {
   buildAssertionState(assertion: TestAssertion): TestAssertionState {
     if (assertion instanceof EqualToJson) {
       return new EqualToJsonAssertionState(this.editorStore, this);
+    } else if (assertion instanceof EqualTo) {
+      const val = returnUndefOnError(() =>
+        this.editorStore.graphManagerState.graphManager.buildValueSpecification(
+          assertion.expected as PlainObject<ValueSpecification>,
+          this.editorStore.graphManagerState.graph,
+        ),
+      );
+      if (val) {
+        return new EqualToAssertionState(this.editorStore, this, val);
+      }
     }
     return new UnsupportedAssertionState(this.editorStore, this);
   }

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

@@ -15,6 +15,7 @@
  */
 
 import {
+  type EqualTo,
   type EqualToJson,
   type ExternalFormatData,
   type AtomicTest,
@@ -36,6 +37,12 @@ export const equalToJSON_setExpected = action(
   },
 );
 
+export const equalTo_setExpected = action(
+  (equalToJSON: EqualTo, val: object): void => {
+    equalToJSON.expected = val;
+  },
+);
+
 export const testAssertion_setId = action(
   (test: TestAssertion, val: string): void => {
     test.id = val;

package/src/stores/workspace-setup/WorkspaceSetupStore.ts

@@ -221,30 +221,30 @@ export class WorkspaceSetupStore {
       const sandbox = guaranteeType(
         this.sandboxProject,
         Project,
-        'Error Retrieving sandbox project',
+        'Error retrieving sandbox project',
       );
-      const pilotWorkspace = Workspace.serialization.fromJson(
+      const initialWorkspace = Workspace.serialization.fromJson(
         (yield this.sdlcServerClient.createWorkspace(
           sandbox.projectId,
           undefined,
-          'pilotWorkspace',
+          'myWorkspace',
           WorkspaceType.GROUP,
         )) as PlainObject<Workspace>,
       );
       yield flowResult(
         this.changeProject(sandbox, {
-          workspaceId: pilotWorkspace.workspaceId,
+          workspaceId: initialWorkspace.workspaceId,
           workspaceType: WorkspaceType.GROUP,
         }),
       );
       this.applicationStore.alertService.setBlockingAlert(undefined);
       this.applicationStore.notificationService.notifySuccess(
-        `Sandbox Project with pilot workspace created`,
+        `Sandbox project with workspace created`,
       );
     } catch (error) {
       assertErrorThrown(error);
       this.applicationStore.logService.error(
-        LogEvent.create(LEGEND_STUDIO_APP_EVENT.DEPOT_MANAGER_FAILURE),
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.ENGINE_MANAGER_FAILURE),
         error,
       );
       this.applicationStore.notificationService.notifyError(error);