@finos/legend-application-studio 27.1.0 → 27.1.1

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

@@ -16,88 +16,53 @@
 
 import {
   type Mapping,
-  type MappingTestSuite,
+  MappingTestSuite,
   type Class,
   type MappingModelCoverageAnalysisResult,
-  type GraphManagerState,
   type RawLambda,
-  type MappingTest,
-  type SetImplementation,
-  type TestAssertion,
+  MappingTest,
   type AtomicTest,
   type EmbeddedData,
   type Store,
   type DataElement,
+  type TestResult,
   LAMBDA_PIPE,
   buildSourceInformationSourceId,
   isStubbed_RawLambda,
   GRAPH_MANAGER_EVENT,
-  MappingDataTestSuite,
-  MappingQueryTestSuite,
-  RootGraphFetchTree,
   PackageableElementExplicitReference,
-  EntityMappedProperty,
-  PropertyGraphFetchTree,
-  PropertyExplicitReference,
-  LambdaFunction,
-  FunctionType,
-  Multiplicity,
-  CORE_PURE_PATH,
-  buildRawLambdaFromLambdaFunction,
-  MappingDataTest,
-  MappingQueryTest,
-  PureInstanceSetImplementation,
   StoreTestData,
-  ModelStore,
   getRootSetImplementation,
-  stub_RawLambda,
   DataElementReference,
   RelationalCSVData,
-  getAllClassProperties,
-  getAllClassDerivedProperties,
-  RelationalInstanceSetImplementation,
-  EmbeddedRelationalInstanceSetImplementation,
-  TableAlias,
-  Table,
-  RelationalCSVDataTable,
-  ModelStoreData,
-  ModelEmbeddedData,
-  getMappingCompatibleClasses,
+  RunTestsTestableInput,
+  UniqueTestId,
 } from '@finos/legend-graph';
 import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import {
   ActionState,
   assertErrorThrown,
-  guaranteeNonNullable,
   type GeneratorFn,
-  assertTrue,
   isNonNullable,
   UnsupportedOperationError,
   LogEvent,
   uuid,
   filterByType,
 } from '@finos/legend-shared';
