@finos/legend-application-studio 27.1.0 → 27.1.1

package/lib/stores/editor/editor-state/element-editor-state/mapping/testable/MappingTestableState.js

@@ -13,152 +13,48 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { 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, } from '@finos/legend-graph';
+import { MappingTestSuite, MappingTest, LAMBDA_PIPE, buildSourceInformationSourceId, isStubbed_RawLambda, GRAPH_MANAGER_EVENT, PackageableElementExplicitReference, StoreTestData, getRootSetImplementation, DataElementReference, RelationalCSVData, RunTestsTestableInput, UniqueTestId, } from '@finos/legend-graph';
 import { action, flow, flowResult, makeObservable, observable } from 'mobx';
-import { ActionState, assertErrorThrown, guaranteeNonNullable, assertTrue, isNonNullable, UnsupportedOperationError, LogEvent, uuid, filterByType, } from '@finos/legend-shared';
-import { LambdaEditorState, buildGetAllFunction, buildSerialzieFunctionWithGraphFetch, } from '@finos/legend-query-builder';
-import { getMappingElementSource, } from '../MappingEditorState.js';
-import { mappingTestable_addStoreTestData, mappingTestable_deleteStoreTestData, mappingTestable_setQuery, mapping_addTestSuite, mapping_deleteTestSuite, } from '../../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
-import { DEFAULT_TEST_ASSERTION_ID, createBareExternalFormat, createDefaultEqualToJSONTestAssertion, createEmbeddedDataFromClass, } from '../../../../utils/TestableUtils.js';
+import { ActionState, assertErrorThrown, isNonNullable, UnsupportedOperationError, LogEvent, uuid, filterByType, } from '@finos/legend-shared';
+import { LambdaEditorState } from '@finos/legend-query-builder';
+import {} from '../MappingEditorState.js';
+import { mappingTestable_addStoreTestData, mappingTestable_deleteStoreTestData, mappingTestable_setEmbeddedData, mappingTestable_setQuery, mapping_addTestSuite, mapping_deleteTestSuite, } from '../../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
+import { EmbeddedDataCreatorFromEmbeddedData, createBareExternalFormat, isTestPassing, } from '../../../../utils/TestableUtils.js';
 import { TESTABLE_TEST_TAB, TestableTestEditorState, TestableTestSuiteEditorState, } from '../../testable/TestableEditorState.js';
 import { EmbeddedDataEditorState } from '../../data/DataEditorState.js';
 import { testSuite_addTest, testSuite_deleteTest, testable_setId, } from '../../../../../graph-modifier/Testable_GraphModifierHelper.js';
 import { EmbeddedDataType } from '../../../ExternalFormatState.js';
