@finos/legend-application-studio 28.13.2 → 28.13.3

package/src/components/editor/side-bar/Explorer.tsx

@@ -91,7 +91,6 @@ import { flowResult } from 'mobx';
 import { useEditorStore } from '../EditorStoreProvider.js';
 import {
   type PackageableElement,
-  type FunctionActivatorConfiguration,
   ELEMENT_PATH_DELIMITER,
   ROOT_PACKAGE_NAME,
   Package,
@@ -144,7 +143,6 @@ import {
   CodeEditor,
 } from '@finos/legend-lego/code-editor';
 import { DatabaseBuilderWizard } from '../editor-group/connection-editor/DatabaseBuilderWizard.js';
-import { FunctionEditorState } from '../../../stores/editor/editor-state/element-editor-state/FunctionEditorState.js';
 import { DatabaseModelBuilder } from '../editor-group/connection-editor/DatabaseModelBuilder.js';
 import { queryService } from '../editor-group/service-editor/ServiceExecutionQueryEditor.js';
 import { QueryDatabaseState } from '../../../stores/editor/editor-state/element-editor-state/database/QueryDatabaseState.js';
@@ -755,50 +753,6 @@ const ExplorerContextMenu = observer(
         ).catch(applicationStore.alertUnhandledError);
       }
     };