-import {
-  LambdaEditorState,
-  buildGetAllFunction,
-  buildSerialzieFunctionWithGraphFetch,
-} from '@finos/legend-query-builder';
-import {
-  type MappingEditorState,
-  getMappingElementSource,
-} from '../MappingEditorState.js';
+import { LambdaEditorState } from '@finos/legend-query-builder';
+import { type MappingEditorState } from '../MappingEditorState.js';
 import {
   mappingTestable_addStoreTestData,
   mappingTestable_deleteStoreTestData,
+  mappingTestable_setEmbeddedData,
   mappingTestable_setQuery,
   mapping_addTestSuite,
   mapping_deleteTestSuite,
 } from '../../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
 import {
-  DEFAULT_TEST_ASSERTION_ID,
+  EmbeddedDataCreatorFromEmbeddedData,
   createBareExternalFormat,
-  createDefaultEqualToJSONTestAssertion,
-  createEmbeddedDataFromClass,
+  isTestPassing,
 } from '../../../../utils/TestableUtils.js';
 import {
   TESTABLE_TEST_TAB,
@@ -112,226 +77,71 @@ import {
 } from '../../../../../graph-modifier/Testable_GraphModifierHelper.js';
 import { EmbeddedDataType } from '../../../ExternalFormatState.js';
 import type { EditorStore } from '../../../../EditorStore.js';
-import { createMockDataForTable } from '../../../../utils/MockDataUtils.js';
-
-export enum MAPPING_TEST_SUITE_TYPE {
-  DATA = 'DATA',
-  QUERY = 'QUERY',
-}
-
-const createGraphFetchLambda = (
-  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);
-};
-
-const createBareModelStoreData = (
-  _class: Class,
-  editorStore: EditorStore,
-): StoreTestData => {
-  const embeddedData = createEmbeddedDataFromClass(_class, editorStore);
-  const testData = new StoreTestData();
-  const modelStoreData = new ModelStoreData();
-  const modelData = new ModelEmbeddedData();
-  modelData.data = embeddedData;
-  modelData.model = PackageableElementExplicitReference.create(_class);
-  modelStoreData.modelData = [modelData];
-  testData.data = modelStoreData;
-  testData.store = PackageableElementExplicitReference.create(
-    ModelStore.INSTANCE,
-  );
-  return testData;
-};
-
-const createBareMappingDataTest = (
-  id: string,
-  storeTestData: StoreTestData | undefined,
-  suite?: MappingTestSuite | undefined,
-): MappingDataTest => {
-  const dataTest = new MappingDataTest();
-  dataTest.id = id;
-  dataTest.storeTestData = storeTestData ? [storeTestData] : [];
-  dataTest.assertions = [
-    createDefaultEqualToJSONTestAssertion(DEFAULT_TEST_ASSERTION_ID),
-  ];
-  if (suite) {
-    dataTest.__parent = suite;
-    suite.tests.push(dataTest);
-  }
-  return dataTest;
-};
-
-const createBareMappingQueryTest = (
-  id: string,
-  query: RawLambda,
-  suite?: MappingTestSuite | undefined,
-): MappingQueryTest => {
-  const dataTest = new MappingQueryTest();
-  dataTest.id = id;
-  dataTest.func = query;
-  dataTest.assertions = [
-    createDefaultEqualToJSONTestAssertion(DEFAULT_TEST_ASSERTION_ID),
-  ];
-  if (suite) {
-    dataTest.__parent = suite;
-    suite.tests.push(dataTest);
-  }
-  return dataTest;
-};
-
-export class MappingTestableQueryState extends LambdaEditorState {
-  editorStore: EditorStore;
-  parent: MappingQueryTestSuite | MappingQueryTest;
-  isInitializingLambda = false;
-  query: RawLambda;
-
-  constructor(
-    editorStore: EditorStore,
-    parent: MappingQueryTestSuite | MappingQueryTest,
-    query: RawLambda,
-  ) {
-    super('', LAMBDA_PIPE);
-
-    makeObservable(this, {
-      query: observable,
-      isInitializingLambda: observable,
-      setIsInitializingLambda: action,
-      updateLamba: flow,
-    });
-
-    this.parent = parent;
-    this.editorStore = editorStore;
-    this.query = query;
-  }
-
-  get lambdaId(): string {
-    return buildSourceInformationSourceId([this.uuid]);
-  }
-
-  setIsInitializingLambda(val: boolean): void {
-    this.isInitializingLambda = val;
-  }
-
-  *updateLamba(val: RawLambda): GeneratorFn<void> {
-    this.query = val;
-    mappingTestable_setQuery(this.parent, val);
-    yield flowResult(this.convertLambdaObjectToGrammarString(true));
-  }
-
-  *convertLambdaObjectToGrammarString(pretty?: boolean): GeneratorFn<void> {
-    if (!isStubbed_RawLambda(this.query)) {
-      try {
-        const lambdas = new Map<string, RawLambda>();
-        lambdas.set(this.lambdaId, this.query);
-        const isolatedLambdas =
-          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
-            lambdas,
-            pretty,
-          )) as Map<string, string>;
-        const grammarText = isolatedLambdas.get(this.lambdaId);
-        this.setLambdaString(
-          grammarText !== undefined
-            ? this.extractLambdaString(grammarText)
-            : '',
-        );
-        this.clearErrors();
-      } catch (error) {
-        assertErrorThrown(error);
-        this.editorStore.applicationStore.logService.error(
-          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
-          error,
-        );
-      }
-    } else {
-      this.clearErrors();
-      this.setLambdaString('');
-    }
-  }
-
-  // NOTE: since we don't allow edition in text mode, we don't need to implement this
-  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
-    throw new UnsupportedOperationError();
-  }
-}
-
-export abstract class MappingTestState extends TestableTestEditorState {
-  readonly mappingTestableState: MappingTestableState;
-  readonly uuid = uuid();
-  override test: MappingTest;
-
-  constructor(
-    editorStore: EditorStore,
-    mappingTestableState: MappingTestableState,
-    test: MappingTest,
-  ) {
-    super(
-      mappingTestableState.mapping,
-      test,
-      mappingTestableState.mappingEditorState.isReadOnly,
-      editorStore,
-    );
-    this.mappingTestableState = mappingTestableState;
-    this.test = test;
-    this.selectedTab = this.defaultTab();
-  }
-
-  abstract defaultTab(): TESTABLE_TEST_TAB;
-}
+import {
+  createBareMappingTest,
+  createGraphFetchQueryFromMappingAnalysis,
+  generateStoreTestDataFromSetImpl,
+} from './MappingTestingHelper.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../../../../__lib__/LegendStudioEvent.js';
 
 export class StoreTestDataState {
   readonly editorStore: EditorStore;
-  readonly testDataState: MappingTestableDataState;
+  readonly testDataState: MappingTestDataState;
   storeTestData: StoreTestData;
-  generatingTestDataSate = ActionState.create();
   embeddedEditorState: EmbeddedDataEditorState;
+  dataElementModal = false;
 
   constructor(
     editorStore: EditorStore,
-    testDataState: MappingTestableDataState,
+    testDataState: MappingTestDataState,
     value: StoreTestData,
   ) {
     makeObservable(this, {
       storeTestData: observable,
-      generatingTestDataSate: observable,
+      dataElementModal: 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 {
+    mappingTestable_setEmbeddedData(
+      this.storeTestData,
+      val,
+      this.editorStore.changeDetectionState.observerContext,
+    );
     this.embeddedEditorState = new EmbeddedDataEditorState(
       this.testDataState.editorStore,
       this.storeTestData.data,
     );
   }
 }
-export class MappingTestableDataState {
+
+export class MappingTestDataState {
   readonly editorStore: EditorStore;
   readonly mappingTestableState: MappingTestableState;
   selectedDataState: StoreTestDataState | undefined;
-  dataHolder: MappingDataTest | MappingDataTestSuite;
+  dataHolder: MappingTest;
   showNewModal = false;
 
   constructor(
     editorStore: EditorStore,
     mappingTestableState: MappingTestableState,
-    holder: MappingDataTest | MappingDataTestSuite,
+    holder: MappingTest,
   ) {
     makeObservable(this, {
       selectedDataState: observable,
@@ -397,97 +207,136 @@ export class MappingTestableDataState {
   }
 }
 
-export class MappingQueryTestState extends MappingTestState {
-  override test: MappingQueryTest;
-  queryState: MappingTestableQueryState;
+export class MappingTestState extends TestableTestEditorState {
+  readonly parentState: MappingTestSuiteState;
+  readonly mappingTestableState: MappingTestableState;
+  readonly uuid = uuid();
+  override test: MappingTest;
+  dataState: MappingTestDataState;
 
   constructor(
     editorStore: EditorStore,
-    mappingTestableState: MappingTestableState,
-    test: MappingQueryTest,
+    parentSuiteState: MappingTestSuiteState,
+    test: MappingTest,
   ) {
-    super(editorStore, mappingTestableState, test);
+    super(
+      parentSuiteState.mappingTestableState.mapping,
+      test,
+      parentSuiteState.mappingTestableState.mappingEditorState.isReadOnly,
+      editorStore,
+    );
     makeObservable(this, {
-      defaultTab: observable,
       selectedAsertionState: observable,
       selectedTab: observable,
       assertionToRename: observable,
       assertionEditorStates: observable,
       testResultState: observable,
       runningTestAction: observable,
+      dataState: observable,
       addAssertion: action,
       setAssertionToRename: action,
       handleTestResult: action,
-      buildQueryState: action,
       setSelectedTab: action,
       runTest: flow,
-      test: observable,
     });
+    this.parentState = parentSuiteState;
+    this.mappingTestableState = parentSuiteState.mappingTestableState;
     this.test = test;
-    this.queryState = this.buildQueryState();
+    this.selectedTab = this.defaultTab();
+    this.dataState = new MappingTestDataState(
+      this.editorStore,
+      parentSuiteState.mappingTestableState,
+      test,
+    );
   }
 
-  override defaultTab(): TESTABLE_TEST_TAB {
+  defaultTab(): TESTABLE_TEST_TAB {
     return TESTABLE_TEST_TAB.SETUP;
   }
-
-  buildQueryState(): MappingTestableQueryState {
-    const queryState = new MappingTestableQueryState(
-      this.editorStore,
-      this.test,
-      this.test.func,
-    );
-    flowResult(queryState.updateLamba(this.test.func)).catch(
-      this.editorStore.applicationStore.alertUnhandledError,
-    );
-    return queryState;
-  }
 }
 
-export class MappingDataTestState extends MappingTestState {
-  override test: MappingDataTest;
-  dataState: MappingTestableDataState;
+export class MappingTestSuiteQueryState extends LambdaEditorState {
+  editorStore: EditorStore;
+  parent: MappingTestSuite;
+  isInitializingLambda = false;
+  query: RawLambda;
 
   constructor(
     editorStore: EditorStore,
-    mappingTestableState: MappingTestableState,
-    test: MappingDataTest,
+    parent: MappingTestSuite,
+    query: RawLambda,
   ) {
-    super(editorStore, mappingTestableState, test);
+    super('', LAMBDA_PIPE);
+
     makeObservable(this, {
-      defaultTab: observable,
-      selectedAsertionState: observable,
-      selectedTab: observable,
-      assertionToRename: observable,
-      assertionEditorStates: observable,
-      testResultState: observable,
-      runningTestAction: observable,
-      addAssertion: action,
-      setAssertionToRename: action,
-      handleTestResult: action,
-      setSelectedTab: action,
-      runTest: flow,
-      test: observable,
+      query: observable,
+      isInitializingLambda: observable,
+      setIsInitializingLambda: action,
+      updateLamba: flow,
     });
-    this.test = test;
-    this.dataState = new MappingTestableDataState(
-      this.editorStore,
-      mappingTestableState,
-      test,
-    );
+
+    this.parent = parent;
+    this.editorStore = editorStore;
+    this.query = query;
   }
 
-  override defaultTab(): TESTABLE_TEST_TAB {
-    return TESTABLE_TEST_TAB.SETUP;
+  get lambdaId(): string {
+    return buildSourceInformationSourceId([this.uuid]);
+  }
+
+  setIsInitializingLambda(val: boolean): void {
+    this.isInitializingLambda = val;
+  }
+
+  *updateLamba(val: RawLambda): GeneratorFn<void> {
+    this.query = val;
+    mappingTestable_setQuery(this.parent, val);
+    yield flowResult(this.convertLambdaObjectToGrammarString(true));
+  }
+
+  *convertLambdaObjectToGrammarString(pretty?: boolean): GeneratorFn<void> {
+    if (!isStubbed_RawLambda(this.query)) {
+      try {
+        const lambdas = new Map<string, RawLambda>();
+        lambdas.set(this.lambdaId, this.query);
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+            pretty,
+          )) as Map<string, string>;
+        const grammarText = isolatedLambdas.get(this.lambdaId);
+        this.setLambdaString(
+          grammarText !== undefined
+            ? this.extractLambdaString(grammarText)
+            : '',
+        );
+        this.clearErrors();
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+
+  // NOTE: since we don't allow edition in text mode, we don't need to implement this
+  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    throw new UnsupportedOperationError();
   }
 }
 
-export abstract class MappingTestSuiteState extends TestableTestSuiteEditorState {
+export class MappingTestSuiteState extends TestableTestSuiteEditorState {
   readonly mappingTestableState: MappingTestableState;
   override suite: MappingTestSuite;
   override testStates: MappingTestState[] = [];
   override selectTestState: MappingTestState | undefined;
   showCreateModal = false;
+  queryState: MappingTestSuiteQueryState;
 
   constructor(
     editorStore: EditorStore,
@@ -500,10 +349,26 @@ export abstract class MappingTestSuiteState extends TestableTestSuiteEditorState
       mappingTestableState.mappingEditorState.isReadOnly,
       editorStore,
     );
+    makeObservable(this, {
+      queryState: observable,
+      showCreateModal: observable,
+      selectTestState: observable,
+      runningSuiteState: observable,
+      setShowModal: action,
+      changeTest: action,
+      addNewTest: action,
+      deleteTest: action,
+      buildQueryState: action,
+      buildTestState: action,
+      createStoreTestData: action,
+      runSuite: flow,
+      runFailingTests: flow,
+    });
     this.mappingTestableState = mappingTestableState;
     this.suite = suite;
     this.testStates = this.buildTestStates();
     this.selectTestState = this.testStates[0];
+    this.queryState = this.buildQueryState();
   }
 
   buildTestStates(): MappingTestState[] {
@@ -512,12 +377,57 @@ export abstract class MappingTestSuiteState extends TestableTestSuiteEditorState
       .filter(isNonNullable);
   }
 
-  abstract getDefaultClass(): Class | undefined;
+  buildTestState(val: AtomicTest): MappingTestState | undefined {
+    if (val instanceof MappingTest) {
+      return new MappingTestState(this.editorStore, this, val);
+    }
+    return undefined;
+  }
 
-  abstract buildTestState(val: MappingTest): MappingTestState | undefined;
+  buildQueryState(): MappingTestSuiteQueryState {
+    const queryState = new MappingTestSuiteQueryState(
+      this.editorStore,
+      this.suite,
+      this.suite.func,
+    );
+    flowResult(queryState.updateLamba(this.suite.func)).catch(
+      this.editorStore.applicationStore.alertUnhandledError,
+    );
+    return queryState;
+  }
+
+  createStoreTestData(
+    targetClass: Class | undefined,
+  ): StoreTestData | undefined {
+    const firstData = this.suite.tests.filter(filterByType(MappingTest))[0]
+      ?.storeTestData[0];
+    if (firstData) {
+      const storeTestData = new StoreTestData();
+      storeTestData.store = PackageableElementExplicitReference.create(
+        firstData.store.value,
+      );
+      storeTestData.data = firstData.data.accept_EmbeddedDataVisitor(
+        new EmbeddedDataCreatorFromEmbeddedData(),
+      );
+      return storeTestData;
+    } else if (targetClass) {
+      const rootSetImpl = getRootSetImplementation(
+        this.mappingTestableState.mapping,
+        targetClass,
+      );
+      return rootSetImpl
+        ? generateStoreTestDataFromSetImpl(rootSetImpl, this.editorStore)
+        : undefined;
+    }
+    return undefined;
+  }
 
   addNewTest(id: string, _class: Class | undefined): void {
-    const test = this.createNewTest(id, _class);
+    const test = createBareMappingTest(
+      id,
+      this.createStoreTestData(_class),
+      this.suite,
+    );
     testSuite_addTest(
       this.suite,
       test,
@@ -531,8 +441,6 @@ export abstract class MappingTestSuiteState extends TestableTestSuiteEditorState
     this.selectTestState = testState;
   }
 
-  abstract createNewTest(id: string, _class: Class | undefined): MappingTest;
-
   setShowModal(val: boolean): void {
     this.showCreateModal = val;
   }
@@ -558,137 +466,6 @@ export abstract class MappingTestSuiteState extends TestableTestSuiteEditorState
   }
 }
 
-export class MappingDataTestSuiteState extends MappingTestSuiteState {
-  override suite: MappingDataTestSuite;
-  dataState: MappingTestableDataState;
-  declare testStates: MappingQueryTestState[];
-  declare selectTestState: MappingQueryTestState | undefined;
-
-  constructor(
-    editorStore: EditorStore,
-    mappingTestableState: MappingTestableState,
-    suite: MappingDataTestSuite,
-  ) {
-    super(editorStore, mappingTestableState, suite);
-    makeObservable(this, {
-      testStates: observable,
-      selectTestState: observable,
-      showCreateModal: observable,
-      buildTestStates: action,
-      changeTest: action,
-      deleteTest: action,
-      removeTestState: action,
-      addNewTest: action,
-      setShowModal: action,
-      runFailingTests: flow,
-      runSuite: flow,
-    });
-    this.suite = suite;
-    this.dataState = new MappingTestableDataState(
-      this.editorStore,
-      mappingTestableState,
-      suite,
-    );
-  }
-  override buildTestState(val: MappingTest): MappingTestState | undefined {
-    if (val instanceof MappingQueryTest) {
-      return new MappingQueryTestState(
-        this.editorStore,
-        this.mappingTestableState,
-        val,
-      );
-    }
-    return undefined;
-  }
-
-  override createNewTest(id: string, _class: Class | undefined): MappingTest {
-    const query = _class
-      ? this.mappingTestableState.createSuiteState.createDefaultQuery(_class)
-      : stub_RawLambda();
-    return createBareMappingQueryTest(id, query, this.suite);
-  }
-
-  getDefaultClass(): Class | undefined {
-    return getMappingCompatibleClasses(
-      this.dataState.mappingTestableState.mapping,
-      this.dataState.mappingTestableState.editorStore.graphManagerState
-        .usableClasses,
-    )[0];
-  }
-}
-
-export class MappingQueryTestSuiteState extends MappingTestSuiteState {
-  override suite: MappingQueryTestSuite;
-  declare testStates: MappingDataTestState[];
-  declare selectTestState: MappingDataTestState | undefined;
-  queryState: MappingTestableQueryState;
-
-  constructor(
-    editorStore: EditorStore,
-    mappingTestableState: MappingTestableState,
-    suite: MappingQueryTestSuite,
-  ) {
-    super(editorStore, mappingTestableState, suite);
-    makeObservable(this, {
-      queryState: observable,
-      testStates: observable,
-      selectTestState: observable,
-      showCreateModal: observable,
-      deleteTest: action,
-      buildTestStates: action,
-      buildQueryState: action,
-      addNewTest: action,
-      changeTest: action,
-      setShowModal: action,
-      runFailingTests: flow,
-      runSuite: flow,
-    });
-    this.suite = suite;
-    this.queryState = this.buildQueryState();
-  }
-
-  override buildTestState(val: MappingTest): MappingTestState | undefined {
-    if (val instanceof MappingDataTest) {
-      return new MappingDataTestState(
-        this.editorStore,
-        this.mappingTestableState,
-        val,
-      );
-    }
-    return undefined;
-  }
-
-  override createNewTest(id: string, _class: Class | undefined): MappingTest {
-    const data = _class
-      ? createBareModelStoreData(_class, this.mappingTestableState.editorStore)
-      : undefined;
-    return createBareMappingDataTest(id, data, this.suite);
-  }
-
-  buildQueryState(): MappingTestableQueryState {
-    const queryState = new MappingTestableQueryState(
-      this.editorStore,
-      this.suite,
-      this.suite.func,
-    );
-    flowResult(queryState.updateLamba(this.suite.func)).catch(
-      this.editorStore.applicationStore.alertUnhandledError,
-    );
-    return queryState;
-  }
-
-  getDefaultClass(): Class | undefined {
-    const dataTest = this.suite.tests.filter(filterByType(MappingDataTest))[0];
-    if (dataTest) {
-      const storeTestData = dataTest.storeTestData[0]?.data;
-      if (storeTestData instanceof ModelStoreData) {
-        return storeTestData.modelData?.[0]?.model.value;
-      }
-    }
-    return undefined;
-  }
-}
-
 export class CreateSuiteState {
   readonly editorStore: EditorStore;
   readonly mappingTestableState: MappingTestableState;
@@ -704,26 +481,22 @@ export class CreateSuiteState {
 
     makeObservable(this, {
       showModal: observable,
-      setShowModal: action,
       createAndAddTestSuite: flow,
       isCreatingSuiteState: observable,
     });
   }
 
-  setShowModal(val: boolean): void {
-    this.showModal = val;
-  }
-
   *createAndAddTestSuite(
     _class: Class,
-    type: MAPPING_TEST_SUITE_TYPE,
-    name: string,
+    suiteName: string,
     testName: string,
   ): GeneratorFn<void> {
-    // type
     try {
       this.isCreatingSuiteState.inProgress();
       const mappingTestableState = this.mappingTestableState;
+      const mappingTestSuite = new MappingTestSuite();
+      mappingTestSuite.id = suiteName;
+      // mapping anaylsis
       if (!mappingTestableState.mappingModelCoverageAnalysisResult) {
         this.isCreatingSuiteState.setMessage(
           'Analyzing mapping to generate test query...',
@@ -731,60 +504,30 @@ export class CreateSuiteState {
         yield flowResult(mappingTestableState.analyzeMappingModelCoverage());
       }
       this.isCreatingSuiteState.setMessage('Creating test query...');
+      // add query
+      mappingTestSuite.func = createGraphFetchQueryFromMappingAnalysis(
+        _class,
+        mappingTestableState.editorStore.graphManagerState,
+        mappingTestableState.mappingModelCoverageAnalysisResult,
+      );
+      // add first test
       const rootSetImpl = getRootSetImplementation(
-        this.mappingTestableState.mapping,
+        mappingTestableState.mapping,
         _class,
       );
-      const query = this.createDefaultQuery(_class);
       const storeTestData = rootSetImpl
-        ? this.attemptToGenerateTestData(rootSetImpl, this.editorStore)
+        ? generateStoreTestDataFromSetImpl(rootSetImpl, this.editorStore)
         : undefined;
-      let testSuite: MappingTestSuite;
-      if (type === MAPPING_TEST_SUITE_TYPE.DATA) {
-        const dataSuite = new MappingDataTestSuite();
-        dataSuite.storeTestData = storeTestData ? [storeTestData] : [];
-        const test = createBareMappingQueryTest(testName, query, dataSuite);
-        test.__parent = dataSuite;
-        dataSuite.tests = [test];
-        const _assertion = createDefaultEqualToJSONTestAssertion(
-          `${testName}_assertion1`,
-        );
-        test.assertions = [_assertion];
-        _assertion.parentTest = test;
-        testSuite = dataSuite;
-      } else {
-        const querySuite = new MappingQueryTestSuite();
-        querySuite.func = query;
-        // add test
-        const _test = createBareMappingDataTest(
-          testName,
-          storeTestData,
-          querySuite,
-        );
-        const _assertion = createDefaultEqualToJSONTestAssertion(
-          `${testName}_assertion1`,
-        );
-        _test.assertions = [_assertion];
-        _assertion.parentTest = _test;
-        testSuite = querySuite;
-      }
-      testSuite.id = name;
+
+      createBareMappingTest(testName, storeTestData, mappingTestSuite);
+      // set test suite
       mapping_addTestSuite(
         this.mappingTestableState.mapping,
-        testSuite,
+        mappingTestSuite,
         this.editorStore.changeDetectionState.observerContext,
       );
-      this.mappingTestableState.changeSuite(testSuite);
-      const selectTestState =
-        this.mappingTestableState.selectedTestSuite?.selectTestState;
-      const selectedAsertionState = selectTestState?.selectedAsertionState;
-      if (selectTestState && selectedAsertionState) {
-        this.isCreatingSuiteState.setMessage(
-          'Attempting to generate expected result...',
-        );
-        yield flowResult(selectedAsertionState.generateExpected());
-      }
-      this.setShowModal(false);
+      this.mappingTestableState.changeSuite(mappingTestSuite);
+      this.mappingTestableState.closeCreateModal();
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(
@@ -795,128 +538,26 @@ export class CreateSuiteState {
       this.isCreatingSuiteState.setMessage(undefined);
     }
   }
-
-  createDefaultQuery(_class: Class): RawLambda {
-    try {
-      const mappingTestableState = this.mappingTestableState;
-      const anaylsis = guaranteeNonNullable(
-        mappingTestableState.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((e) => {
-        if (!(e instanceof EntityMappedProperty)) {
-          const name = e.name;
-          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 === name);
-          if (property) {
-            const subTree = new PropertyGraphFetchTree(
-              PropertyExplicitReference.create(property),
-              undefined,
-            );
-            rootTree.subTrees.push(subTree);
-          }
-        }
-      });
-      assertTrue(!rootTree.isEmpty);
-      return createGraphFetchLambda(
-        _class,
-        this.editorStore.graphManagerState,
-        rootTree,
-      );
-    } catch (error) {
-      assertErrorThrown(error);
-      const lambdaFunction = new LambdaFunction(
-        new FunctionType(
-          PackageableElementExplicitReference.create(
-            this.editorStore.graphManagerState.graph.getType(
-              CORE_PURE_PATH.ANY,
-            ),
-          ),
-          Multiplicity.ONE,
-        ),
-      );
-      lambdaFunction.expressionSequence = [
-        buildGetAllFunction(_class, Multiplicity.ONE),
-      ];
-      return buildRawLambdaFromLambdaFunction(
-        lambdaFunction,
-        this.editorStore.graphManagerState,
-      );
-    }
-  }
-
-  // change to use api call for relational
-  attemptToGenerateTestData(
-    setImpl: SetImplementation,
-    editorStore: EditorStore,
-  ): 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 (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 createBareModelStoreData(
-          srcClass.value,
-          this.mappingTestableState.editorStore,
-        );
-      }
-    }
-    return undefined;
-  }
 }
 
 export class MappingTestableState {
   readonly editorStore: EditorStore;
   readonly mappingEditorState: MappingEditorState;
-  selectedTestSuite: MappingTestSuiteState | undefined;
-  testableComponentToRename:
-    | MappingTestSuite
-    | MappingTest
-    | TestAssertion
-    | undefined;
-  // state
-  createSuiteState: CreateSuiteState;
   mappingModelCoverageAnalysisState = ActionState.create();
   mappingModelCoverageAnalysisResult:
     | MappingModelCoverageAnalysisResult
     | undefined;
 
+  testableComponentToRename: MappingTestSuite | MappingTest | undefined;
+  createSuiteState: CreateSuiteState | undefined;
+
+  isRunningTestableSuitesState = ActionState.create();
+  isRunningFailingSuitesState = ActionState.create();
+
+  selectedTestSuite: MappingTestSuiteState | undefined;
+  testableResults: TestResult[] | undefined;
+  runningSuite: MappingTestSuite | undefined;
+
   constructor(
     editorStore: EditorStore,
     mappingEditorState: MappingEditorState,
@@ -927,16 +568,22 @@ export class MappingTestableState {
       selectedTestSuite: observable,
       testableComponentToRename: observable,
       renameTestableComponent: observable,
+      testableResults: observable,
+      createSuiteState: observable,
       changeSuite: action,
+      closeCreateModal: action,
+      openCreateModal: action,
       init: action,
       deleteTestSuite: action,
       analyzeMappingModelCoverage: flow,
       setRenameComponent: action,
+      handleNewResults: action,
+      runTestable: flow,
+      runSuite: flow,
+      runAllFailingSuites: flow,
     });
-
     this.editorStore = editorStore;
     this.mappingEditorState = mappingEditorState;
-    this.createSuiteState = new CreateSuiteState(this.editorStore, this);
     this.init();
   }
 
@@ -944,21 +591,80 @@ export class MappingTestableState {
     return this.mappingEditorState.mapping;
   }
 
-  renameTestableComponent(val: string | undefined): void {
-    const _component = this.testableComponentToRename;
-    if (_component) {
-      testable_setId(_component, val ?? '');
+  get suiteCount(): number {
+    return this.mapping.tests.length;
+  }
+
+  get passingSuites(): MappingTestSuite[] {
+    const results = this.testableResults;
+    if (results?.length) {
+      return this.mapping.tests.filter((suite) =>
+        results
+          .filter((res) => res.parentSuite?.id === suite.id)
+          .every((e) => isTestPassing(e)),
+      );
+    }
+    return [];
+  }
+
+  get failingSuites(): MappingTestSuite[] {
+    const results = this.testableResults;
+    if (results?.length) {
+      return this.mapping.tests.filter((suite) =>
+        results
+          .filter((res) => res.parentSuite?.id === suite.id)
+          .some((e) => !isTestPassing(e)),
+      );
     }
+    return [];
+  }
+
+  get staticSuites(): MappingTestSuite[] {
+    const results = this.testableResults;
+    if (results?.length) {
+      return this.mapping.tests.filter((suite) =>
+        results.every((res) => res.parentSuite?.id !== suite.id),
+      );
+    }
+    return this.mapping.tests;
+  }
+
+  resolveSuiteResults(suite: MappingTestSuite): TestResult[] | undefined {
+    return this.testableResults?.filter((t) => t.parentSuite?.id === suite.id);
+  }
+
+  clearTestResultsForSuite(suite: MappingTestSuite): void {
+    this.testableResults = this.testableResults?.filter(
+      (t) => !(this.resolveSuiteResults(suite) ?? []).includes(t),
+    );
+  }
+
+  setTestableResults(val: TestResult[] | undefined): void {
+    this.testableResults = val;
   }
 
   init(): void {
-    // TODO: ? should we add a test suite here by default if certain things
     const suite = this.mapping.tests[0];
     this.selectedTestSuite = suite
       ? this.buildTestSuiteState(suite)
       : undefined;
   }
 
+  openCreateModal(): void {
+    this.createSuiteState = new CreateSuiteState(this.editorStore, this);
+  }
+
+  closeCreateModal(): void {
+    this.createSuiteState = undefined;
+  }
+
+  renameTestableComponent(val: string | undefined): void {
+    const _component = this.testableComponentToRename;
+    if (_component) {
+      testable_setId(_component, val ?? '');
+    }
+  }
+
   changeSuite(suite: MappingTestSuite): void {
     if (this.selectedTestSuite?.suite !== suite) {
       this.selectedTestSuite = this.buildTestSuiteState(suite);
@@ -966,7 +672,7 @@ export class MappingTestableState {
   }
 
   setRenameComponent(
-    testSuite: MappingTestSuite | AtomicTest | undefined,
+    testSuite: MappingTestSuite | MappingTest | undefined,
   ): void {
     this.testableComponentToRename = testSuite;
   }
@@ -978,25 +684,12 @@ export class MappingTestableState {
     }
   }
 
-  buildTestSuiteStates(): MappingTestSuiteState[] {
-    return this.mapping.tests
-      .map((suite) => this.buildTestSuiteState(suite))
-      .filter(isNonNullable);
-  }
-
-  buildTestSuiteState(
-    val: MappingTestSuite,
-  ): MappingTestSuiteState | undefined {
-    if (val instanceof MappingQueryTestSuite) {
-      return new MappingQueryTestSuiteState(this.editorStore, this, val);
-    } else if (val instanceof MappingDataTestSuite) {
-      return new MappingDataTestSuiteState(this.editorStore, this, val);
-    }
-    return undefined;
+  buildTestSuiteState(val: MappingTestSuite): MappingTestSuiteState {
+    return new MappingTestSuiteState(this.editorStore, this, val);
   }
 
-  // check to only anaylsis when mapping has changed
   *analyzeMappingModelCoverage(): GeneratorFn<void> {
+    this.mappingModelCoverageAnalysisResult = undefined;
     this.mappingModelCoverageAnalysisState.inProgress();
     this.mappingModelCoverageAnalysisState.setMessage('Analyzing Mapping...');
     try {
@@ -1008,19 +701,116 @@ export class MappingTestableState {
       )) as MappingModelCoverageAnalysisResult;
     } catch (error) {
       assertErrorThrown(error);
-      this.editorStore.applicationStore.notificationService.notifyError(
-        error.message,
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(LEGEND_STUDIO_APP_EVENT.MAPPING_TEST_FAILURE),
+        error,
       );
     } finally {
       this.mappingModelCoverageAnalysisState.complete();
     }
   }
 
-  runAllSuites(): void {
-    // TODO
+  *runSuite(suite: MappingTestSuite): 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.mapping);
+      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;
+    }
+  }
+
+  *runTestable(): GeneratorFn<void> {
+    try {
+      this.setTestableResults(undefined);
+      this.isRunningTestableSuitesState.inProgress();
+      this.selectedTestSuite?.testStates.forEach((t) => t.resetResult());
+      this.selectedTestSuite?.testStates.forEach((t) =>
+        t.runningTestAction.inProgress(),
+      );
+      const input = new RunTestsTestableInput(this.mapping);
+      const testResults =
+        (yield this.editorStore.graphManagerState.graphManager.runTests(
+          [input],
+          this.editorStore.graphManagerState.graph,
+        )) as TestResult[];
+      this.handleNewResults(testResults);
+      this.isRunningTestableSuitesState.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+      this.isRunningTestableSuitesState.fail();
+    } finally {
+      this.selectedTestSuite?.testStates.forEach((t) =>
+        t.runningTestAction.complete(),
+      );
+    }
+  }
+
+  *runAllFailingSuites(): GeneratorFn<void> {
+    try {
+      this.isRunningFailingSuitesState.inProgress();
+      const input = new RunTestsTestableInput(this.mapping);
+      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(),
+      );
+    }
   }
 
-  runAllFailingSuites(): void {
-    // TODO
+  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);
+    });
   }
 }