@finos/legend-graph 5.0.0 → 7.0.0

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_TestBuilderHelper.ts

@@ -0,0 +1,122 @@
+/**
+ * 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 { guaranteeType, UnsupportedOperationError } from '@finos/legend-shared';
+import { ExternalFormatData } from '../../../../../../../metamodels/pure/data/EmbeddedData';
+import { EqualTo } from '../../../../../../../metamodels/pure/test/assertion/EqualTo';
+import { EqualToJson } from '../../../../../../../metamodels/pure/test/assertion/EqualToJson';
+import {
+  EqualToTDS,
+  RelationalTDS,
+} from '../../../../../../../metamodels/pure/test/assertion/EqualToTDS';
+import type { TestAssertion } from '../../../../../../../metamodels/pure/test/assertion/TestAssertion';
+import type {
+  AtomicTest,
+  TestSuite,
+} from '../../../../../../../metamodels/pure/test/Test';
+import { V1_ServiceTest } from '../../../../model/packageableElements/service/V1_ServiceTest';
+import { V1_ServiceTestSuite } from '../../../../model/packageableElements/service/V1_ServiceTestSuite';
+import { V1_EqualTo } from '../../../../model/test/assertion/V1_EqualTo';
+import { V1_EqualToJson } from '../../../../model/test/assertion/V1_EqualToJson';
+import { V1_EqualToTDS } from '../../../../model/test/assertion/V1_EqualToTDS';
+import type { V1_TestAssertion } from '../../../../model/test/assertion/V1_TestAssertion';
+import type { V1_AtomicTest } from '../../../../model/test/V1_AtomicTest';
+import type { V1_TestSuite } from '../../../../model/test/V1_TestSuite';
+import type { V1_GraphBuilderContext } from '../V1_GraphBuilderContext';
+import { V1_ProtocolToMetaModelEmbeddedDataBuilder } from './V1_DataElementBuilderHelper';
+import {
+  V1_buildServiceTest,
+  V1_buildServiceTestSuite,
+} from './V1_ServiceBuilderHelper';
+
+const buildEqualTo = (
+  element: V1_EqualTo,
+  parentTest: AtomicTest | undefined,
+): EqualTo => {
+  const equalTo = new EqualTo();
+  equalTo.id = element.id;
+  equalTo.parentTest = parentTest;
+  equalTo.expected = element.expected;
+  return equalTo;
+};
+
+const buildEqualToJson = (
+  element: V1_EqualToJson,
+  parentTest: AtomicTest | undefined,
+  context: V1_GraphBuilderContext,
+): EqualToJson => {
+  const equalToJson = new EqualToJson();
+  equalToJson.id = element.id;
+  equalToJson.parentTest = parentTest;
+  equalToJson.expected = guaranteeType(
+    element.expected.accept_EmbeddedDataVisitor(
+      new V1_ProtocolToMetaModelEmbeddedDataBuilder(context),
+    ),
+    ExternalFormatData,
+  );
+  return equalToJson;
+};
+
+const buildEqualToTDS = (
+  element: V1_EqualToTDS,
+  parentTest: AtomicTest | undefined,
+  context: V1_GraphBuilderContext,
+): EqualToTDS => {
+  const equalToTDS = new EqualToTDS();
+  equalToTDS.id = element.id;
+  equalToTDS.parentTest = parentTest;
+  const expected = new RelationalTDS();
+  expected.columns = element.expected.columns;
+  expected.rows = element.expected.rows;
+  equalToTDS.expected = expected;
+  return equalToTDS;
+};
+
+export const V1_buildAtomicTest = (
+  value: V1_AtomicTest,
+  parentSuite: TestSuite | undefined,
+  context: V1_GraphBuilderContext,
+): AtomicTest => {
+  if (value instanceof V1_ServiceTest) {
+    return V1_buildServiceTest(value, parentSuite, context);
+  }
+  throw new UnsupportedOperationError(`Can't build atomic test`, value);
+};
+
+export const V1_buildTestAssertion = (
+  value: V1_TestAssertion,
+  parentTest: AtomicTest | undefined,
+  context: V1_GraphBuilderContext,
+): TestAssertion => {
+  if (value instanceof V1_EqualTo) {
+    return buildEqualTo(value, parentTest);
+  } else if (value instanceof V1_EqualToJson) {
+    return buildEqualToJson(value, parentTest, context);
+  } else if (value instanceof V1_EqualToTDS) {
+    return buildEqualToTDS(value, parentTest, context);
+  }
+  throw new UnsupportedOperationError(`Can't build test assertion`, value);
+};
+
+export const V1_buildTestSuite = (
+  value: V1_TestSuite,
+  context: V1_GraphBuilderContext,
+): TestSuite => {
+  if (value instanceof V1_ServiceTestSuite) {
+    return V1_buildServiceTestSuite(value, context);
+  }
+  throw new UnsupportedOperationError(`Can't build test suite`, value);
+};

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_TestResultBuilderHelper.ts

@@ -0,0 +1,165 @@
+/**
+ * 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 {
+  filterByType,
+  guaranteeNonNullable,
+  guaranteeType,
+  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 { AtomicTestId } from '../../../../../../../metamodels/pure/test/result/AtomicTestId';
+import {
+  TestError,
+  TestFailed,
+  TestPassed,
+  type TestResult,
+} from '../../../../../../../metamodels/pure/test/result/TestResult';
+import {
+  AtomicTest,
+  TestSuite,
+} from '../../../../../../../metamodels/pure/test/Test';
+import type { Testable } from '../../../../../../../metamodels/pure/test/Testable';
+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 {
+  type V1_TestResult,
+  V1_TestFailed,
+  V1_TestPassed,
+  V1_TestError,
+} from '../../../../model/test/result/V1_TestResult';
+import type { V1_AtomicTestId } from '../../../../model/test/V1_AtomicTestId';
+
+const buildAtomicTestId = (
+  element: V1_AtomicTestId,
+  testable: Testable,
+): AtomicTestId => {
+  const testSuite = testable.tests
+    .filter(filterByType(TestSuite))
+    .find((t) => t.id === element.testSuiteId);
+  let atomicTest: AtomicTest;
+  if (testSuite) {
+    atomicTest = guaranteeNonNullable(
+      testSuite.tests.find((aT) => aT.id === element.atomicTestId),
+    );
+  } else {
+    atomicTest = guaranteeType(
+      testable.tests.find((e) => e.id === element.atomicTestId),
+      AtomicTest,
+    );
+  }
+  return new AtomicTestId(testSuite, atomicTest);
+};
+
+const buildAssertFail = (
+  element: V1_AssertFail,
+  atomicTest: AtomicTest,
+): AssertFail => {
+  const assertion = guaranteeNonNullable(
+    atomicTest.assertions.find((a) => a.id === element.id),
+  );
+  return new AssertFail(assertion, element.message);
+};
+const buildAssertPass = (
+  element: V1_AssertPass,
+  atomicTest: AtomicTest,
+): AssertPass => {
+  const assertion = guaranteeNonNullable(
+    atomicTest.assertions.find((a) => a.id === element.id),
+  );
+  return new AssertPass(assertion);
+};
+
+const buildEqualToJsonAssertFail = (
+  element: V1_EqualToJsonAssertFail,
+  atomicTest: AtomicTest,
+): EqualToJsonAssertFail => {
+  const assertion = guaranteeNonNullable(
+    atomicTest.assertions.find((a) => a.id === element.id),
+  );
+  const equalToJsonAssertFail = new EqualToJsonAssertFail(
+    assertion,
+    element.message,
+  );
+  equalToJsonAssertFail.actual = element.actual;
+  equalToJsonAssertFail.expected = element.expected;
+  return equalToJsonAssertFail;
+};
+
+const buildAssertionStatus = (
+  value: V1_AssertionStatus,
+  atomicTest: AtomicTest,
+): AssertionStatus => {
+  if (value instanceof V1_EqualToJsonAssertFail) {
+    return buildEqualToJsonAssertFail(value, atomicTest);
+  } else if (value instanceof V1_AssertFail) {
+    return buildAssertFail(value, atomicTest);
+  } else if (value instanceof V1_AssertPass) {
+    return buildAssertPass(value, atomicTest);
+  }
+  throw new UnsupportedOperationError(`Can't build assertion status`, value);
+};
+export const V1_buildTestError = (
+  element: V1_TestError,
+  testable: Testable,
+): TestError => {
+  const testError = new TestError();
+  testError.testable = testable;
+  testError.atomicTestId = buildAtomicTestId(element.atomicTestId, testable);
+  testError.error = element.error;
+  return testError;
+};
+export const V1_buildTestFailed = (
+  element: V1_TestFailed,
+  testable: Testable,
+): TestFailed => {
+  const testFailed = new TestFailed();
+  testFailed.atomicTestId = buildAtomicTestId(element.atomicTestId, testable);
+  testFailed.testable = testable;
+  testFailed.assertStatuses = element.assertStatuses.map((e) =>
+    buildAssertionStatus(e, testFailed.atomicTestId.atomicTest),
+  );
+  return testFailed;
+};
+
+export const V1_buildTestPassed = (
+  element: V1_TestPassed,
+  testable: Testable,
+): TestPassed => {
+  const testPassed = new TestPassed();
+  testPassed.testable = testable;
+  testPassed.atomicTestId = buildAtomicTestId(element.atomicTestId, testable);
+  return testPassed;
+};
+
+export const V1_buildTestResult = (
+  element: V1_TestResult,
+  testable: Testable,
+): TestResult | undefined => {
+  if (element instanceof V1_TestPassed) {
+    return V1_buildTestPassed(element, testable);
+  } else if (element instanceof V1_TestFailed) {
+    return V1_buildTestFailed(element, testable);
+  } else if (element instanceof V1_TestError) {
+    return V1_buildTestError(element, testable);
+  }
+  throw new UnsupportedOperationError(`Can't build test result`, element);
+};

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_ValueSpecificationBuilderHelper.ts

@@ -118,9 +118,10 @@ import { EnumValueExplicitReference } from '../../../../../../../metamodels/pure
 import type { V1_PackageableElementPtr } from '../../../../model/valueSpecification/raw/V1_PackageableElementPtr';
 import type { V1_HackedClass } from '../../../../model/valueSpecification/raw/V1_HackedClass';
 import type { V1_HackedUnit } from '../../../../model/valueSpecification/raw/V1_HackedUnit';
-import type { V1_INTERNAL__UnknownValueSpecfication } from '../../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
+import type { V1_INTERNAL__UnknownValueSpecification } from '../../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
 import { INTERNAL__UnknownValueSpecification } from '../../../../../../../metamodels/pure/valueSpecification/INTERNAL__UnknownValueSpecification';
 import { GraphBuilderError } from '../../../../../../../../graphManager/GraphManagerUtils';
+import { getEnumValue } from '../../../../../../../../helpers/DomainHelper';
 
 const LET_FUNCTION = 'letFunction';
 
@@ -154,7 +155,7 @@ export class V1_ValueSpecificationBuilder
   }
 
   visit_INTERNAL__UnknownValueSpecfication(
-    valueSpecification: V1_INTERNAL__UnknownValueSpecfication,
+    valueSpecification: V1_INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     const metamodel = new INTERNAL__UnknownValueSpecification(
       valueSpecification.content,
@@ -888,7 +889,7 @@ export function V1_processProperty(
       context.graph.getTypicalMultiplicity(TYPICAL_MULTIPLICITY_TYPE.ONE),
     );
     enumValueInstanceValue.values = [
-      EnumValueExplicitReference.create(inferredType.getValue(property)),
+      EnumValueExplicitReference.create(getEnumValue(inferredType, property)),
     ];
     return enumValueInstanceValue;
   }

package/src/models/protocols/pure/v1/transformation/pureGraph/to/helpers/V1_ValueSpecificationPathResolver.ts

@@ -60,7 +60,7 @@ import type { V1_TdsOlapRank } from '../../../../model/valueSpecification/raw/V1
 import type { V1_TDSSortInformation } from '../../../../model/valueSpecification/raw/V1_TDSSortInformation';
 import type { V1_UnitInstance } from '../../../../model/valueSpecification/raw/V1_UnitInstance';
 import type { V1_UnitType } from '../../../../model/valueSpecification/raw/V1_UnitType';
-import type { V1_INTERNAL__UnknownValueSpecfication } from '../../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
+import type { V1_INTERNAL__UnknownValueSpecification } from '../../../../model/valueSpecification/V1_INTERNAL__UnknownValueSpecfication';
 import type {
   V1_ValueSpecification,
   V1_ValueSpecificationVisitor,
@@ -91,7 +91,7 @@ class V1_ValueSpecificationPathResolver
   }
 
   visit_INTERNAL__UnknownValueSpecfication(
-    spec: V1_INTERNAL__UnknownValueSpecfication,
+    spec: V1_INTERNAL__UnknownValueSpecification,
   ): V1_ValueSpecification {
     return spec;
   }

package/src/models/protocols/pure/v1/transformation/pureProtocol/V1_PackageableElementSerialization.ts

@@ -49,7 +49,7 @@ import {
   V1_MAPPING_ELEMENT_PROTOCOL_TYPE,
 } from './serializationHelpers/V1_MappingSerializationHelper';
 import {
-  V1_servicedModelSchema,
+  V1_serviceModelSchema,
   V1_SERVICE_ELEMENT_PROTOCOL_TYPE,
 } from './serializationHelpers/V1_ServiceSerializationHelper';
 import {
@@ -95,6 +95,11 @@ import type {
   V1_ElementProtocolSerializer,
 } from '../../../PureProtocolProcessorPlugin';
 import { createPath } from '../../../../../../MetaModelUtils';
+import type { V1_DataElement } from '../../model/packageableElements/data/V1_DataElement';
+import {
+  V1_dataElementModelSchema,
+  V1_DATA_ELEMENT_PROTOCOL_TYPE,
+} from './serializationHelpers/V1_DataElementSerializationHelper';
 
 class V1_PackageableElementSerializer
   implements V1_PackageableElementVisitor<PlainObject<V1_PackageableElement>>
@@ -166,7 +171,7 @@ class V1_PackageableElementSerializer
   }
 
   visit_Service(element: V1_Service): PlainObject<V1_PackageableElement> {
-    return serialize(V1_servicedModelSchema, element);
+    return serialize(V1_serviceModelSchema(this.plugins), element);
   }
 
   visit_PackageableRuntime(
@@ -201,6 +206,12 @@ class V1_PackageableElementSerializer
   ): PlainObject<V1_PackageableElement> {
     return serialize(V1_sectionIndexModelSchema, element);
   }
+
+  visit_DataElement(
+    element: V1_DataElement,
+  ): PlainObject<V1_PackageableElement> {
+    return serialize(V1_dataElementModelSchema(this.plugins), element);
+  }
 }
 
 export const V1_serializePackageableElement = (
@@ -256,7 +267,7 @@ export const V1_deserializePackageableElement = (
       case V1_MAPPING_ELEMENT_PROTOCOL_TYPE:
         return deserialize(V1_mappingModelSchema(plugins), json);
       case V1_SERVICE_ELEMENT_PROTOCOL_TYPE:
-        return deserialize(V1_servicedModelSchema, json);
+        return deserialize(V1_serviceModelSchema(plugins), json);
       case V1_PACKAGEABLE_CONNECTION_ELEMENT_PROTOCOL_TYPE:
         return deserialize(V1_packageableConnectionModelSchema(plugins), json);
       case V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE:
@@ -267,6 +278,8 @@ export const V1_deserializePackageableElement = (
         return deserialize(V1_generationSpecificationsModelSchema, json);
       case V1_SECTION_INDEX_ELEMENT_PROTOCOL_TYPE:
         return deserialize(V1_sectionIndexModelSchema, json);
+      case V1_DATA_ELEMENT_PROTOCOL_TYPE:
+        return deserialize(V1_dataElementModelSchema(plugins), json);
       default: {
         for (const deserializer of extraElementProtocolDeserializers) {
           const elementProtocol = deserializer(json, plugins);

package/src/models/protocols/pure/v1/transformation/pureProtocol/serializationHelpers/V1_ConnectionSerializationHelper.ts

@@ -30,6 +30,8 @@ import {
   usingConstantValueSchema,
   IllegalStateError,
   UnsupportedOperationError,
+  serializeArray,
+  deserializeArray,
 } from '@finos/legend-shared';
 import { V1_ModelChainConnection } from '../../../model/packageableElements/store/modelToModel/connection/V1_ModelChainConnection';
 import { V1_PackageableConnection } from '../../../model/packageableElements/connection/V1_PackageableConnection';
@@ -90,7 +92,15 @@ export const V1_modelChainConnectionModelSchema = createModelSchema(
   V1_ModelChainConnection,
   {
     _type: usingConstantValueSchema(V1_ConnectionType.MODEL_CHAIN_CONNECTION),
-    store: alias('element', optional(primitive())), // @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
+     */
+    store: alias('element', optional(primitive())),
     mappings: list(primitive()),
   },
 );
