@finos/legend-graph 4.0.2 → 6.0.0

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_MappingTransformer.ts

@@ -25,7 +25,6 @@ import type { Mapping } from '../../../../../../metamodels/pure/packageableEleme
 import type {
   SetImplementationVisitor,
   SetImplementation,
-  TEMPORARY__UnresolvedSetImplementation,
 } from '../../../../../../metamodels/pure/packageableElements/mapping/SetImplementation';
 import type {
   PropertyMappingVisitor,
@@ -149,6 +148,7 @@ import type { SubstituteStore } from '../../../../../../metamodels/pure/packagea
 import { V1_BindingTransformer } from '../../../model/packageableElements/externalFormat/store/V1_BindingTransformer';
 import { V1_MergeOperationClassMapping } from '../../../model/packageableElements/mapping/V1_MergeOperationClassMapping';
 import { MergeOperationSetImplementation } from '../../../../../../metamodels/pure/packageableElements/mapping/MergeOperationSetImplementation';
+import type { TEMPORARY__UnresolvedSetImplementation } from '../../../../../../metamodels/pure/packageableElements/mapping/TEMPORARY__UnresolvedSetImplementation';
 
 export const V1_transformPropertyReference = (
   element: PropertyReference,
@@ -438,7 +438,15 @@ const transformPurePropertyMapping = (
       isTransformingLocalPropertyMapping: Boolean(element.localMappingProperty),
     },
   );
-  purePropertyMapping.source = ''; // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+  /**
+   * Omit this information during protocol transformation as it can be
+   * interpreted while building the graph; and will help grammar-roundtrip
+   * tests (involving engine) to pass. Ideally, this requires grammar parser
+   * and composer in engine to be more consistent.
+   *
+   * @discrepancy grammar-roundtrip
+   */
+  purePropertyMapping.source = '';
   purePropertyMapping.target = transformPropertyMappingTarget(
     element.targetSetImplementation,
   );
@@ -487,7 +495,15 @@ const transformRelationalPropertyMapping = (
   // NOTE: isTransformingSourceId is needed for the roundtrip of association relational property mapping
   propertyMapping.source = isTransformingSourceId
     ? transformPropertyMappingSource(element.sourceSetImplementation)
-    : undefined; // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+    : /**
+       * Omit this information during protocol transformation as it can be
+       * interpreted while building the graph; and will help grammar-roundtrip
+       * tests (involving engine) to pass. Ideally, this requires grammar parser
+       * and composer in engine to be more consistent.
+       *
+       * @discrepancy grammar-roundtrip
+       */
+      undefined;
   propertyMapping.target = transformPropertyMappingTarget(
     element.targetSetImplementation,
   );
@@ -516,7 +532,15 @@ const transformEmbeddedRelationalPropertyMapping = (
     isTransformingEmbeddedPropertyMapping:
       isTransformingEmbeddedPropertyMapping,
   });
-  embedded.source = undefined; // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+  /**
+   * Omit this information during protocol transformation as it can be
+   * interpreted while building the graph; and will help grammar-roundtrip
+   * tests (involving engine) to pass. Ideally, this requires grammar parser
+   * and composer in engine to be more consistent.
+   *
+   * @discrepancy grammar-roundtrip
+   */
+  embedded.source = undefined;
   embedded.target = transformPropertyMappingTarget(
     element.targetSetImplementation,
   );
@@ -534,7 +558,15 @@ const transformEmbeddedRelationalPropertyMapping = (
   if (root !== undefined) {
     classMapping.root = root;
   }
-  classMapping.class = undefined; // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+  /**
+   * Omit this information during protocol transformation as it can be
+   * interpreted while building the graph; and will help grammar-roundtrip
+   * tests (involving engine) to pass. Ideally, this requires grammar parser
+   * and composer in engine to be more consistent.
+   *
+   * @discrepancy grammar-roundtrip
+   */
+  classMapping.class = undefined;
   embedded.classMapping = classMapping;
   if (element.localMappingProperty) {
     embedded.localMappingProperty = transformLocalPropertyInfo(
@@ -553,7 +585,15 @@ const transformInlineEmbeddedRelationalPropertyMapping = (
     isTransformingEmbeddedPropertyMapping:
       isTransformingEmbeddedPropertyMapping,
   });
-  embedded.source = undefined; // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+  /**
+   * Omit this information during protocol transformation as it can be
+   * interpreted while building the graph; and will help grammar-roundtrip
+   * tests (involving engine) to pass. Ideally, this requires grammar parser
+   * and composer in engine to be more consistent.
+   *
+   * @discrepancy grammar-roundtrip
+   */
+  embedded.source = undefined;
   embedded.target = transformPropertyMappingTarget(
     element.targetSetImplementation,
   );
@@ -576,7 +616,15 @@ const transformOtherwiseEmbeddedRelationalPropertyMapping = (
     isTransformingEmbeddedPropertyMapping:
       isTransformingEmbeddedPropertyMapping,
   });
-  embedded.source = undefined; // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+  /**
+   * Omit this information during protocol transformation as it can be
+   * interpreted while building the graph; and will help grammar-roundtrip
+   * tests (involving engine) to pass. Ideally, this requires grammar parser
+   * and composer in engine to be more consistent.
+   *
+   * @discrepancy grammar-roundtrip
+   */
+  embedded.source = undefined;
   embedded.target = transformPropertyMappingTarget(
     element.targetSetImplementation,
   );
@@ -594,7 +642,15 @@ const transformOtherwiseEmbeddedRelationalPropertyMapping = (
   if (root !== undefined) {
     classMapping.root = root;
   }
-  classMapping.class = undefined; // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+  /**
+   * Omit this information during protocol transformation as it can be
+   * interpreted while building the graph; and will help grammar-roundtrip
+   * tests (involving engine) to pass. Ideally, this requires grammar parser
+   * and composer in engine to be more consistent.
+   *
+   * @discrepancy grammar-roundtrip
+   */
+  classMapping.class = undefined;
   embedded.classMapping = classMapping;
   embedded.otherwisePropertyMapping = transformProperyMapping(
     element.otherwisePropertyMapping,
@@ -924,7 +980,15 @@ const transformRelationalInstanceSetImpl = (
   if (root !== undefined) {
     classMapping.root = root;
   }
-  classMapping.class = undefined; // @MARKER: GRAMMAR ROUNDTRIP --- omit this information during protocol transformation as it can be interpreted while building the graph
+  /**
+   * Omit this information during protocol transformation as it can be
+   * interpreted while building the graph; and will help grammar-roundtrip
+   * tests (involving engine) to pass. Ideally, this requires grammar parser
+   * and composer in engine to be more consistent.
+   *
+   * @discrepancy grammar-roundtrip
+   */
+  classMapping.class = undefined;
   return classMapping;
 };
 
@@ -1135,7 +1199,13 @@ export class V1_SetImplementationTransformer
     );
   }
 
-  /* @MARKER: RELAXED GRAPH CHECK - See https://github.com/finos/legend-studio/issues/880 */
+  /**
+   * This test is skipped because we want to temporarily relax graph building algorithm
+   * to ease Pure -> Legend migration push.
+   * See https://github.com/finos/legend-studio/issues/880
+   *
+   * @discrepancy graph-building
+   */
   visit_TEMPORARY__UnresolvedSetImplementation(
     setImplementation: TEMPORARY__UnresolvedSetImplementation,
   ): V1_ClassMapping | undefined {

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_MilestoningTransformer.ts

@@ -25,7 +25,7 @@ import { V1_ProcessingMilestoning } from '../../../model/packageableElements/sto
 import { ProcessingMilestoning } from '../../../../../../metamodels/pure/packageableElements/store/relational/model/milestoning/ProcessingMilestoning';
 import type { StoreRelational_PureProtocolProcessorPlugin_Extension } from '../../../../StoreRelational_PureProtocolProcessorPlugin_Extension';
 import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext';
-import { V1_RawInstanceValue } from '../../../model/rawValueSpecification/V1_RawInstanceValue';
+import { V1_RawPrimitiveInstanceValue } from '../../../model/rawValueSpecification/V1_RawPrimitiveInstanceValue';
 import { V1_RawValueSpecificationTransformer } from './V1_RawValueSpecificationTransformer';
 
 const transformBusinessMilesoning = (
@@ -41,7 +41,7 @@ const transformBusinessMilesoning = (
       metamodel.infinityDate.accept_RawValueSpecificationVisitor(
         new V1_RawValueSpecificationTransformer(context),
       ),
-      V1_RawInstanceValue,
+      V1_RawPrimitiveInstanceValue,
     );
   }
   return protocol;
@@ -68,7 +68,7 @@ const transformProcessingMilestoning = (
       metamodel.infinityDate.accept_RawValueSpecificationVisitor(
         new V1_RawValueSpecificationTransformer(context),
       ),
-      V1_RawInstanceValue,
+      V1_RawPrimitiveInstanceValue,
     );
   }
   return protocol;

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_PackageableElementTransformer.ts

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-import { UnsupportedOperationError } from '@finos/legend-shared';
+import {
+  assertErrorThrown,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
 import type {
   PackageableElement,
   PackageableElementVisitor,
@@ -61,8 +64,10 @@ import type {
   PureProtocolProcessorPlugin,
 } from '../../../../PureProtocolProcessorPlugin';
 import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext';
+import type { DataElement } from '../../../../../../metamodels/pure/packageableElements/data/DataElement';
+import { V1_transformDataElement } from './V1_DataElementTransformer';
 
-export class V1_PackageableElementTransformer
+class V1_PackageableElementTransformer
   implements PackageableElementVisitor<V1_PackageableElement>
 {
   context: V1_GraphTransformerContext;
@@ -166,4 +171,25 @@ export class V1_PackageableElementTransformer
   ): V1_PackageableElement {
     return V1_transformGenerationSpecification(element);
   }
+
+  visit_DataElement(element: DataElement): V1_PackageableElement {
+    return V1_transformDataElement(element, this.context);
+  }
 }
+
+export const V1_transformPackageableElement = (
+  element: PackageableElement,
+  plugins: PureProtocolProcessorPlugin[],
+  context: V1_GraphTransformerContext,
+): V1_PackageableElement => {
+  try {
+    return element.accept_PackageableElementVisitor(
+      new V1_PackageableElementTransformer(plugins, context),
+    );
+  } catch (error) {
+    assertErrorThrown(error);
+    // TODO?: should we wrap this in GraphTransformerError?
+    error.message = `Can't transform element '${element.path}': ${error.message}`;
+    throw error;
+  }
+};

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_RawValueSpecificationTransformer.ts

@@ -27,8 +27,8 @@ import { SOURCE_INFORMATION_KEY } from '../../../../../../../MetaModelConst';
 import { recursiveOmit } from '@finos/legend-shared';
 import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext';
 import type { V1_RawValueSpecification } from '../../../model/rawValueSpecification/V1_RawValueSpecification';
-import { V1_RawInstanceValue } from '../../../model/rawValueSpecification/V1_RawInstanceValue';
-import type { RawInstanceValue } from '../../../../../../metamodels/pure/rawValueSpecification/RawInstanceValue';
+import { V1_RawPrimitiveInstanceValue } from '../../../model/rawValueSpecification/V1_RawPrimitiveInstanceValue';
+import type { RawPrimitiveInstanceValue } from '../../../../../../metamodels/pure/rawValueSpecification/RawPrimitiveInstanceValue';
 
 export class V1_RawValueSpecificationTransformer
   implements RawValueSpecificationVisitor<V1_RawValueSpecification>
@@ -78,18 +78,16 @@ export class V1_RawValueSpecificationTransformer
     return rawVariable;
   }
 
-  visit_RawInstanceValue(
-    rawValueSpecification: RawInstanceValue,
+  visit_RawPrimitiveInstanceValue(
+    rawValueSpecification: RawPrimitiveInstanceValue,
   ): V1_RawValueSpecification {
-    const rawInstanceValue = new V1_RawInstanceValue();
-    rawInstanceValue.type = V1_transformElementReference(
-      rawValueSpecification.type,
-    );
-    rawInstanceValue.multiplicity = V1_transformMultiplicity(
+    const protocol = new V1_RawPrimitiveInstanceValue();
+    protocol.type = V1_transformElementReference(rawValueSpecification.type);
+    protocol.multiplicity = V1_transformMultiplicity(
       rawValueSpecification.multiplicity,
     );
-    rawInstanceValue.values = rawValueSpecification.values;
-    return rawInstanceValue;
+    protocol.values = rawValueSpecification.values;
+    return protocol;
   }
 }
 

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_ServiceTransformer.ts

@@ -16,13 +16,7 @@
 
 import { UnsupportedOperationError } from '@finos/legend-shared';
 import type { Service } from '../../../../../../metamodels/pure/packageableElements/service/Service';
-import {
-  type KeyedSingleExecutionTest,
-  type ServiceTest,
-  type TestContainer,
-  MultiExecutionTest,
-  SingleExecutionTest,
-} from '../../../../../../metamodels/pure/packageableElements/service/ServiceTest';
+import type { ServiceTest } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTest';
 import {
   type KeyedExecutionParameter,
   type ServiceExecution,
@@ -40,13 +34,7 @@ import {
   V1_PureMultiExecution,
   V1_KeyedExecutionParameter,
 } from '../../../model/packageableElements/service/V1_ServiceExecution';
-import {
-  type V1_ServiceTest,
-  V1_MultiExecutionTest,
-  V1_TestContainer,
-  V1_SingleExecutionTest,
-  V1_KeyedSingleExecutionTest,
-} from '../../../model/packageableElements/service/V1_ServiceTest';
+import { V1_ServiceTest } from '../../../model/packageableElements/service/V1_ServiceTest';
 import { V1_RawValueSpecificationTransformer } from './V1_RawValueSpecificationTransformer';
 import type { V1_RawLambda } from '../../../model/rawValueSpecification/V1_RawLambda';
 import { V1_transformRuntime } from './V1_RuntimeTransformer';
@@ -55,6 +43,92 @@ import {
   V1_transformStereotype,
   V1_transformTaggedValue,
 } from './V1_DomainTransformer';
+import {
+  type DEPRECATED__ServiceTest,
+  type DEPRECATED__KeyedSingleExecutionTest,
+  type DEPRECATED__TestContainer,
+  DEPRECATED__MultiExecutionTest,
+  DEPRECATED__SingleExecutionTest,
+} from '../../../../../../metamodels/pure/packageableElements/service/DEPRECATED__ServiceTest';
+import {
+  type V1_DEPRECATED__ServiceTest,
+  V1_DEPRECATED__KeyedSingleExecutionTest,
+  V1_DEPRECATED__MultiExecutionTest,
+  V1_DEPRECATED__SingleExecutionTest,
+  V1_DEPRECATED__TestContainer,
+} from '../../../model/packageableElements/service/V1_DEPRECATED__ServiceTest';
+import type { ConnectionTestData } from '../../../../../../metamodels/pure/packageableElements/service/ConnectionTestData';
+import { V1_ConnectionTestData } from '../../../model/packageableElements/service/V1_ConnectionTestData';
+import { V1_transformEmbeddedData } from './V1_DataElementTransformer';
+import { V1_ParameterValue } from '../../../model/packageableElements/service/V1_ParameterValue';
+import type { ParameterValue } from '../../../../../../metamodels/pure/packageableElements/service/ParameterValue';
+import type { TestData } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTestData';
+import { V1_TestData } from '../../../model/packageableElements/service/V1_TestData';
+import { V1_ServiceTestSuite } from '../../../model/packageableElements/service/V1_ServiceTestSuite';
+import type { ServiceTestSuite } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTestSuite';
+import {
+  V1_transformAtomicTest,
+  V1_transformTestAssertion,
+  V1_transformTestSuite,
+} from './V1_TestTransformer';
+
+const transformConnectionTestData = (
+  element: ConnectionTestData,
+  context: V1_GraphTransformerContext,
+): V1_ConnectionTestData => {
+  const connectionTestData = new V1_ConnectionTestData();
+  connectionTestData.id = element.connectionId;
+  connectionTestData.data = V1_transformEmbeddedData(element.testData, context);
+  return connectionTestData;
+};
+
+const transformParameterValue = (
+  element: ParameterValue,
+): V1_ParameterValue => {
+  const parameterValue = new V1_ParameterValue();
+  parameterValue.name = element.name;
+  parameterValue.value = element.value;
+  return parameterValue;
+};
+
+const transformTestData = (
+  element: TestData,
+  context: V1_GraphTransformerContext,
+): V1_TestData => {
+  const testData = new V1_TestData();
+  testData.connectionsTestData = element.connectionsTestData.map(
+    (connectionTestData) =>
+      transformConnectionTestData(connectionTestData, context),
+  );
+  return testData;
+};
+
+export const V1_transformServiceTest = (
+  element: ServiceTest,
+): V1_ServiceTest => {
+  const serviceTest = new V1_ServiceTest();
+  serviceTest.id = element.id;
+  serviceTest.parameters = element.parameters.map((parameter) =>
+    transformParameterValue(parameter),
+  );
+  serviceTest.assertions = element.assertions.map((assertion) =>
+    V1_transformTestAssertion(assertion),
+  );
+  return serviceTest;
+};
+
+export const V1_transformServiceTestSuite = (
+  element: ServiceTestSuite,
+  context: V1_GraphTransformerContext,
+): V1_ServiceTestSuite => {
+  const serviceTestSuite = new V1_ServiceTestSuite();
+  serviceTestSuite.id = element.id;
+  serviceTestSuite.testData = transformTestData(element.testData, context);
+  serviceTestSuite.tests = element.tests.map((test) =>
+    V1_transformAtomicTest(test),
+  );
+  return serviceTestSuite;
+};
 
 const transformSingleExecution = (
   element: PureSingleExecution,
@@ -111,10 +185,10 @@ const transformServiceExecution = (
 };
 
 const transformTestContainer = (
-  element: TestContainer,
+  element: DEPRECATED__TestContainer,
   context: V1_GraphTransformerContext,
-): V1_TestContainer => {
-  const container = new V1_TestContainer();
+): V1_DEPRECATED__TestContainer => {
+  const container = new V1_DEPRECATED__TestContainer();
   container.assert = element.assert.accept_RawValueSpecificationVisitor(
     new V1_RawValueSpecificationTransformer(context),
   ) as V1_RawLambda;
@@ -123,10 +197,10 @@ const transformTestContainer = (
 };
 
 const transformSingleExecutionTest = (
-  element: SingleExecutionTest,
+  element: DEPRECATED__SingleExecutionTest,
   context: V1_GraphTransformerContext,
-): V1_SingleExecutionTest => {
-  const single = new V1_SingleExecutionTest();
+): V1_DEPRECATED__SingleExecutionTest => {
+  const single = new V1_DEPRECATED__SingleExecutionTest();
   single.asserts = element.asserts
     .filter((testContainer) => testContainer.assert.body !== undefined)
     .map((testContainer) => transformTestContainer(testContainer, context));
@@ -135,10 +209,10 @@ const transformSingleExecutionTest = (
 };
 
 const transformKeyedSingleExecutionTest = (
-  element: KeyedSingleExecutionTest,
+  element: DEPRECATED__KeyedSingleExecutionTest,
   context: V1_GraphTransformerContext,
-): V1_KeyedSingleExecutionTest => {
-  const keyedTest = new V1_KeyedSingleExecutionTest();
+): V1_DEPRECATED__KeyedSingleExecutionTest => {
+  const keyedTest = new V1_DEPRECATED__KeyedSingleExecutionTest();
   keyedTest.asserts = element.asserts
     .filter((testContainer) => testContainer.assert.body !== undefined)
     .map((testContainer) => transformTestContainer(testContainer, context));
@@ -148,23 +222,23 @@ const transformKeyedSingleExecutionTest = (
 };
 
 const transformMultiExecutiontest = (
-  element: MultiExecutionTest,
+  element: DEPRECATED__MultiExecutionTest,
   context: V1_GraphTransformerContext,
-): V1_MultiExecutionTest => {
-  const multi = new V1_MultiExecutionTest();
+): V1_DEPRECATED__MultiExecutionTest => {
+  const multi = new V1_DEPRECATED__MultiExecutionTest();
   multi.tests = element.tests.map((test) =>
     transformKeyedSingleExecutionTest(test, context),
   );
   return multi;
 };
 
-const transformServiceTest = (
-  value: ServiceTest,
+const transformLegacyServiceTest = (
+  value: DEPRECATED__ServiceTest,
   context: V1_GraphTransformerContext,
-): V1_ServiceTest => {
-  if (value instanceof SingleExecutionTest) {
+): V1_DEPRECATED__ServiceTest => {
+  if (value instanceof DEPRECATED__SingleExecutionTest) {
     return transformSingleExecutionTest(value, context);
-  } else if (value instanceof MultiExecutionTest) {
+  } else if (value instanceof DEPRECATED__MultiExecutionTest) {
     return transformMultiExecutiontest(value, context);
   }
   throw new UnsupportedOperationError(`Can't transform service test`, value);
@@ -183,6 +257,11 @@ export const V1_transformService = (
   service.execution = transformServiceExecution(element.execution, context);
   service.owners = element.owners;
   service.pattern = element.pattern;
-  service.test = transformServiceTest(element.test, context);
+  if (element.test) {
+    service.test = transformLegacyServiceTest(element.test, context);
+  }
+  service.testSuites = element.tests.map((testSuite) =>
+    V1_transformTestSuite(testSuite, context),
+  );
   return service;
 };

package/src/models/protocols/pure/v1/transformation/pureGraph/from/V1_TestTransformer.ts

@@ -0,0 +1,176 @@
+/**
+ * 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 { UnsupportedOperationError } from '@finos/legend-shared';
+import { AssertFail } from '../../../../../../metamodels/pure/test/assertion/status/AssertFail';
+import type { AssertionStatus } from '../../../../../../metamodels/pure/test/assertion/status/AssertionStatus';
+import { AssertPass } from '../../../../../../metamodels/pure/test/assertion/status/AssertPass';
+import { EqualToJsonAssertFail } from '../../../../../../metamodels/pure/test/assertion/status/EqualToJsonAssertFail';
+import { V1_AssertFail } from '../../../model/test/assertion/status/V1_AssertFail';
+import type { V1_AssertionStatus } from '../../../model/test/assertion/status/V1_AssertionStatus';
+import { V1_AssertPass } from '../../../model/test/assertion/status/V1_AssertPass';
+import { V1_EqualToJsonAssertFail } from '../../../model/test/assertion/status/V1_EqualToJsonAssertFail';
+import { V1_AtomicTestId } from '../../../model/test/V1_AtomicTestId';
+import { V1_EqualTo } from '../../../model/test/assertion/V1_EqualTo';
+import { V1_EqualToJson } from '../../../model/test/assertion/V1_EqualToJson';
+import { EqualTo } from '../../../../../../metamodels/pure/test/assertion/EqualTo';
+import { EqualToJson } from '../../../../../../metamodels/pure/test/assertion/EqualToJson';
+import { V1_transformExternalFormatData } from './V1_DataElementTransformer';
+import type { V1_AtomicTest } from '../../../model/test/V1_AtomicTest';
+import { ServiceTest } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTest';
+import type { V1_TestAssertion } from '../../../model/test/assertion/V1_TestAssertion';
+import type { TestAssertion } from '../../../../../../metamodels/pure/test/assertion/TestAssertion';
+import type { V1_TestSuite } from '../../../model/test/V1_TestSuite';
+import { V1_TestResult } from '../../../model/test/result/V1_TestResult';
+import { V1_TestPassed } from '../../../model/test/result/V1_TestPassed';
+import { V1_TestFailed } from '../../../model/test/result/V1_TestFailed';
+import { V1_TestError } from '../../../model/test/result/V1_TestError';
+import type { TestResult } from '../../../../../../metamodels/pure/test/result/TestResult';
+import type { TestPassed } from '../../../../../../metamodels/pure/test/result/TestPassed';
+import type { TestFailed } from '../../../../../../metamodels/pure/test/result/TestFailed';
+import type { TestError } from '../../../../../../metamodels/pure/test/result/TestError';
+import {
+  V1_transformServiceTest,
+  V1_transformServiceTestSuite,
+} from './V1_ServiceTransformer';
+import { ServiceTestSuite } from '../../../../../../metamodels/pure/packageableElements/service/ServiceTestSuite';
+import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext';
+import type { AtomicTestId } from '../../../../../../metamodels/pure/test/result/AtomicTestId';
+import type {
+  AtomicTest,
+  TestSuite,
+} from '../../../../../../metamodels/pure/test/Test';
+
+const transformAtomicTestId = (element: AtomicTestId): V1_AtomicTestId => {
+  const atomicTestId = new V1_AtomicTestId();
+  atomicTestId.atomicTestId = element.atomicTestId;
+  atomicTestId.testSuiteId = element.testSuiteId;
+  return atomicTestId;
+};
+
+const transformAssertFail = (element: AssertFail): V1_AssertFail => {
+  const assertFail = new V1_AssertFail();
+  assertFail.id = element.id;
+  assertFail.message = element.message;
+  return assertFail;
+};
+
+const transformAssertPass = (element: AssertPass): V1_AssertPass => {
+  const assertPass = new V1_AssertPass();
+  assertPass.id = element.id;
+  return assertPass;
+};
+
+const transformEqualToJsonAssertFail = (
+  element: EqualToJsonAssertFail,
+): V1_EqualToJsonAssertFail => {
+  const equalToJsonAssertFail = new V1_EqualToJsonAssertFail();
+  equalToJsonAssertFail.id = element.id;
+  equalToJsonAssertFail.message = element.message;
+  equalToJsonAssertFail.actual = element.actual;
+  equalToJsonAssertFail.expected = element.expected;
+  return equalToJsonAssertFail;
+};
+
+const transformAssertionStatus = (
+  value: AssertionStatus,
+): V1_AssertionStatus => {
+  if (value instanceof EqualToJsonAssertFail) {
+    return transformEqualToJsonAssertFail(value);
+  } else if (value instanceof AssertFail) {
+    return transformAssertFail(value);
+  } else if (value instanceof AssertPass) {
+    return transformAssertPass(value);
+  }
+  throw new UnsupportedOperationError(
+    `Can't transform assertion status`,
+    value,
+  );
+};
+
+const transformEqualTo = (element: EqualTo): V1_EqualTo => {
+  const equalTo = new V1_EqualTo();
+  equalTo.id = element.id;
+  equalTo.expected = element.expected;
+  return equalTo;
+};
+
+const transformEqualToJson = (element: EqualToJson): V1_EqualToJson => {
+  const equalToJson = new V1_EqualToJson();
+  equalToJson.id = element.id;
+  equalToJson.expected = V1_transformExternalFormatData(element.expected);
+  return equalToJson;
+};
+
+export const V1_transformTestError = (element: TestError): V1_TestError => {
+  const testError = new V1_TestError();
+  testError.testable = element.testable;
+  testError.error = element.error;
+  testError.atomicTestId = transformAtomicTestId(element.atomicTestId);
+  return testError;
+};
+
+export const V1_transformTestFailed = (element: TestFailed): V1_TestFailed => {
+  const testFailed = new V1_TestFailed();
+  testFailed.testable = element.testable;
+  testFailed.atomicTestId = transformAtomicTestId(element.atomicTestId);
+  testFailed.assertStatuses = element.assertStatuses.map((assertStatus) =>
+    transformAssertionStatus(assertStatus),
+  );
+  return testFailed;
+};
+
+export const V1_transformTestPassed = (element: TestPassed): V1_TestPassed => {
+  const testPassed = new V1_TestPassed();
+  testPassed.testable = element.testable;
+  testPassed.atomicTestId = transformAtomicTestId(element.atomicTestId);
+  return testPassed;
+};
+
+export const V1_transformTestResult = (element: TestResult): V1_TestResult => {
+  const testResult = new V1_TestResult();
+  testResult.testable = element.testable;
+  testResult.atomicTestId = transformAtomicTestId(element.atomicTestId);
+  return testResult;
+};
+
+export const V1_transformAtomicTest = (value: AtomicTest): V1_AtomicTest => {
+  if (value instanceof ServiceTest) {
+    return V1_transformServiceTest(value);
+  }
+  throw new UnsupportedOperationError(`Can't transform atomic test`, value);
+};
+
+export const V1_transformTestAssertion = (
+  value: TestAssertion,
+): V1_TestAssertion => {
+  if (value instanceof EqualTo) {
+    return transformEqualTo(value);
+  } else if (value instanceof EqualToJson) {
+    return transformEqualToJson(value);
+  }
+  throw new UnsupportedOperationError(`Can't transform test assertion`, value);
+};
+
+export const V1_transformTestSuite = (
+  value: TestSuite,
+  context: V1_GraphTransformerContext,
+): V1_TestSuite => {
+  if (value instanceof ServiceTestSuite) {
+    return V1_transformServiceTestSuite(value, context);
+  }
+  throw new UnsupportedOperationError(`Can't transform test suite`, value);
+};