-import { createMockDataForTable } from '../../../../utils/MockDataUtils.js';
-export var MAPPING_TEST_SUITE_TYPE;
-(function (MAPPING_TEST_SUITE_TYPE) {
-    MAPPING_TEST_SUITE_TYPE["DATA"] = "DATA";
-    MAPPING_TEST_SUITE_TYPE["QUERY"] = "QUERY";
-})(MAPPING_TEST_SUITE_TYPE || (MAPPING_TEST_SUITE_TYPE = {}));
-const createGraphFetchLambda = (mainClass, graphManagerState, root) => {
-    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, editorStore) => {
-    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, storeTestData, suite) => {
-    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, query, suite) => {
-    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;
-    parent;
-    isInitializingLambda = false;
-    query;
-    constructor(editorStore, parent, query) {
-        super('', LAMBDA_PIPE);
-        makeObservable(this, {
-            query: observable,
-            isInitializingLambda: observable,
-            setIsInitializingLambda: action,
-            updateLamba: flow,
-        });
-        this.parent = parent;
-        this.editorStore = editorStore;
-        this.query = query;
-    }
-    get lambdaId() {
-        return buildSourceInformationSourceId([this.uuid]);
-    }
-    setIsInitializingLambda(val) {
-        this.isInitializingLambda = val;
-    }
-    *updateLamba(val) {
-        this.query = val;
-        mappingTestable_setQuery(this.parent, val);
-        yield flowResult(this.convertLambdaObjectToGrammarString(true));
-    }
-    *convertLambdaObjectToGrammarString(pretty) {
-        if (!isStubbed_RawLambda(this.query)) {
-            try {
-                const lambdas = new Map();
-                lambdas.set(this.lambdaId, this.query);
-                const isolatedLambdas = (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(lambdas, pretty));
-                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() {
-        throw new UnsupportedOperationError();
-    }
-}
-export class MappingTestState extends TestableTestEditorState {
-    mappingTestableState;
-    uuid = uuid();
-    test;
-    constructor(editorStore, mappingTestableState, test) {
-        super(mappingTestableState.mapping, test, mappingTestableState.mappingEditorState.isReadOnly, editorStore);
-        this.mappingTestableState = mappingTestableState;
-        this.test = test;
-        this.selectedTab = this.defaultTab();
-    }
-}
+import { createBareMappingTest, createGraphFetchQueryFromMappingAnalysis, generateStoreTestDataFromSetImpl, } from './MappingTestingHelper.js';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../../../../__lib__/LegendStudioEvent.js';
 export class StoreTestDataState {
     editorStore;
     testDataState;
     storeTestData;
-    generatingTestDataSate = ActionState.create();
     embeddedEditorState;
+    dataElementModal = false;
     constructor(editorStore, testDataState, value) {
         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) {
+        this.dataElementModal = val;
+    }
+    changeEmbeddedData(val) {
+        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 {
     editorStore;
     mappingTestableState;
     selectedDataState;
@@ -217,64 +113,91 @@ export class MappingTestableDataState {
         this.openStoreTestData(_storeData);
     }
 }
-export class MappingQueryTestState extends MappingTestState {
+export class MappingTestState extends TestableTestEditorState {
+    parentState;
+    mappingTestableState;
+    uuid = uuid();
     test;
-    queryState;
-    constructor(editorStore, mappingTestableState, test) {
-        super(editorStore, mappingTestableState, test);
+    dataState;
+    constructor(editorStore, parentSuiteState, 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);
     }
     defaultTab() {
         return TESTABLE_TEST_TAB.SETUP;
     }
-    buildQueryState() {
-        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 {
-    test;
-    dataState;
-    constructor(editorStore, mappingTestableState, test) {
-        super(editorStore, mappingTestableState, test);
+export class MappingTestSuiteQueryState extends LambdaEditorState {
+    editorStore;
+    parent;
+    isInitializingLambda = false;
+    query;
+    constructor(editorStore, parent, query) {
+        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;
     }
-    defaultTab() {
-        return TESTABLE_TEST_TAB.SETUP;
+    get lambdaId() {
+        return buildSourceInformationSourceId([this.uuid]);
+    }
+    setIsInitializingLambda(val) {
+        this.isInitializingLambda = val;
+    }
+    *updateLamba(val) {
+        this.query = val;
+        mappingTestable_setQuery(this.parent, val);
+        yield flowResult(this.convertLambdaObjectToGrammarString(true));
+    }
+    *convertLambdaObjectToGrammarString(pretty) {
+        if (!isStubbed_RawLambda(this.query)) {
+            try {
+                const lambdas = new Map();
+                lambdas.set(this.lambdaId, this.query);
+                const isolatedLambdas = (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(lambdas, pretty));
+                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() {
+        throw new UnsupportedOperationError();
     }
 }
 export class MappingTestSuiteState extends TestableTestSuiteEditorState {
@@ -283,20 +206,65 @@ export class MappingTestSuiteState extends TestableTestSuiteEditorState {
     testStates = [];
     selectTestState;
     showCreateModal = false;
+    queryState;
     constructor(editorStore, mappingTestableState, suite) {
         super(mappingTestableState.mapping, suite, 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() {
         return this.suite.tests
             .map((t) => this.buildTestState(t))
             .filter(isNonNullable);
     }
+    buildTestState(val) {
+        if (val instanceof MappingTest) {
+            return new MappingTestState(this.editorStore, this, val);
+        }
+        return undefined;
+    }
+    buildQueryState() {
+        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) {
+        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, _class) {
-        const test = this.createNewTest(id, _class);
+        const test = createBareMappingTest(id, this.createStoreTestData(_class), this.suite);
         testSuite_addTest(this.suite, test, this.mappingTestableState.editorStore.changeDetectionState
             .observerContext);
         const testState = this.buildTestState(test);
@@ -324,94 +292,6 @@ export class MappingTestSuiteState extends TestableTestSuiteEditorState {
         this.testStates = this.testStates.filter((e) => e.test !== val);
     }
 }
-export class MappingDataTestSuiteState extends MappingTestSuiteState {
-    suite;
-    dataState;
-    constructor(editorStore, mappingTestableState, suite) {
-        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);
-    }
-    buildTestState(val) {
-        if (val instanceof MappingQueryTest) {
-            return new MappingQueryTestState(this.editorStore, this.mappingTestableState, val);
-        }
-        return undefined;
-    }
-    createNewTest(id, _class) {
-        const query = _class
-            ? this.mappingTestableState.createSuiteState.createDefaultQuery(_class)
-            : stub_RawLambda();
-        return createBareMappingQueryTest(id, query, this.suite);
-    }
-    getDefaultClass() {
-        return getMappingCompatibleClasses(this.dataState.mappingTestableState.mapping, this.dataState.mappingTestableState.editorStore.graphManagerState
-            .usableClasses)[0];
-    }
-}
-export class MappingQueryTestSuiteState extends MappingTestSuiteState {
-    suite;
-    queryState;
-    constructor(editorStore, mappingTestableState, suite) {
-        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();
-    }
-    buildTestState(val) {
-        if (val instanceof MappingDataTest) {
-            return new MappingDataTestState(this.editorStore, this.mappingTestableState, val);
-        }
-        return undefined;
-    }
-    createNewTest(id, _class) {
-        const data = _class
-            ? createBareModelStoreData(_class, this.mappingTestableState.editorStore)
-            : undefined;
-        return createBareMappingDataTest(id, data, this.suite);
-    }
-    buildQueryState() {
-        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() {
-        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 {
     editorStore;
     mappingTestableState;
@@ -422,61 +302,34 @@ export class CreateSuiteState {
         this.mappingTestableState = mappingTestableState;
         makeObservable(this, {
             showModal: observable,
-            setShowModal: action,
             createAndAddTestSuite: flow,
             isCreatingSuiteState: observable,
         });
     }
-    setShowModal(val) {
-        this.showModal = val;
-    }
-    *createAndAddTestSuite(_class, type, name, testName) {
-        // type
+    *createAndAddTestSuite(_class, suiteName, testName) {
         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...');
                 yield flowResult(mappingTestableState.analyzeMappingModelCoverage());
             }
             this.isCreatingSuiteState.setMessage('Creating test query...');
-            const rootSetImpl = getRootSetImplementation(this.mappingTestableState.mapping, _class);
-            const query = this.createDefaultQuery(_class);
+            // add query
+            mappingTestSuite.func = createGraphFetchQueryFromMappingAnalysis(_class, mappingTestableState.editorStore.graphManagerState, mappingTestableState.mappingModelCoverageAnalysisResult);
+            // add first test
+            const rootSetImpl = getRootSetImplementation(mappingTestableState.mapping, _class);
             const storeTestData = rootSetImpl
-                ? this.attemptToGenerateTestData(rootSetImpl, this.editorStore)
+                ? generateStoreTestDataFromSetImpl(rootSetImpl, this.editorStore)
                 : undefined;
-            let testSuite;
-            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;
-            mapping_addTestSuite(this.mappingTestableState.mapping, testSuite, 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);
+            createBareMappingTest(testName, storeTestData, mappingTestSuite);
+            // set test suite
+            mapping_addTestSuite(this.mappingTestableState.mapping, mappingTestSuite, this.editorStore.changeDetectionState.observerContext);
+            this.mappingTestableState.changeSuite(mappingTestSuite);
+            this.mappingTestableState.closeCreateModal();
         }
         catch (error) {
             assertErrorThrown(error);
@@ -487,81 +340,19 @@ export class CreateSuiteState {
             this.isCreatingSuiteState.setMessage(undefined);
         }
     }
-    createDefaultQuery(_class) {
-        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.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, editorStore) {
-        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 {
     editorStore;
     mappingEditorState;
-    selectedTestSuite;
-    testableComponentToRename;
-    // state
-    createSuiteState;
     mappingModelCoverageAnalysisState = ActionState.create();
     mappingModelCoverageAnalysisResult;
+    testableComponentToRename;
+    createSuiteState;
+    isRunningTestableSuitesState = ActionState.create();
+    isRunningFailingSuitesState = ActionState.create();
+    selectedTestSuite;
+    testableResults;
+    runningSuite;
     constructor(editorStore, mappingEditorState) {
         makeObservable(this, {
             mappingModelCoverageAnalysisResult: observable,
@@ -569,33 +360,82 @@ 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();
     }
     get mapping() {
         return this.mappingEditorState.mapping;
     }
-    renameTestableComponent(val) {
-        const _component = this.testableComponentToRename;
-        if (_component) {
-            testable_setId(_component, val ?? '');
+    get suiteCount() {
+        return this.mapping.tests.length;
+    }
+    get passingSuites() {
+        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() {
+        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() {
+        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) {
+        return this.testableResults?.filter((t) => t.parentSuite?.id === suite.id);
+    }
+    clearTestResultsForSuite(suite) {
+        this.testableResults = this.testableResults?.filter((t) => !(this.resolveSuiteResults(suite) ?? []).includes(t));
+    }
+    setTestableResults(val) {
+        this.testableResults = val;
     }
     init() {
-        // 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() {
+        this.createSuiteState = new CreateSuiteState(this.editorStore, this);
+    }
+    closeCreateModal() {
+        this.createSuiteState = undefined;
+    }
+    renameTestableComponent(val) {
+        const _component = this.testableComponentToRename;
+        if (_component) {
+            testable_setId(_component, val ?? '');
+        }
+    }
     changeSuite(suite) {
         if (this.selectedTestSuite?.suite !== suite) {
             this.selectedTestSuite = this.buildTestSuiteState(suite);
@@ -610,22 +450,11 @@ export class MappingTestableState {
             this.init();
         }
     }
-    buildTestSuiteStates() {
-        return this.mapping.tests
-            .map((suite) => this.buildTestSuiteState(suite))
-            .filter(isNonNullable);
-    }
     buildTestSuiteState(val) {
-        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;
+        return new MappingTestSuiteState(this.editorStore, this, val);
     }
-    // check to only anaylsis when mapping has changed
     *analyzeMappingModelCoverage() {
+        this.mappingModelCoverageAnalysisResult = undefined;
         this.mappingModelCoverageAnalysisState.inProgress();
         this.mappingModelCoverageAnalysisState.setMessage('Analyzing Mapping...');
         try {
@@ -633,17 +462,89 @@ export class MappingTestableState {
         }
         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() {
-        // TODO
+    *runSuite(suite) {
+        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));
+            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() {
-        // TODO
+    *runTestable() {
+        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));
+            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() {
+        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));
+            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) {
+        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);
+        });
     }
 }
 //# sourceMappingURL=MappingTestableState.js.map