@@ -100,7 +110,15 @@ export const V1_jsonModelConnectionModelSchema = createModelSchema(
   {
     _type: usingConstantValueSchema(V1_ConnectionType.JSON_MODEL_CONNECTION),
     class: primitive(),
-    store: alias('element', optional(primitive())), // @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
+     */
+    store: alias('element', optional(primitive())),
     url: primitive(),
   },
 );
@@ -110,7 +128,15 @@ export const V1_xmlModelConnectionModelSchema = createModelSchema(
   {
     _type: usingConstantValueSchema(V1_ConnectionType.XML_MODEL_CONNECTION),
     class: primitive(),
-    store: alias('element', optional(primitive())), // @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
+     */
+    store: alias('element', optional(primitive())),
     url: primitive(),
   },
 );
@@ -161,7 +187,16 @@ const localH2DatasourceSpecificationModelSchema = createModelSchema(
   {
     _type: usingConstantValueSchema(V1_DatasourceSpecificationType.H2_LOCAL),
     testDataSetupCsv: optional(primitive()),
-    testDataSetupSqls: list(primitive()),
+    testDataSetupSqls: custom(
+      (values) =>
+        serializeArray(values, (value) => value, {
+          skipIfEmpty: true,
+        }),
+      (values) =>
+        deserializeArray(values, (v) => v, {
+          skipIfEmpty: false,
+        }),
+    ),
   },
 );
 
@@ -214,6 +249,8 @@ const bigqueryDatasourceSpecificationModelSchema = createModelSchema(
     _type: usingConstantValueSchema(V1_DatasourceSpecificationType.BIGQUERY),
     defaultDataset: primitive(),
     projectId: primitive(),
+    proxyHost: optional(primitive()),
+    proxyPort: optional(primitive()),
   },
 );