@finos/legend-application-studio 22.6.0 → 23.0.1

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

@@ -0,0 +1,398 @@
+/**
+ * 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 TestData,
+  type Connection,
+  type IdentifiedConnection,
+  type Runtime,
+  type EmbeddedData,
+  type RawLambda,
+  type DataElement,
+  ConnectionTestData,
+  PureSingleExecution,
+  PureMultiExecution,
+  DatabaseConnection,
+  buildLambdaVariableExpressions,
+  VariableExpression,
+  PrimitiveType,
+  Enumeration,
+  DataElementReference,
+  PackageableElementExplicitReference,
+  ConnectionPointer,
+  reportGraphAnalytics,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  ActionState,
+  assertErrorThrown,
+  deleteEntry,
+  filterByType,
+  guaranteeNonNullable,
+  isNonNullable,
+  returnUndefOnError,
+  getNullableFirstElement,
+  uniq,
+} from '@finos/legend-shared';
+import { action, flow, makeObservable, observable } from 'mobx';
+import type { EditorStore } from '../../../../EditorStore.js';
+import {
+  service_addConnectionTestData,
+  service_setConnectionTestDataEmbeddedData,
+} from '../../../../shared/modifier/DSL_Service_GraphModifierHelper.js';
+import {
+  createMockEnumerationProperty,
+  createMockPrimitiveProperty,
+} from '../../../../shared/MockDataUtils.js';
+import {
+  TEMPORARY__createRelationalDataFromCSV,
+  EmbeddedDataConnectionTypeVisitor,
+  getAllIdentifiedConnectionsFromRuntime,
+  TEMPORARY__EmbeddedDataConnectionVisitor,
+} from '../../../../shared/TestableUtils.js';
+import { EmbeddedDataType } from '../../../ExternalFormatState.js';
+import {
+  type EmbeddedDataTypeOption,
+  EmbeddedDataEditorState,
+} from '../../data/DataEditorState.js';
+import { createEmbeddedData } from '../../data/EmbeddedDataState.js';
+import type { ServiceTestSuiteState } from './ServiceTestableState.js';
+import { LegendStudioTelemetryHelper } from '../../../../../../application/LegendStudioTelemetryHelper.js';
+
+const buildTestDataParameters = (
+  rawLambda: RawLambda,
+  editorStore: EditorStore,
+): (string | number | boolean)[] =>
+  buildLambdaVariableExpressions(rawLambda, editorStore.graphManagerState)
+    .filter(filterByType(VariableExpression))
+    .map((varExpression) => {
+      if (varExpression.multiplicity.lowerBound !== 0) {
+        const type = varExpression.genericType?.value.rawType;
+        if (type instanceof PrimitiveType) {
+          return createMockPrimitiveProperty(type, varExpression.name);
+        } else if (type instanceof Enumeration) {
+          return createMockEnumerationProperty(type);
+        }
+      }
+      return undefined;
+    })
+    .filter(isNonNullable);
+
+export class ConnectionTestDataState {
+  readonly editorStore: EditorStore;
+  readonly testDataState: ServiceTestDataState;
+  connectionData: ConnectionTestData;
+  embeddedEditorState: EmbeddedDataEditorState;
+  generatingTestDataSate = ActionState.create();
+  anonymizeGeneratedData = true;
+
+  constructor(
+    testDataState: ServiceTestDataState,
+    connectionData: ConnectionTestData,
+  ) {
+    makeObservable(this, {
+      generatingTestDataSate: observable,
+      embeddedEditorState: observable,
+      anonymizeGeneratedData: observable,
+      setAnonymizeGeneratedData: action,
+      generateTestData: flow,
+    });
+    this.testDataState = testDataState;
+    this.editorStore = testDataState.editorStore;
+    this.connectionData = connectionData;
+    this.embeddedEditorState = new EmbeddedDataEditorState(
+      this.testDataState.editorStore,
+      connectionData.testData,
+    );
+  }
+  get identifiedConnection(): IdentifiedConnection | undefined {
+    return this.getAllIdentifiedConnections().find(
+      (c) => c.id === this.connectionData.connectionId,
+    );
+  }
+
+  setAnonymizeGeneratedData(val: boolean): void {
+    this.anonymizeGeneratedData = val;
+  }
+
+  *generateTestData(): GeneratorFn<void> {
+    try {
+      this.generatingTestDataSate.inProgress();
+      const connection = guaranteeNonNullable(
+        this.resolveConnectionValue(this.connectionData.connectionId),
+        `Unable to resolve connection ID '${this.connectionData.connectionId}`,
+      );
+
+      let embeddedData: EmbeddedData;
+      if (connection instanceof DatabaseConnection) {
+        const serviceExecutionParameters = guaranteeNonNullable(
+          this.testDataState.testSuiteState.testableState.serviceEditorState
+            .executionState.serviceExecutionParameters,
+        );
+
+        // NOTE: since we don't have a generic mechanism for test-data generation
+        // we will only report metrics around API usage, when we genericize, we will
+        // move this out
+        LegendStudioTelemetryHelper.logEvent_TestDataGenerationLaunched(
+          this.testDataState.editorStore.applicationStore.telemetryService,
+        );
+        const report = reportGraphAnalytics(
+          this.editorStore.graphManagerState.graph,
+        );
+
+        const value =
+          (yield this.editorStore.graphManagerState.graphManager.generateExecuteTestData(
+            serviceExecutionParameters.query,
+            buildTestDataParameters(
+              serviceExecutionParameters.query,
+              this.editorStore,
+            ),
+            serviceExecutionParameters.mapping,
+            serviceExecutionParameters.runtime,
+            this.editorStore.graphManagerState.graph,
+            {
+              anonymizeGeneratedData: this.anonymizeGeneratedData,
+            },
+            report,
+          )) as string;
+
+        // NOTE: since we don't have a generic mechanism for test-data generation
+        // we will only report metrics around API usage, when we genericize, we will
+        // move this out
+        LegendStudioTelemetryHelper.logEvent_TestDataGenerationSucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          report,
+        );
+
+        embeddedData = TEMPORARY__createRelationalDataFromCSV(value);
+      } else {
+        embeddedData = connection.accept_ConnectionVisitor(
+          new TEMPORARY__EmbeddedDataConnectionVisitor(this.editorStore),
+        );
+      }
+      service_setConnectionTestDataEmbeddedData(
+        this.connectionData,
+        embeddedData,
+        this.editorStore.changeDetectionState.observerContext,
+      );
+      this.embeddedEditorState = new EmbeddedDataEditorState(
+        this.testDataState.editorStore,
+        this.connectionData.testData,
+      );
+      this.generatingTestDataSate.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Unable to generate test data: ${error.message}`,
+      );
+      this.generatingTestDataSate.fail();
+    }
+  }
+
+  resolveConnectionValue(id: string): Connection | undefined {
+    const connection = this.getAllIdentifiedConnections().find(
+      (c) => c.id === id,
+    )?.connection;
+    if (connection instanceof ConnectionPointer) {
+      return connection.packageableConnection.value.connectionValue;
+    }
+    return connection;
+  }
+
+  getAllIdentifiedConnections(): IdentifiedConnection[] {
+    const service =
+      this.testDataState.testSuiteState.testableState.serviceEditorState
+        .service;
+    const execution = service.execution;
+    let runtimes: Runtime[] = [];
+    if (execution instanceof PureSingleExecution && execution.runtime) {
+      runtimes = [execution.runtime];
+    } else if (execution instanceof PureMultiExecution) {
+      runtimes = execution.executionParameters.map((t) => t.runtime);
+    }
+    return runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime);
+  }
+}
+
+export class NewConnectionDataState {
+  readonly editorStore: EditorStore;
+  readonly testSuiteState: ServiceTestDataState;
+  showModal = false;
+  connection: IdentifiedConnection | undefined;
+  embeddedDataType: EmbeddedDataTypeOption | undefined;
+  dataElement: DataElement | undefined;
+
+  constructor(
+    editorStore: EditorStore,
+    serviceTestDataState: ServiceTestDataState,
+  ) {
+    makeObservable(this, {
+      showModal: observable,
+      connection: observable,
+      embeddedDataType: observable,
+      dataElement: observable,
+      setModal: action,
+      openModal: action,
+      setEmbeddedDataType: action,
+      handleConnectionChange: action,
+      setDataElement: action,
+    });
+
+    this.editorStore = editorStore;
+    this.testSuiteState = serviceTestDataState;
+    this.dataElement = editorStore.graphManagerState.usableDataElements[0];
+  }
+
+  setModal(val: boolean): void {
+    this.showModal = val;
+  }
+
+  setDataElement(val: DataElement | undefined): void {
+    this.dataElement = val;
+  }
+
+  setEmbeddedDataType(val: EmbeddedDataTypeOption | undefined): void {
+    this.embeddedDataType = val;
+  }
+
+  openModal(): void {
+    this.setModal(true);
+    this.connection = this.testSuiteState.allIdentifiedConnections[0];
+    if (this.connection) {
+      this.handleConnectionChange(this.connection);
+    }
+  }
+
+  setConnection(val: IdentifiedConnection | undefined): void {
+    this.connection = val;
+  }
+
+  handleConnectionChange(val: IdentifiedConnection): void {
+    const connectionValue = val.connection;
+    const type = returnUndefOnError(() =>
+      connectionValue.accept_ConnectionVisitor(
+        new EmbeddedDataConnectionTypeVisitor(this.testSuiteState.editorStore),
+      ),
+    );
+    this.setEmbeddedDataType(type ? { label: type, value: type } : undefined);
+  }
+
+  createConnectionTestData(): ConnectionTestData {
+    const val = guaranteeNonNullable(this.connection);
+    const embeddedDataType = guaranteeNonNullable(this.embeddedDataType);
+    const connectionTestData = new ConnectionTestData();
+    connectionTestData.connectionId = val.id;
+    let testData: EmbeddedData;
+    if (
+      this.embeddedDataType?.value === EmbeddedDataType.DATA_ELEMENT &&
+      this.dataElement
+    ) {
+      const value = new DataElementReference();
+      value.dataElement = PackageableElementExplicitReference.create(
+        this.dataElement,
+      );
+      testData = value;
+    } else {
+      testData = createEmbeddedData(
+        embeddedDataType.value,
+        this.testSuiteState.editorStore,
+      );
+    }
+    connectionTestData.testData = testData;
+    return connectionTestData;
+  }
+}
+
+export class ServiceTestDataState {
+  readonly editorStore: EditorStore;
+  readonly testSuiteState: ServiceTestSuiteState;
+  testData: TestData;
+  selectedDataState: ConnectionTestDataState | undefined;
+  newConnectionDataState: NewConnectionDataState;
+
+  constructor(testData: TestData, testSuiteState: ServiceTestSuiteState) {
+    makeObservable(this, {
+      setSelectedDataState: action,
+      openConnectionTestData: action,
+      createConnectionTestData: action,
+      newConnectionDataState: observable,
+      selectedDataState: observable,
+    });
+
+    this.testData = testData;
+    this.testSuiteState = testSuiteState;
+    this.editorStore = testSuiteState.editorStore;
+    const connectionData = getNullableFirstElement(
+      testData.connectionsTestData,
+    );
+    if (connectionData) {
+      this.selectedDataState = new ConnectionTestDataState(
+        this,
+        connectionData,
+      );
+    }
+    this.newConnectionDataState = new NewConnectionDataState(
+      this.editorStore,
+      this,
+    );
+  }
+
+  createConnectionTestData(): void {
+    const connectionTestData =
+      this.newConnectionDataState.createConnectionTestData();
+    service_addConnectionTestData(
+      this.testSuiteState.suite,
+      connectionTestData,
+      this.editorStore.changeDetectionState.observerContext,
+    );
+    this.selectedDataState = new ConnectionTestDataState(
+      this,
+      connectionTestData,
+    );
+  }
+
+  setSelectedDataState(val: ConnectionTestDataState | undefined): void {
+    this.selectedDataState = val;
+  }
+
+  deleteConnectionTestData(val: ConnectionTestData): void {
+    deleteEntry(this.testData.connectionsTestData, val);
+    if (this.selectedDataState?.connectionData === val) {
+      const data = getNullableFirstElement(this.testData.connectionsTestData);
+      this.selectedDataState = data
+        ? new ConnectionTestDataState(this, data)
+        : undefined;
+    }
+  }
+
+  openConnectionTestData(val: ConnectionTestData): void {
+    if (this.selectedDataState?.connectionData !== val) {
+      this.setSelectedDataState(new ConnectionTestDataState(this, val));
+    }
+  }
+  get allIdentifiedConnections(): IdentifiedConnection[] {
+    const service =
+      this.testSuiteState.testableState.serviceEditorState.service;
+    const execution = service.execution;
+    let runtimes: Runtime[] = [];
+    if (execution instanceof PureSingleExecution && execution.runtime) {
+      runtimes = [execution.runtime];
+    } else if (execution instanceof PureMultiExecution) {
+      runtimes = execution.executionParameters.map((t) => t.runtime);
+    }
+    return uniq(runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime));
+  }
+}

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

@@ -0,0 +1,314 @@
+/**
+ * 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,
+  TestExecuted,
+  ServiceTestSuite,
+  TestData,
+  ServiceTest,
+  RunTestsTestableInput,
+  UniqueTestId,
+  DEFAULT_TEST_SUITE_PREFIX,
+  DEFAULT_TEST_PREFIX,
+  TestError,
+  MultiExecutionServiceTestResult,
+  isStubbed_RawLambda,
+  TestExecutionStatus,
+} 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 '../../../../shared/modifier/DSL_Service_GraphModifierHelper.js';
+import { createEmptyEqualToJsonAssertion } from '../../../../shared/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 UniqueTestId(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.atomicTest);
+        state?.handleTestResult(result);
+      });
+      this.isRunningTest.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.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 TestExecuted &&
+              result.testExecutionStatus === TestExecutionStatus.FAIL) ||
+            result instanceof TestError
+          ) {
+            testState.runningTestAction.inProgress();
+            return new UniqueTestId(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.atomicTest);
+        state?.handleTestResult(result);
+      });
+      this.isRunningTest.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.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 TestExecuted &&
+          e.testResultState.result.testExecutionStatus ===
+            TestExecutionStatus.PASS) ||
+        (e.testResultState.result instanceof MultiExecutionServiceTestResult &&
+          Array.from(
+            e.testResultState.result.keyIndexedTestResults.values(),
+          ).every(
+            (kv) =>
+              kv instanceof TestExecuted &&
+              kv.testExecutionStatus === TestExecutionStatus.PASS,
+          )),
+    ).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,
+      init: action,
+      addTestSuite: action,
+      changeSuite: action,
+      setSuiteToRename: action,
+      deleteSuite: action,
+    });
+    this.editorStore = editorStore;
+    this.serviceEditorState = serviceEditorState;
+    this.initSuites();
+  }
+
+  init(): void {
+    const service = this.serviceEditorState.service;
+    const query = this.serviceEditorState.serviceQuery;
+    if (
+      query &&
+      !isStubbed_RawLambda(query) &&
+      !service.tests.length &&
+      !service.test
+    ) {
+      this.addTestSuite();
+    }
+  }
+
+  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);
+  }
+}