-    const activateFunction = (): void => {
-      if (node?.packageableElement instanceof ConcreteFunctionDefinition) {
-        editorStore.setQuickInputState({
-          title: 'Activate function',
-          placeholder: 'Select an activation...',
-          options: editorStore.graphState.functionActivatorConfigurations.map(
-            (config) => ({
-              value: config,
-              label: (
-                <div
-                  className="function-editor__activator__selector__option"
-                  title={config.description}
-                >
-                  <div className="function-editor__activator__selector__option__name">
-                    {config.name}
-                  </div>
-                  <div className="function-editor__activator__selector__option__description">
-                    {config.description}
-                  </div>
-                </div>
-              ),
-            }),
-          ),
-          getSearchValue: (option: {
-            value: FunctionActivatorConfiguration;
-            label: React.ReactNode;
-          }): string => option.value.name,
-          onSelect: (option: {
-            value: FunctionActivatorConfiguration;
-            label: React.ReactNode;
-          }) => {
-            editorStore.graphEditorMode.openElement(node.packageableElement);
-            editorStore.tabManagerState
-              .getCurrentEditorState(FunctionEditorState)
-              .activatorBuilderState.setCurrentActivatorConfiguration(
-                option.value,
-              );
-          },
-          customization: {
-            rowHeight: 70,
-          },
-        });
-      }
-    };
 
     if (isDependencyProjectRoot()) {
       return (
@@ -878,19 +832,6 @@ const ExplorerContextMenu = observer(
             <MenuContentDivider />
           </>
         )}
-        {node.packageableElement instanceof ConcreteFunctionDefinition && (
-          <>
-            {editorStore.applicationStore.config.options
-              .TEMPORARY__enableFunctionActivatorSupport && (
-              <>
-                <MenuContentItem onClick={activateFunction}>
-                  Activate...
-                </MenuContentItem>
-                <MenuContentDivider />
-              </>
-            )}
-          </>
-        )}
         {isRelationalDatabaseConnection(node.packageableElement) && (
           <>
             <MenuContentItem onClick={openSQLPlayground}>

package/src/stores/editor/editor-state/element-editor-state/{FunctionActivatorPromoteState.ts → FunctionActivatorState.ts}

@@ -27,54 +27,54 @@ import {
   SnowflakeAppType,
 } from '@finos/legend-graph';
 import { type GeneratorFn } from '@finos/legend-shared';
-import { FUNCTION_PROMOTE_TYPE } from '../../../../components/editor/editor-group/function-activator/FunctionEditor.js';
+import { FUNCTION_ACTIVATE_TYPE } from '../../../../components/editor/editor-group/function-activator/FunctionEditor.js';
 
 const BASE_ACTIVATOR_NAME = 'NewActivator';
 
-export class FunctionActivatorPromoteState {
+export class FunctionActivatorState {
   readonly functionEditorState: FunctionEditorState;
 
   activatorPath: string;
-  isPromotingFunction = false;
+  isActivatingFunction = false;
   isFunctionActivatorEditorOpen = false;
-  promoteType: string | undefined;
+  activateType: string | undefined;
 
   constructor(functionEditorState: FunctionEditorState) {
     makeObservable(this, {
       activatorPath: observable,
-      isPromotingFunction: observable,
+      isActivatingFunction: observable,
       isFunctionActivatorEditorOpen: observable,
-      promoteType: observable,
-      setPromoteType: action,
+      activateType: observable,
+      setAcitvateType: action,
       updateActivatorPath: action,
-      setIsPromotingFunction: action,
+      setIsActivatingFunction: action,
       setIsFunctionActivatorEditorOpen: action,
-      promote: flow,
+      activate: flow,
     });
 
     this.functionEditorState = functionEditorState;
-    this.promoteType = FUNCTION_PROMOTE_TYPE.SNOWFLAKE_NATIVE_APP;
+    this.activateType = FUNCTION_ACTIVATE_TYPE.SNOWFLAKE_NATIVE_APP;
     this.activatorPath = `${this.functionEditorState.functionElement.package?.path}::${BASE_ACTIVATOR_NAME}`;
   }
 
-  setIsPromotingFunction(val: boolean): void {
-    this.isPromotingFunction = val;
+  setIsActivatingFunction(val: boolean): void {
+    this.isActivatingFunction = val;
   }
 
   setIsFunctionActivatorEditorOpen(val: boolean): void {
     this.isFunctionActivatorEditorOpen = val;
   }
 
-  setPromoteType(val: string | undefined): void {
-    this.promoteType = val;
+  setAcitvateType(val: string | undefined): void {
+    this.activateType = val;
   }
 
-  showFunctionPromoteModal(): void {
-    this.setIsPromotingFunction(true);
+  showFunctionActivateModal(): void {
+    this.setIsActivatingFunction(true);
   }
 
-  closeFunctionPromoteModal(): void {
-    this.setIsPromotingFunction(false);
+  closeFunctionActivateModal(): void {
+    this.setIsActivatingFunction(false);
   }
 
   updateActivatorPath(val: string): void {
@@ -84,9 +84,9 @@ export class FunctionActivatorPromoteState {
   createFunctionActivator(
     functionElement: ConcreteFunctionDefinition,
   ): FunctionActivator | undefined {
-    const type = this.promoteType;
+    const type = this.activateType;
     switch (type) {
-      case FUNCTION_PROMOTE_TYPE.SNOWFLAKE_NATIVE_APP: {
+      case FUNCTION_ACTIVATE_TYPE.SNOWFLAKE_NATIVE_APP: {
         const activatorName = this.activatorPath.includes('::')
           ? extractElementNameFromPath(this.activatorPath)
           : this.activatorPath;
@@ -106,7 +106,7 @@ export class FunctionActivatorPromoteState {
     }
   }
 
-  *promote(functionElement: ConcreteFunctionDefinition): GeneratorFn<void> {
+  *activate(functionElement: ConcreteFunctionDefinition): GeneratorFn<void> {
     const functionActivator = this.createFunctionActivator(functionElement);
     if (!functionActivator) {
       return;
@@ -121,10 +121,10 @@ export class FunctionActivatorPromoteState {
       );
     } catch {
       this.functionEditorState.editorStore.applicationStore.notificationService.notifyError(
-        `Can't promote function`,
+        `Can't activate function`,
       );
     } finally {
-      this.setPromoteType(FUNCTION_PROMOTE_TYPE.SNOWFLAKE_NATIVE_APP);
+      this.setAcitvateType(FUNCTION_ACTIVATE_TYPE.SNOWFLAKE_NATIVE_APP);
     }
   }
 }

package/src/stores/editor/editor-state/element-editor-state/FunctionEditorState.ts

@@ -65,13 +65,14 @@ import {
   buildExecutionParameterValues,
   getExecutionQueryFromRawLambda,
 } from '@finos/legend-query-builder';
-import { FunctionActivatorBuilderState } from './FunctionActivatorBuilderState.js';
-import { FunctionActivatorPromoteState } from './FunctionActivatorPromoteState.js';
+import { FunctionActivatorState } from './FunctionActivatorState.js';
+import { FunctionTestableState } from './function-activator/testable/FunctionTestableState.js';
 
 export enum FUNCTION_EDITOR_TAB {
   DEFINITION = 'DEFINITION',
   TAGGED_VALUES = 'TAGGED_VALUES',
   STEREOTYPES = 'STEREOTYPES',
+  TEST_SUITES = 'TEST_SUITES',
 }
 
 export class FunctionDefinitionEditorState extends LambdaEditorState {
@@ -244,8 +245,8 @@ export class FunctionParametersState extends LambdaParametersState {
 
 export class FunctionEditorState extends ElementEditorState {
   readonly functionDefinitionEditorState: FunctionDefinitionEditorState;
-  readonly activatorBuilderState: FunctionActivatorBuilderState; // to be removed
-  readonly activatorPromoteState: FunctionActivatorPromoteState;
+  readonly activatorPromoteState: FunctionActivatorState;
+  readonly functionTestableEditorState: FunctionTestableState;
 
   selectedTab: FUNCTION_EDITOR_TAB;
 
@@ -288,13 +289,13 @@ export class FunctionEditorState extends ElementEditorState {
       element,
       this.editorStore,
     );
-    this.activatorBuilderState = new FunctionActivatorBuilderState(this);
-    this.activatorPromoteState = new FunctionActivatorPromoteState(this);
+    this.activatorPromoteState = new FunctionActivatorState(this);
     this.executionPlanState = new ExecutionPlanState(
       this.editorStore.applicationStore,
       this.editorStore.graphManagerState,
     );
     this.parametersState = new FunctionParametersState(this);
+    this.functionTestableEditorState = new FunctionTestableState(this);
   }
 
   override get label(): string {

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

@@ -30,7 +30,7 @@ import {
 } from '@finos/legend-shared';
 import { ProtocolValueBuilderState } from '../ProtocolValueBuilderState.js';
 import { INTERNAL__UnknownFunctionActivator_setContent } from '../../../../graph-modifier/DomainGraphModifierHelper.js';
-import { FUNCTION_ACTIVATOR_EXCLUDED_PATHS } from '../FunctionActivatorBuilderState.js';
+import { FUNCTION_ACTIVATOR_EXCLUDED_PATHS } from '../ToDelete_FunctionActivatorBuilderState.js';
 
 export class INTERNAL__UnknownFunctionActivatorEdtiorState extends ElementEditorState {
   readonly activator: INTERNAL__UnknownFunctionActivator;

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

@@ -50,7 +50,7 @@ export class SnowflakeAppFunctionActivatorEdtiorState extends ElementEditorState
       updateConnection: action,
       updateAppType: action,
       validate: flow,
-      deploy: flow,
+      deployToSandbox: flow,
     });
   }
 
@@ -106,7 +106,7 @@ export class SnowflakeAppFunctionActivatorEdtiorState extends ElementEditorState
     }
   }
 
-  *deploy(): GeneratorFn<void> {
+  *deployToSandbox(): GeneratorFn<void> {
     this.deployState.inProgress();
     try {
       yield this.editorStore.graphManagerState.graphManager.publishFunctionActivatorToSandbox(

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

@@ -0,0 +1,414 @@
+/**
+ * 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 { action, flow, makeObservable, observable } from 'mobx';
+import type { EditorStore } from '../../../../EditorStore.js';
+import type { FunctionEditorState } from '../../FunctionEditorState.js';
+import {
+  assertErrorThrown,
+  isNonNullable,
+  uuid,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import {
+  FunctionTest,
+  type ConcreteFunctionDefinition,
+  type EmbeddedData,
+  type FunctionStoreTestData,
+  type FunctionTestSuite,
+  type TestResult,
+  type AtomicTest,
+  UniqueTestId,
+  RunTestsTestableInput,
+} from '@finos/legend-graph';
+import {
+  TestablePackageableElementEditorState,
+  TestableTestEditorState,
+  TestableTestSuiteEditorState,
+} from '../../testable/TestableEditorState.js';
+import { EmbeddedDataEditorState } from '../../data/DataEditorState.js';
+import {
+  functionTestable_deleteDataStore,
+  functionTestable_setEmbeddedData,
+} from '../../../../../graph-modifier/DomainGraphModifierHelper.js';
+import { isTestPassing } from '../../../../utils/TestableUtils.js';
+
+export class FunctionStoreTestDataState {
+  readonly editorStore: EditorStore;
+  readonly testDataState: FunctionTestDataState;
+  storeTestData: FunctionStoreTestData;
+  embeddedEditorState: EmbeddedDataEditorState;
+  dataElementModal = false;
+
+  constructor(
+    editorStore: EditorStore,
+    testDataState: FunctionTestDataState,
+    value: FunctionStoreTestData,
+  ) {
+    makeObservable(this, {
+      storeTestData: observable,
+      dataElementModal: observable,
+      embeddedEditorState: observable,
+
+      setDataElementModal: action,
+      changeEmbeddedData: action,
+    });
+    this.editorStore = editorStore;
+    this.testDataState = testDataState;
+    this.storeTestData = value;
+    this.embeddedEditorState = new EmbeddedDataEditorState(
+      this.testDataState.editorStore,
+      this.storeTestData.data,
+      {
+        hideSource: true,
+      },
+    );
+  }
+
+  setDataElementModal(val: boolean): void {
+    this.dataElementModal = val;
+  }
+
+  changeEmbeddedData(val: EmbeddedData): void {
+    functionTestable_setEmbeddedData(
+      this.storeTestData,
+      val,
+      this.editorStore.changeDetectionState.observerContext,
+    );
+    this.embeddedEditorState = new EmbeddedDataEditorState(
+      this.testDataState.editorStore,
+      this.storeTestData.data,
+    );
+  }
+}
+
+export class FunctionTestState extends TestableTestEditorState {
+  readonly parentState: FunctionTestSuiteState;
+  readonly functionTestableState: FunctionTestableState;
+  readonly uuid = uuid();
+  override test: FunctionTest;
+  // TODO: param
+
+  constructor(
+    editorStore: EditorStore,
+    parentSuiteState: FunctionTestSuiteState,
+    test: FunctionTest,
+  ) {
+    super(
+      parentSuiteState.functionTestableState.function,
+      test,
+      parentSuiteState.functionTestableState.functionEditorState.isReadOnly,
+      editorStore,
+    );
+    makeObservable(this, {
+      selectedAsertionState: observable,
+      selectedTab: observable,
+      assertionToRename: observable,
+      assertionEditorStates: observable,
+      testResultState: observable,
+      runningTestAction: observable,
+      addAssertion: action,
+      setAssertionToRename: action,
+      handleTestResult: action,
+      setSelectedTab: action,
+      runTest: flow,
+    });
+    this.parentState = parentSuiteState;
+    this.functionTestableState = parentSuiteState.functionTestableState;
+    this.test = test;
+  }
+}
+
+class FunctionTestDataState {
+  readonly editorStore: EditorStore;
+  readonly functionTestableState: FunctionTestableState;
+  selectedDataState: FunctionStoreTestDataState | undefined;
+  dataHolder: FunctionTestSuite;
+  showNewModal = false;
+
+  constructor(
+    editorStore: EditorStore,
+    functionTestableState: FunctionTestableState,
+    holder: FunctionTestSuite,
+  ) {
+    makeObservable(this, {
+      selectedDataState: observable,
+      dataHolder: observable,
+      showNewModal: observable,
+      initDefaultStore: action,
+      setShowModal: action,
+      deleteStoreTestData: action,
+      openStoreTestData: action,
+    });
+    this.editorStore = editorStore;
+    this.functionTestableState = functionTestableState;
+    this.dataHolder = holder;
+    this.initDefaultStore();
+  }
+
+  initDefaultStore(): void {
+    const val = this.dataHolder.testData?.[0];
+    if (val) {
+      this.openStoreTestData(val);
+    } else {
+      this.selectedDataState = undefined;
+    }
+  }
+
+  setShowModal(val: boolean): void {
+    this.showNewModal = val;
+  }
+
+  deleteStoreTestData(val: FunctionStoreTestData): void {
+    functionTestable_deleteDataStore(this.dataHolder, val);
+    this.initDefaultStore();
+  }
+
+  openStoreTestData(val: FunctionStoreTestData): void {
+    this.selectedDataState = new FunctionStoreTestDataState(
+      this.editorStore,
+      this,
+      val,
+    );
+  }
+}
+
+export class FunctionTestSuiteState extends TestableTestSuiteEditorState {
+  readonly functionTestableState: FunctionTestableState;
+  override suite: FunctionTestSuite;
+  override testStates: FunctionTestState[] = [];
+  override selectTestState: FunctionTestState | undefined;
+  dataState: FunctionTestDataState;
+
+  showCreateModal = false;
+
+  constructor(
+    editorStore: EditorStore,
+    functionTestableState: FunctionTestableState,
+    suite: FunctionTestSuite,
+  ) {
+    super(
+      functionTestableState.function,
+      suite,
+      functionTestableState.functionEditorState.isReadOnly,
+      editorStore,
+    );
+    makeObservable(this, {
+      dataState: observable,
+      showCreateModal: observable,
+      buildTestState: action,
+      deleteTest: action,
+      buildTestStates: action,
+    });
+    this.functionTestableState = functionTestableState;
+    this.suite = suite;
+    this.dataState = new FunctionTestDataState(
+      editorStore,
+      functionTestableState,
+      suite,
+    );
+    this.testStates = this.buildTestStates();
+    this.selectTestState = this.testStates[0];
+  }
+
+  buildTestStates(): FunctionTestState[] {
+    return this.suite.tests
+      .map((t) => this.buildTestState(t))
+      .filter(isNonNullable);
+  }
+
+  buildTestState(val: AtomicTest): FunctionTestState | undefined {
+    if (val instanceof FunctionTest) {
+      return new FunctionTestState(this.editorStore, this, val);
+    }
+    return undefined;
+  }
+}
+
+export class FunctionTestableState extends TestablePackageableElementEditorState {
+  readonly functionEditorState: FunctionEditorState;
+
+  runningSuite: FunctionTestSuite | undefined;
+  declare selectedTestSuite: FunctionTestSuiteState | undefined;
+
+  constructor(functionEditorState: FunctionEditorState) {
+    super(functionEditorState, functionEditorState.functionElement);
+    makeObservable(this, {
+      isRunningTestableSuitesState: observable,
+      isRunningFailingSuitesState: observable,
+      selectedTestSuite: observable,
+      testableResults: observable,
+      runningSuite: observable,
+      init: action,
+      buildTestSuiteState: action,
+      deleteTestSuite: action,
+      changeSuite: action,
+      handleNewResults: action,
+      setRenameComponent: action,
+      runTestable: flow,
+      runSuite: flow,
+      runAllFailingSuites: flow,
+    });
+    this.functionEditorState = functionEditorState;
+    this.init();
+  }
+
+  get function(): ConcreteFunctionDefinition {
+    return this.functionEditorState.functionElement;
+  }
+
+  get passingSuites(): FunctionTestSuite[] {
+    const results = this.testableResults;
+    if (results?.length) {
+      return this.function.tests.filter((suite) =>
+        results
+          .filter((res) => res.parentSuite?.id === suite.id)
+          .every((e) => isTestPassing(e)),
+      );
+    }
+    return [];
+  }
+
+  get failingSuites(): FunctionTestSuite[] {
+    const results = this.testableResults;
+    if (results?.length) {
+      return this.function.tests.filter((suite) =>
+        results
+          .filter((res) => res.parentSuite?.id === suite.id)
+          .some((e) => !isTestPassing(e)),
+      );
+    }
+    return [];
+  }
+
+  get staticSuites(): FunctionTestSuite[] {
+    const results = this.testableResults;
+    if (results?.length) {
+      return this.function.tests.filter((suite) =>
+        results.every((res) => res.parentSuite?.id !== suite.id),
+      );
+    }
+    return this.function.tests;
+  }
+
+  init(): void {
+    if (!this.selectedTestSuite) {
+      const suite = this.function.tests[0];
+      this.selectedTestSuite = suite
+        ? this.buildTestSuiteState(suite)
+        : undefined;
+    }
+  }
+
+  *runSuite(suite: FunctionTestSuite): 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.function);
+      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;
+    }
+  }
+
+  *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(),
+      );
+    }
+  }
+
+  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(
+        (t) =>
+          t.test.id === result.atomicTest.id &&
+          t.parentState.suite.id === result.parentSuite?.id,
+      );
+      state?.handleTestResult(result);
+    });
+  }
+
+  clearTestResultsForSuite(suite: FunctionTestSuite): void {
+    this.testableResults = this.testableResults?.filter(
+      (t) => !(this.resolveSuiteResults(suite) ?? []).includes(t),
+    );
+  }
+
+  resolveSuiteResults(suite: FunctionTestSuite): TestResult[] | undefined {
+    return this.testableResults?.filter((t) => t.parentSuite?.id === suite.id);
+  }
+
+  buildTestSuiteState(val: FunctionTestSuite): FunctionTestSuiteState {
+    return new FunctionTestSuiteState(this.editorStore, this, val);
+  }
+
+  changeSuite(suite: FunctionTestSuite): void {
+    if (this.selectedTestSuite?.suite !== suite) {
+      this.selectedTestSuite = this.buildTestSuiteState(suite);
+    }
+  }
+}

package/src/stores/editor/editor-state/element-editor-state/mapping/MappingEditorState.ts

@@ -673,10 +673,7 @@ export class MappingEditorState extends ElementEditorState {
       this.mapping,
       editorStore,
     );
-    this.mappingTestableState = new MappingTestableState(
-      this.editorStore,
-      this,
-    );
+    this.mappingTestableState = new MappingTestableState(this);
   }
 
   get mapping(): Mapping {