@finos/legend-application-studio 22.6.0 → 23.0.1

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

@@ -0,0 +1,213 @@
+/**
+ * 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 AtomicTest,
+  type Testable,
+  type TestAssertion,
+  type TestResult,
+  TestExecuted,
+  UniqueTestId,
+  RunTestsTestableInput,
+  TestSuite,
+  TestExecutionStatus,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  assertTrue,
+  guaranteeNonNullable,
+  ActionState,
+  addUniqueEntry,
+  deleteEntry,
+} from '@finos/legend-shared';
+import { action, makeObservable, observable } from 'mobx';
+import type { EditorStore } from '../../../EditorStore.js';
+import { atomicTest_addAssertion } from '../../../shared/modifier/Testable_GraphModifierHelper.js';
+import { createEmptyEqualToJsonAssertion } from '../../../shared/TestableUtils.js';
+import { TESTABLE_RESULT } from '../../../sidebar-state/testable/GlobalTestRunnerState.js';
+import {
+  TestAssertionEditorState,
+  TEST_ASSERTION_TAB,
+} from './TestAssertionState.js';
+
+export class TestableTestResultState {
+  readonly editorStore: EditorStore;
+  readonly testState: TestableTestEditorState;
+  result: TestResult | undefined;
+
+  constructor(testState: TestableTestEditorState, editorStore: EditorStore) {
+    makeObservable(this, {
+      result: observable,
+      setResult: action,
+    });
+
+    this.editorStore = editorStore;
+    this.testState = testState;
+  }
+
+  setResult(val: TestResult | undefined): void {
+    this.result = val;
+  }
+}
+
+export enum TESTABLE_TEST_TAB {
+  SETUP = 'SETUP',
+  ASSERTIONS = 'ASSERTIONS',
+}
+
+export class TestableTestEditorState {
+  readonly editorStore: EditorStore;
+  testable: Testable;
+  test: AtomicTest;
+  selectedAsertionState: TestAssertionEditorState | undefined;
+  assertionEditorStates: TestAssertionEditorState[] = [];
+  selectedTab = TESTABLE_TEST_TAB.ASSERTIONS;
+  assertionToRename: TestAssertion | undefined;
+  runningTestAction = ActionState.create();
+  testResultState: TestableTestResultState;
+  isReadOnly: boolean;
+
+  constructor(
+    testable: Testable,
+    test: AtomicTest,
+    isReadOnly: boolean,
+    editorStore: EditorStore,
+  ) {
+    this.editorStore = editorStore;
+    this.test = test;
+    this.testable = testable;
+    this.testResultState = new TestableTestResultState(this, this.editorStore);
+    this.assertionEditorStates = test.assertions.map(
+      (assertion) =>
+        new TestAssertionEditorState(this.editorStore, assertion, this),
+    );
+    this.selectedAsertionState = this.assertionEditorStates[0];
+    this.isReadOnly = isReadOnly;
+  }
+
+  setSelectedTab(val: TESTABLE_TEST_TAB): void {
+    this.selectedTab = val;
+  }
+
+  setAssertionToRename(assertion: TestAssertion | undefined): void {
+    this.assertionToRename = assertion;
+  }
+
+  addAssertion(): void {
+    const assertion = createEmptyEqualToJsonAssertion(this.test);
+    atomicTest_addAssertion(this.test, assertion);
+    const assertionState = new TestAssertionEditorState(
+      this.editorStore,
+      assertion,
+      this,
+    );
+    addUniqueEntry(this.assertionEditorStates, assertionState);
+    this.selectedAsertionState = assertionState;
+    this.resetResult();
+  }
+
+  deleteAssertion(assertionState: TestAssertionEditorState): void {
+    deleteEntry(this.test.assertions, assertionState.assertion);
+    deleteEntry(this.assertionEditorStates, assertionState);
+    if (this.selectedAsertionState === assertionState) {
+      this.selectedAsertionState = this.assertionEditorStates[0];
+    }
+  }
+
+  openAssertion(val: TestAssertion): void {
+    const state = this.assertionEditorStates.find((a) => a.assertion === val);
+    if (state) {
+      this.selectedAsertionState = state;
+    }
+  }
+
+  *runTest(): GeneratorFn<void> {
+    try {
+      this.resetResult();
+      this.runningTestAction.inProgress();
+      const input = new RunTestsTestableInput(this.testable);
+      const suite =
+        this.test.__parent instanceof TestSuite
+          ? this.test.__parent
+          : undefined;
+      input.unitTestIds.push(new UniqueTestId(suite, this.test));
+      const testResults =
+        (yield this.editorStore.graphManagerState.graphManager.runTests(
+          [input],
+          this.editorStore.graphManagerState.graph,
+        )) as TestResult[];
+      const result = guaranteeNonNullable(testResults[0]);
+      assertTrue(
+        result.testable === this.testable && result.atomicTest === this.test,
+        'Unexpected test result',
+      );
+      this.handleTestResult(result);
+      this.runningTestAction.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Error running test: ${error.message}`,
+      );
+      this.runningTestAction.fail();
+    }
+  }
+
+  resetResult(): void {
+    this.testResultState.setResult(undefined);
+    this.assertionEditorStates.forEach((assertionState) =>
+      assertionState.assertionResultState.setTestResult(undefined),
+    );
+  }
+
+  handleTestResult(testResult: TestResult): void {
+    this.testResultState.setResult(testResult);
+    this.assertionEditorStates.forEach((assertionState) => {
+      assertionState.assertionResultState.setTestResult(testResult);
+      assertionState.setSelectedTab(TEST_ASSERTION_TAB.ASSERTION_RESULT);
+    });
+  }
+
+  get assertionCount(): number {
+    return this.assertionEditorStates.length;
+  }
+
+  get assertionPassed(): number {
+    if (
+      this.testResultState.result instanceof TestExecuted &&
+      this.testResultState.result.testExecutionStatus ===
+        TestExecutionStatus.PASS
+    ) {
+      return this.assertionCount;
+    }
+    return this.assertionEditorStates.filter(
+      (state) => state.assertionResultState.result === TESTABLE_RESULT.PASSED,
+    ).length;
+  }
+
+  get assertionFailed(): number {
+    if (
+      this.testResultState.result instanceof TestExecuted &&
+      this.testResultState.result.testExecutionStatus ===
+        TestExecutionStatus.PASS
+    ) {
+      return 0;
+    }
+    return this.assertionEditorStates.filter(
+      (state) => state.assertionResultState.result !== TESTABLE_RESULT.PASSED,
+    ).length;
+  }
+}

package/src/stores/editor/editor-state/entity-diff-editor-state/EntityDiffViewState.ts

@@ -0,0 +1,244 @@
+/**
+ * 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 { observable, action, flow, computed, makeObservable } from 'mobx';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  LogEvent,
+  assertNonNullable,
+  guaranteeNonNullable,
+  hashObject,
+} from '@finos/legend-shared';
+import type { EditorStore } from '../../EditorStore.js';
+import {
+  type SPECIAL_REVISION_ALIAS,
+  EntityDiffViewerState,
+} from './EntityDiffEditorState.js';
+import { type Entity, extractEntityNameFromPath } from '@finos/legend-storage';
+import { LEGEND_STUDIO_APP_EVENT } from '../../../../application/LegendStudioEvent.js';
+import type { PackageableElement } from '@finos/legend-graph';
+import type { EditorState } from '../EditorState.js';
+
+/**
+ * NOTE: when we support comparison between entities, we should create a new editor state
+ * as there are no benefits in trying to make this current one also work with comparison
+ * There are many differences, such as the concept of from and to revision makes no sense,
+ * the header text is different, etc.
+ */
+
+export enum DIFF_VIEW_MODE {
+  JSON = 'JSON',
+  GRAMMAR = 'Grammar',
+}
+
+export class EntityDiffViewState extends EntityDiffViewerState {
+  diffMode = DIFF_VIEW_MODE.GRAMMAR;
+  fromEntityPath?: string | undefined;
+  toEntityPath?: string | undefined;
+  fromRevision: SPECIAL_REVISION_ALIAS | string;
+  toRevision: SPECIAL_REVISION_ALIAS | string;
+  // to and from entities
+  fromEntity?: Entity | undefined;
+  toEntity?: Entity | undefined;
+  fromGrammarText?: string | undefined;
+  toGrammarText?: string | undefined;
+  // functions to get to and from entities
+  fromEntityGetter?:
+    | ((entityPath: string | undefined) => Entity | undefined)
+    | undefined;
+  toEntityGetter?:
+    | ((entityPath: string | undefined) => Entity | undefined)
+    | undefined;
+
+  constructor(
+    editorStore: EditorStore,
+    fromRevision: SPECIAL_REVISION_ALIAS | string,
+    toRevision: SPECIAL_REVISION_ALIAS | string,
+    fromEntityPath: string | undefined,
+    toEntityPath: string | undefined,
+    fromEntity: Entity | undefined,
+    toEntity: Entity | undefined,
+    fromEntityGetter?: (entityPath: string | undefined) => Entity | undefined,
+    toEntityGetter?: (entityPath: string | undefined) => Entity | undefined,
+  ) {
+    super(editorStore);
+
+    makeObservable<
+      EntityDiffViewState,
+      'setToGrammarText' | 'setFromGrammarText'
+    >(this, {
+      diffMode: observable,
+      fromEntityPath: observable,
+      toEntityPath: observable,
+      fromRevision: observable,
+      toRevision: observable,
+      fromEntity: observable.ref,
+      toEntity: observable.ref,
+      fromGrammarText: observable,
+      toGrammarText: observable,
+      fromEntityGetter: observable,
+      toEntityGetter: observable,
+      effectiveEntityPath: computed,
+      element: computed,
+      label: computed,
+      description: computed,
+      summaryText: computed,
+      setDiffMode: action,
+      setToGrammarText: action,
+      setFromGrammarText: action,
+      refresh: action,
+      getFromGrammar: flow,
+      getToGrammar: flow,
+    });
+
+    this.fromEntityPath = fromEntityPath;
+    this.toEntityPath = toEntityPath;
+    assertNonNullable(this.effectiveEntityPath);
+    this.fromEntity = fromEntity;
+    this.toEntity = toEntity;
+    this.fromRevision = fromRevision;
+    this.toRevision = toRevision;
+    this.fromEntityGetter = fromEntityGetter;
+    this.toEntityGetter = toEntityGetter;
+  }
+
+  /**
+   * The idea behind effective is that an entity diff state was constructed, one of `toEntityPath` and `fromEntityPath` can be undefined
+   * when the diff is a delete or create. But we can always guarantee that at least one exist and thus `effectiveEntityPath` is that guaranteed to exist path.
+   * It serves 2 main purposes:
+   * 1. For display
+   * 2. For refreshing diff: for example, when we push a workspace change, a delete is updated and if we continue to use the
+   *    `toEntityPath` the diff will be shown as a delete still, but we don't want this, we want both panels to have the same content
+   *
+   * As for which path to take precedence, it is more suitable to take `toEntityPath` because it reflects what currently presents in the project
+   * and what the UI should show all the time in the display
+   * e.g. it does not make sense to show the old path for a create element diff.
+   */
+  get effectiveEntityPath(): string {
+    return guaranteeNonNullable(
+      this.toEntityPath ?? this.fromEntityPath,
+      'Neither from nor to entity paths can be missing',
+    );
+  }
+
+  get element(): PackageableElement | undefined {
+    return this.editorStore.graphManagerState.graph.getNullableElement(
+      this.effectiveEntityPath,
+    );
+  }
+
+  get label(): string {
+    return extractEntityNameFromPath(this.effectiveEntityPath);
+  }
+
+  override get description(): string {
+    return this.effectiveEntityPath;
+  }
+
+  get summaryText(): string {
+    // NOTE: we don't support rename at the moment
+    if (!this.fromEntity && !this.toEntity) {
+      return 'Nothing to compare. Neither entity contents is available';
+    } else if (!this.fromEntity) {
+      return `Entity '${this.toEntityPath}' is created`;
+    } else if (!this.toEntity) {
+      return `Entity '${this.fromEntityPath}' is deleted`;
+    } else if (
+      hashObject(this.fromEntity.content) === hashObject(this.toEntity.content)
+    ) {
+      return 'Entity contents are identical';
+    }
+    return `Entity '${this.toEntityPath}' is modified`;
+  }
+
+  setDiffMode(diffMode: DIFF_VIEW_MODE): void {
+    this.diffMode = diffMode;
+  }
+
+  private setToGrammarText(text: string): void {
+    this.toGrammarText = text;
+  }
+
+  private setFromGrammarText(text: string): void {
+    this.fromGrammarText = text;
+  }
+
+  override match(tab: EditorState): boolean {
+    return (
+      tab instanceof EntityDiffViewState &&
+      tab.fromEntityPath === this.fromEntityPath &&
+      tab.toEntityPath === this.toEntityPath &&
+      tab.fromRevision === this.fromRevision &&
+      tab.toRevision === this.toRevision
+    );
+  }
+
+  refresh(): void {
+    this.fromEntity = this.fromEntityGetter
+      ? this.fromEntityGetter(this.effectiveEntityPath)
+      : this.fromEntity;
+    this.toEntity = this.toEntityGetter
+      ? this.toEntityGetter(this.effectiveEntityPath)
+      : this.toEntity;
+  }
+
+  *getFromGrammar(): GeneratorFn<void> {
+    if (this.fromEntity) {
+      try {
+        const elementGrammar =
+          (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
+            [this.fromEntity],
+          )) as string;
+        this.setFromGrammarText(elementGrammar);
+      } catch (error) {
+        assertErrorThrown(error);
+        this.setFromGrammarText(
+          '/* Failed to transform grammar text, see JSON diff instead */',
+        );
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.setFromGrammarText('');
+    }
+  }
+
+  *getToGrammar(): GeneratorFn<void> {
+    if (this.toEntity) {
+      try {
+        const elementGrammar =
+          (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
+            [this.toEntity],
+          )) as string;
+        this.setToGrammarText(elementGrammar);
+      } catch (error) {
+        assertErrorThrown(error);
+        this.setFromGrammarText(
+          '/* Failed to transform grammar text, see JSON diff instead */',
+        );
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.setToGrammarText('');
+    }
+  }
+}