@finos/legend-application-studio 13.0.0

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

@@ -0,0 +1,405 @@
+/**
+ * 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 {
+  type ServiceTest,
+  type Service,
+  type ValueSpecification,
+  type RawLambda,
+  observe_ValueSpecification,
+  ParameterValue,
+  buildLambdaVariableExpressions,
+  VariableExpression,
+  generateVariableExpressionMockValue,
+} from '@finos/legend-graph';
+import { action, flow, makeObservable, observable } from 'mobx';
+import { TestableTestEditorState } from '../../testable/TestableEditorState.js';
+import type { ServiceTestSuiteState } from './ServiceTestableState.js';
+import {
+  service_addParameterValue,
+  service_deleteParameterValue,
+  service_setParameterName,
+  service_setParameterValues,
+  service_setParameterValueSpec,
+  service_setSerializationFormat,
+} from '../../../../graphModifier/DSLService_GraphModifierHelper.js';
+import {
+  assertErrorThrown,
+  deleteEntry,
+  filterByType,
+  guaranteeNonNullable,
+  isNonNullable,
+  returnUndefOnError,
+  uuid,
+} from '@finos/legend-shared';
+import type { EditorStore } from '../../../../EditorStore.js';
+
+export enum SERIALIZATION_FORMAT {
+  PURE = 'PURE',
+  // Temporary remove this option as it is currently not being read correctly.
+  // See https://github.com/finos/legend-engine/pull/799
+  // DEFAULT = 'DEFAULT',
+  PURE_TDSOBJECT = 'PURE_TDSOBJECT',
+}
+
+export enum SERIALIZATION_FORMAT_LABEL {
+  PURE = 'PURE',
+  TDS = 'TDS',
+}
+
+const getSerializationFormatLabel = (val: string): string => {
+  switch (val) {
+    case SERIALIZATION_FORMAT.PURE:
+      return SERIALIZATION_FORMAT.PURE;
+    case SERIALIZATION_FORMAT.PURE_TDSOBJECT:
+      return SERIALIZATION_FORMAT_LABEL.TDS;
+    default:
+      return val;
+  }
+};
+
+export type SerializationFormatOption = {
+  value: string;
+  label: string;
+};
+
+export class ServiceTestParameterState {
+  readonly uuid = uuid();
+  readonly editorStore: EditorStore;
+  readonly setupState: ServiceTestSetupState;
+  parameterValue: ParameterValue;
+  constructor(
+    parameterValue: ParameterValue,
+    editorStore: EditorStore,
+    setupState: ServiceTestSetupState,
+  ) {
+    this.editorStore = editorStore;
+    this.setupState = setupState;
+    this.parameterValue = parameterValue;
+  }
+}
+
+export class ServiceValueSpecificationTestParameterState extends ServiceTestParameterState {
+  valueSpec: ValueSpecification;
+  varExpression: VariableExpression;
+  constructor(
+    parameterValue: ParameterValue,
+    editorStore: EditorStore,
+    setupState: ServiceTestSetupState,
+    valueSpec: ValueSpecification,
+    varExpression: VariableExpression,
+  ) {
+    super(parameterValue, editorStore, setupState);
+    makeObservable(this, {
+      setName: observable,
+      valueSpec: observable,
+      parameterValue: observable,
+      resetValueSpec: action,
+      updateValueSpecification: action,
+      updateParameterValue: action,
+    });
+    this.valueSpec = valueSpec;
+    this.varExpression = varExpression;
+  }
+
+  updateValueSpecification(val: ValueSpecification): void {
+    this.valueSpec = observe_ValueSpecification(
+      val,
+      this.editorStore.changeDetectionState.observerContext,
+    );
+    this.updateParameterValue();
+  }
+
+  updateParameterValue(): void {
+    const updatedValueSpec =
+      this.editorStore.graphManagerState.graphManager.serializeValueSpecification(
+        this.valueSpec,
+      );
+    service_setParameterValueSpec(this.parameterValue, updatedValueSpec);
+  }
+
+  setName(val: string): void {
+    service_setParameterName(this.parameterValue, val);
+  }
+
+  resetValueSpec(): void {
+    const mockValue = generateVariableExpressionMockValue(this.varExpression);
+    if (mockValue) {
+      this.updateValueSpecification(mockValue);
+    }
+  }
+}
+
+export class ServiceTestSetupState {
+  readonly editorStore: EditorStore;
+  readonly testState: ServiceTestState;
+  parameterValueStates: ServiceTestParameterState[] = [];
+  newParameterValueName = '';
+  showNewParameterModal = false;
+
+  constructor(testState: ServiceTestState) {
+    this.testState = testState;
+    this.editorStore = testState.editorStore;
+    makeObservable(this, {
+      changeSerializationFormat: action,
+      parameterValueStates: observable,
+      buildParameterStates: action,
+      newParameterValueName: observable,
+      showNewParameterModal: observable,
+      setNewParameterValueName: action,
+      setShowNewParameterModal: action,
+      openNewParamModal: action,
+      addParameterValue: action,
+      syncWithQuery: action,
+      removeParamValueState: action,
+    });
+    this.parameterValueStates = this.buildParameterStates();
+  }
+
+  get serviceQuery(): RawLambda | undefined {
+    return this.testState.suiteState.testableState.serviceEditorState
+      .executionState.serviceExecutionParameters?.query;
+  }
+
+  get queryVariableExpressions(): VariableExpression[] {
+    return this.serviceQuery
+      ? buildLambdaVariableExpressions(
+          this.serviceQuery,
+          this.editorStore.graphManagerState,
+        ).filter(filterByType(VariableExpression))
+      : [];
+  }
+  get options(): SerializationFormatOption[] {
+    return Object.values(SERIALIZATION_FORMAT).map((e) => ({
+      value: e,
+      label: getSerializationFormatLabel(e),
+    }));
+  }
+
+  get newParamOptions(): { value: string; label: string }[] {
+    const queryVarExpressions = this.queryVariableExpressions;
+    const currentParams = this.testState.test.parameters;
+    return queryVarExpressions
+      .filter((v) => !currentParams.find((i) => i.name === v.name))
+      .map((e) => ({ value: e.name, label: e.name }));
+  }
+
+  syncWithQuery(): void {
+    // remove non existing params
+    this.parameterValueStates.forEach((paramState) => {
+      const expression = this.queryVariableExpressions.find(
+        (v) => v.name === paramState.parameterValue.name,
+      );
+      if (!expression) {
+        deleteEntry(this.parameterValueStates, paramState);
+        service_deleteParameterValue(
+          this.testState.test,
+          paramState.parameterValue,
+        );
+      }
+    });
+    // add new required params
+    this.queryVariableExpressions.forEach((v) => {
+      const multiplicity = v.multiplicity;
+      const isRequired = multiplicity.lowerBound > 0;
+      const paramState = this.parameterValueStates.find(
+        (p) => p.parameterValue.name === v.name,
+      );
+      if (!paramState && isRequired) {
+        this.addExpressionParameterValue(v);
+      }
+    });
+  }
+
+  setNewParameterValueName(val: string): void {
+    this.newParameterValueName = val;
+  }
+
+  setShowNewParameterModal(val: boolean): void {
+    this.showNewParameterModal = val;
+  }
+
+  openNewParamModal(): void {
+    this.setShowNewParameterModal(true);
+    const option = this.newParamOptions[0];
+    if (option) {
+      this.newParameterValueName = option.value;
+    }
+  }
+
+  addParameterValue(): void {
+    try {
+      const expressions = this.queryVariableExpressions;
+      const expression = guaranteeNonNullable(
+        expressions.find((v) => v.name === this.newParameterValueName),
+      );
+      this.addExpressionParameterValue(expression);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notifyError(error);
+    } finally {
+      this.setShowNewParameterModal(false);
+    }
+  }
+
+  addExpressionParameterValue(expression: VariableExpression): void {
+    try {
+      const mockValue = guaranteeNonNullable(
+        generateVariableExpressionMockValue(expression),
+      );
+      const paramValue = new ParameterValue();
+      paramValue.name = expression.name;
+      paramValue.value =
+        this.editorStore.graphManagerState.graphManager.serializeValueSpecification(
+          mockValue,
+        );
+      service_addParameterValue(this.testState.test, paramValue);
+      const paramValueState = new ServiceValueSpecificationTestParameterState(
+        paramValue,
+        this.editorStore,
+        this,
+        observe_ValueSpecification(
+          mockValue,
+          this.editorStore.changeDetectionState.observerContext,
+        ),
+        expression,
+      );
+      this.parameterValueStates.push(paramValueState);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notifyError(error);
+    }
+  }
+
+  removeParamValueState(paramState: ServiceTestParameterState): void {
+    deleteEntry(this.parameterValueStates, paramState);
+    service_deleteParameterValue(
+      this.testState.test,
+      paramState.parameterValue,
+    );
+  }
+
+  buildParameterStates(): ServiceTestParameterState[] {
+    const varExpressions = this.queryVariableExpressions;
+    const paramValues = this.testState.test.parameters;
+    return paramValues.map((pValue) => {
+      const spec = returnUndefOnError(() =>
+        this.editorStore.graphManagerState.graphManager.buildValueSpecification(
+          pValue.value as Record<PropertyKey, unknown>,
+          this.editorStore.graphManagerState.graph,
+        ),
+      );
+      const expression = varExpressions.find((e) => e.name === pValue.name);
+      return spec && expression
+        ? new ServiceValueSpecificationTestParameterState(
+            pValue,
+            this.editorStore,
+            this,
+            observe_ValueSpecification(
+              spec,
+              this.editorStore.changeDetectionState.observerContext,
+            ),
+            expression,
+          )
+        : new ServiceTestParameterState(pValue, this.editorStore, this);
+    });
+  }
+
+  getSelectedFormatOption(): SerializationFormatOption | undefined {
+    const test = this.testState.test;
+    if (test.serializationFormat) {
+      return {
+        value: test.serializationFormat,
+        label: getSerializationFormatLabel(test.serializationFormat),
+      };
+    }
+    return undefined;
+  }
+
+  changeSerializationFormat(val: string | undefined): void {
+    service_setSerializationFormat(this.testState.test, val);
+  }
+
+  generateTestParameterValues(): void {
+    try {
+      const varExpressions = this.queryVariableExpressions;
+      const parameterValueStates = varExpressions
+        .map((varExpression) => {
+          const mockValue = generateVariableExpressionMockValue(varExpression);
+          if (mockValue) {
+            const paramValue = new ParameterValue();
+            paramValue.name = varExpression.name;
+            paramValue.value =
+              this.editorStore.graphManagerState.graphManager.serializeValueSpecification(
+                mockValue,
+              );
+            return new ServiceValueSpecificationTestParameterState(
+              paramValue,
+              this.editorStore,
+              this,
+              mockValue,
+              varExpression,
+            );
+          }
+          return undefined;
+        })
+        .filter(isNonNullable);
+      service_setParameterValues(
+        this.testState.test,
+        parameterValueStates.map((s) => s.parameterValue),
+      );
+      this.parameterValueStates = parameterValueStates;
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notifyError(
+        `Unable to generate param values: ${error.message}`,
+      );
+    }
+  }
+}
+
+export class ServiceTestState extends TestableTestEditorState {
+  readonly suiteState: ServiceTestSuiteState;
+  override test: ServiceTest;
+  override testable: Service;
+  setupState: ServiceTestSetupState;
+  constructor(suiteState: ServiceTestSuiteState, test: ServiceTest) {
+    super(
+      suiteState.testableState.serviceEditorState.service,
+      test,
+      suiteState.testableState.serviceEditorState.isReadOnly,
+      suiteState.editorStore,
+    );
+    makeObservable(this, {
+      selectedAsertionState: observable,
+      selectedTab: observable,
+      assertionToRename: observable,
+      assertionEditorStates: observable,
+      testResultState: observable,
+      runningTestAction: observable,
+      setupState: observable,
+      addAssertion: action,
+      setAssertionToRename: action,
+      handleTestResult: action,
+      setSelectedTab: action,
+      runTest: flow,
+    });
+    this.test = test;
+    this.suiteState = suiteState;
+    this.testable = suiteState.testableState.serviceEditorState.service;
+    this.setupState = new ServiceTestSetupState(this);
+  }
+}

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

@@ -0,0 +1,293 @@
+/**
+ * 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 {
+  type TestResult,
+  type Service,
+  TestPassed,
+  TestFailed,
+  ServiceTestSuite,
+  TestData,
+  ServiceTest,
+  RunTestsTestableInput,
+  AtomicTestId,
+  DEFAULT_TEST_SUITE_PREFIX,
+  DEFAULT_TEST_PREFIX,
+  TestError,
+  MultiExecutionServiceTestResult,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  addUniqueEntry,
+  assertErrorThrown,
+  filterByType,
+  ActionState,
+  deleteEntry,
+  isNonNullable,
+  generateEnumerableNameFromToken,
+  getNullableFirstElement,
+} from '@finos/legend-shared';
+import { action, flow, makeObservable, observable } from 'mobx';
+import type { EditorStore } from '../../../../EditorStore.js';
+import {
+  service_addTest,
+  service_addTestSuite,
+  service_deleteTestSuite,
+} from '../../../../graphModifier/DSLService_GraphModifierHelper.js';
+import { createEmptyEqualToJsonAssertion } from '../../../../shared/testable/TestableUtils.js';
+import type { ServiceEditorState } from '../ServiceEditorState.js';
+import { ServiceTestDataState } from './ServiceTestDataState.js';
+import {
+  SERIALIZATION_FORMAT,
+  ServiceTestState,
+} from './ServiceTestEditorState.js';
+
+const createEmptyServiceTestSuite = (service: Service): ServiceTestSuite => {
+  const suite = new ServiceTestSuite();
+  suite.id = generateEnumerableNameFromToken(
+    service.tests.map((s) => s.id),
+    DEFAULT_TEST_SUITE_PREFIX,
+  );
+  suite.testData = new TestData();
+  const test = new ServiceTest();
+  test.serializationFormat = SERIALIZATION_FORMAT.PURE;
+  test.id = generateEnumerableNameFromToken([], DEFAULT_TEST_PREFIX);
+  test.__parent = suite;
+  suite.tests = [test];
+  const assertion = createEmptyEqualToJsonAssertion(test);
+  test.assertions = [assertion];
+  return suite;
+};
+
+export class ServiceTestSuiteState {
+  readonly editorStore: EditorStore;
+  readonly testableState: ServiceTestableState;
+  suite: ServiceTestSuite;
+  testDataState: ServiceTestDataState;
+  selectedTestState: ServiceTestState | undefined;
+  testStates: ServiceTestState[] = [];
+  testToRename: ServiceTest | undefined;
+  isRunningTest = ActionState.create();
+
+  constructor(suite: ServiceTestSuite, testableState: ServiceTestableState) {
+    makeObservable(this, {
+      editorStore: false,
+      testableState: false,
+      testToRename: observable,
+      selectedTestState: observable,
+      setSelectedTestState: action,
+      setTestToRename: action,
+      addServiceTest: action,
+      runSuite: flow,
+      runFailingTests: flow,
+    });
+
+    this.editorStore = testableState.editorStore;
+    this.testableState = testableState;
+    this.suite = suite;
+    this.testStates = this.suite.tests
+      .filter(filterByType(ServiceTest))
+      .map((test) => new ServiceTestState(this, test));
+    this.selectedTestState = this.testStates[0];
+    this.testDataState = new ServiceTestDataState(this.suite.testData, this);
+  }
+
+  setTestToRename(test: ServiceTest | undefined): void {
+    this.testToRename = test;
+  }
+
+  setSelectedTestState(val: ServiceTestState | undefined): void {
+    this.selectedTestState = val;
+  }
+
+  addServiceTest(): void {
+    const test = new ServiceTest();
+    test.serializationFormat = SERIALIZATION_FORMAT.PURE;
+    test.id = generateEnumerableNameFromToken(
+      this.suite.tests.map((t) => t.id),
+      DEFAULT_TEST_PREFIX,
+    );
+    test.__parent = this.suite;
+    const state = new ServiceTestState(this, test);
+    state.addAssertion();
+    this.selectedTestState = state;
+    service_addTest(this.suite, test);
+    addUniqueEntry(this.testStates, state);
+  }
+
+  deleteTest(testState: ServiceTestState): void {
+    deleteEntry(this.suite.tests, testState.test);
+    deleteEntry(this.testStates, testState);
+    this.selectedTestState =
+      this.selectedTestState === testState
+        ? this.testStates[0]
+        : this.selectedTestState;
+  }
+
+  *runSuite(): GeneratorFn<void> {
+    try {
+      this.isRunningTest.inProgress();
+      this.testStates.forEach((t) => t.resetResult());
+      this.testStates.forEach((t) => t.runningTestAction.inProgress());
+      const service = this.testableState.serviceEditorState.service;
+      const input = new RunTestsTestableInput(service);
+      input.unitTestIds = this.suite.tests.map(
+        (t) => new AtomicTestId(this.suite, t),
+      );
+      const testResults =
+        (yield this.editorStore.graphManagerState.graphManager.runTests(
+          [input],
+          this.editorStore.graphManagerState.graph,
+        )) as TestResult[];
+      testResults.forEach((result) => {
+        const state = this.testStates.find(
+          (t) => t.test === result.atomicTestId.atomicTest,
+        );
+        state?.handleTestResult(result);
+      });
+      this.isRunningTest.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notifyError(error);
+      this.isRunningTest.fail();
+    } finally {
+      this.testStates.forEach((t) => t.runningTestAction.complete());
+    }
+  }
+
+  *runFailingTests(): GeneratorFn<void> {
+    try {
+      this.isRunningTest.inProgress();
+      const service = this.testableState.serviceEditorState.service;
+      const input = new RunTestsTestableInput(service);
+      input.unitTestIds = this.testStates
+        .map((testState) => {
+          const result = testState.testResultState.result;
+          if (result instanceof TestFailed || result instanceof TestError) {
+            testState.runningTestAction.inProgress();
+            return new AtomicTestId(this.suite, testState.test);
+          }
+          return undefined;
+        })
+        .filter(isNonNullable);
+      const testResults =
+        (yield this.editorStore.graphManagerState.graphManager.runTests(
+          [input],
+          this.editorStore.graphManagerState.graph,
+        )) as TestResult[];
+      testResults.forEach((result) => {
+        const state = this.testStates.find(
+          (t) => t.test === result.atomicTestId.atomicTest,
+        );
+        state?.handleTestResult(result);
+      });
+      this.isRunningTest.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notifyError(error);
+      this.isRunningTest.fail();
+    } finally {
+      this.testStates.forEach((t) => t.runningTestAction.complete());
+    }
+  }
+
+  get testCount(): number {
+    return this.testStates.length;
+  }
+
+  get testPassed(): number {
+    return this.testStates.filter(
+      (e) =>
+        e.testResultState.result instanceof TestPassed ||
+        (e.testResultState.result instanceof MultiExecutionServiceTestResult &&
+          Array.from(
+            e.testResultState.result.keyIndexedTestResults.values(),
+          ).every((kv) => kv instanceof TestPassed)),
+    ).length;
+  }
+
+  get testFailed(): number {
+    return this.testCount - this.testPassed;
+  }
+}
+
+export class ServiceTestableState {
+  readonly editorStore: EditorStore;
+  readonly serviceEditorState: ServiceEditorState;
+  selectedSuiteState: ServiceTestSuiteState | undefined;
+  suiteToRename: ServiceTestSuite | undefined;
+
+  constructor(
+    editorStore: EditorStore,
+    serviceEditorState: ServiceEditorState,
+  ) {
+    makeObservable(this, {
+      editorStore: false,
+      serviceEditorState: false,
+      selectedSuiteState: observable,
+      suiteToRename: observable,
+      initSuites: action,
+      addTestSuite: action,
+      changeSuite: action,
+      setSuiteToRename: action,
+      deleteSuite: action,
+    });
+    this.editorStore = editorStore;
+    this.serviceEditorState = serviceEditorState;
+    this.initSuites();
+  }
+
+  setSuiteToRename(testSuite: ServiceTestSuite | undefined): void {
+    this.suiteToRename = testSuite;
+  }
+
+  deleteSuite(testSuite: ServiceTestSuite): void {
+    service_deleteTestSuite(this.serviceEditorState.service, testSuite);
+    if (this.selectedSuiteState?.suite === testSuite) {
+      this.selectedSuiteState = this.serviceEditorState.service.tests.length
+        ? new ServiceTestSuiteState(
+            this.serviceEditorState.service.tests[0] as ServiceTestSuite,
+            this,
+          )
+        : undefined;
+    }
+  }
+
+  changeSuite(suite: ServiceTestSuite): void {
+    this.selectedSuiteState = new ServiceTestSuiteState(suite, this);
+  }
+
+  initSuites(): void {
+    const serviceSuite = getNullableFirstElement(
+      this.serviceEditorState.service.tests,
+    );
+    if (serviceSuite instanceof ServiceTestSuite) {
+      this.selectedSuiteState = new ServiceTestSuiteState(serviceSuite, this);
+    } else {
+      this.selectedSuiteState = undefined;
+    }
+  }
+
+  addTestSuite(): void {
+    const suite = createEmptyServiceTestSuite(this.serviceEditorState.service);
+    service_addTestSuite(
+      this.serviceEditorState.service,
+      suite,
+      this.serviceEditorState.editorStore.changeDetectionState.observerContext,
+    );
+    this.selectedSuiteState = new ServiceTestSuiteState(suite, this);
+  }
+}