@finos/legend-graph 31.4.2 → 31.5.1

package/src/graph/metamodel/pure/packageableElements/function/test/FunctionTest.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 { hashArray, type Hashable } from '@finos/legend-shared';
+import { AtomicTest } from '../../../test/Test.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../../Core_HashUtils.js';
+
+export class FunctionParameterValue implements Hashable {
+  name!: string;
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  value!: object;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.FUNCTION_PARAMETER_VALUE,
+      this.name,
+      hashObjectWithoutSourceInformation(this.value),
+    ]);
+  }
+}
+
+export class FunctionTest extends AtomicTest implements Hashable {
+  parameters: FunctionParameterValue[] | undefined;
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.FUNCTION_TEST,
+      this.id,
+      this.doc ?? '',
+      this.parameters ? hashArray(this.parameters) : '',
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/function/test/FunctionTestSuite.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { hashArray } from '@finos/legend-shared';
+import { TestSuite } from '../../../test/Test.js';
+import type { FunctionStoreTestData } from './FunctionStoreTestData.js';
+import { CORE_HASH_STRUCTURE } from '../../../../../Core_HashUtils.js';
+
+export class FunctionTestSuite extends TestSuite {
+  testData: FunctionStoreTestData[] | undefined;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.FUNCTION_TEST_SUITE,
+      this.id,
+      this.doc ?? '',
+      this.testData ? hashArray(this.testData) : '',
+      hashArray(this.tests),
+    ]);
+  }
+}

package/src/graph-manager/action/changeDetection/DomainObserverHelper.ts

@@ -68,6 +68,14 @@ import {
 import type { INTERNAL__UnknownFunctionActivator } from '../../../graph/metamodel/pure/packageableElements/function/INTERNAL__UnknownFunctionActivator.js';
 import type { SnowflakeApp } from '../../../graph/metamodel/pure/packageableElements/function/SnowflakeApp.js';
 import { observe_SnowflakeAppDeploymentConfiguration } from './DSL_FunctionActivatorObserverHelper.js';
+import type { FunctionTest } from '../../../graph/metamodel/pure/packageableElements/function/test/FunctionTest.js';
+import type { FunctionTestSuite } from '../../../graph/metamodel/pure/packageableElements/function/test/FunctionTestSuite.js';
+import {
+  observe_AtomicTest,
+  observe_TestAssertion,
+} from './Testable_ObserverHelper.js';
+import type { FunctionStoreTestData } from '../../../graph/metamodel/pure/packageableElements/function/test/FunctionStoreTestData.js';
+import { observe_EmbeddedData } from './DSL_Data_ObserverHelper.js';
 
 const _observe_Abstract_Package = (metamodel: Package): void => {
   observe_Abstract_PackageableElement(metamodel);
@@ -83,7 +91,7 @@ const _observe_Abstract_Package = (metamodel: Package): void => {
  * and observe all descendents.
  */
 export const observe_Package = skipObservedWithContext(
-  (metamodel: Package, context): Package => {
+  (metamodel: Package, context: ObserverContext): Package => {
     _observe_Abstract_Package(metamodel);
 
     metamodel.children.forEach((child) => {
@@ -453,8 +461,52 @@ export const observe_Association = skipObserved(
 
 // ------------------------------------- Function -------------------------------------
 
-export const observe_ConcreteFunctionDefinition = skipObserved(
-  (metamodel: ConcreteFunctionDefinition): ConcreteFunctionDefinition => {
+export const observe_FunctionTest = skipObserved(
+  (metamodel: FunctionTest): FunctionTest => {
+    makeObservable(metamodel, {
+      id: observable,
+      doc: observable,
+      assertions: observable,
+      hashCode: computed,
+    });
+    metamodel.assertions.forEach(observe_TestAssertion);
+    return metamodel;
+  },
+);
+
+export const observe_FunctionTestData = skipObservedWithContext(
+  (metamodel: FunctionStoreTestData, context: ObserverContext) => {
+    makeObservable(metamodel, {
+      store: observable,
+      data: observable,
+      hashCode: computed,
+    });
+    observe_EmbeddedData(metamodel.data, context);
+    return metamodel;
+  },
+);
+
+export const observe_FunctionTestSuite = skipObservedWithContext(
+  (
+    metamodel: FunctionTestSuite,
+    context: ObserverContext,
+  ): FunctionTestSuite => {
+    makeObservable(metamodel, {
+      id: observable,
+      tests: observable,
+      testData: observable,
+      hashCode: computed,
+    });
+    metamodel.tests.forEach((t) => observe_AtomicTest(t, context));
+    metamodel.testData?.forEach((t) => observe_FunctionTestData(t, context));
+    return metamodel;
+  },
+);
+export const observe_ConcreteFunctionDefinition = skipObservedWithContext(
+  (
+    metamodel: ConcreteFunctionDefinition,
+    context: ObserverContext,
+  ): ConcreteFunctionDefinition => {
     observe_Abstract_PackageableElement(metamodel);
 
     makeObservable<ConcreteFunctionDefinition, '_elementHashCode'>(metamodel, {
@@ -471,7 +523,7 @@ export const observe_ConcreteFunctionDefinition = skipObserved(
     observe_PackageableElementReference(metamodel.returnType);
     metamodel.stereotypes.forEach(observe_StereotypeReference);
     metamodel.taggedValues.forEach(observe_TaggedValue);
-
+    metamodel.tests.forEach((t) => observe_FunctionTestSuite(t, context));
     return metamodel;
   },
 );

package/src/graph-manager/action/changeDetection/PackageableElementObserver.ts

@@ -146,7 +146,7 @@ class PackageableElementObserver implements PackageableElementVisitor<void> {
   }
 
   visit_ConcreteFunctionDefinition(element: ConcreteFunctionDefinition): void {
-    observe_ConcreteFunctionDefinition(element);
+    observe_ConcreteFunctionDefinition(element, this.observerContext);
   }
 
   visit_FlatData(element: FlatData): void {

package/src/graph-manager/action/changeDetection/Testable_ObserverHelper.ts

@@ -38,6 +38,8 @@ import {
   observe_ServiceTest,
   observe_ServiceTestSuite,
 } from './DSL_Service_ObserverHelper.js';
+import { FunctionTest } from '../../../graph/metamodel/pure/packageableElements/function/test/FunctionTest.js';
+import { observe_FunctionTest } from './DomainObserverHelper.js';
 
 export const observe_EqualTo = skipObserved((metamodel: EqualTo): EqualTo => {
   makeObservable(metamodel, {
@@ -83,6 +85,8 @@ export function observe_AtomicTest(
     return observe_ServiceTest(metamodel);
   } else if (metamodel instanceof MappingTest) {
     return observe_MappingTest(metamodel, context);
+  } else if (metamodel instanceof FunctionTest) {
+    return observe_FunctionTest(metamodel);
   }
   const extraAtomicTestBuilder = context.plugins.flatMap(
     (plugin) =>

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/V1_ConcreteFunctionDefinition.ts

@@ -27,6 +27,7 @@ import {
   type V1_PackageableElementVisitor,
   V1_PackageableElement,
 } from '../../../model/packageableElements/V1_PackageableElement.js';
+import type { V1_FunctionTestSuite } from './test/V1_FunctionTestSuite.js';
 
 export class V1_ConcreteFunctionDefinition extends V1_PackageableElement {
   /**
@@ -57,6 +58,7 @@ export class V1_ConcreteFunctionDefinition extends V1_PackageableElement {
   returnMultiplicity!: V1_Multiplicity;
   taggedValues: V1_TaggedValue[] = [];
   stereotypes: V1_StereotypePtr[] = [];
+  tests: V1_FunctionTestSuite[] | undefined;
 
   override get hashCode(): string {
     return hashArray([
@@ -67,6 +69,7 @@ export class V1_ConcreteFunctionDefinition extends V1_PackageableElement {
       hashArray(this.taggedValues),
       hashArray(this.stereotypes),
       hashRawLambda(undefined, this.body),
+      this.tests ? hashArray(this.tests) : '',
     ]);
   }
 

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/test/V1_FunctionStoreTestData.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { hashArray, type Hashable } from '@finos/legend-shared';
+import type { V1_EmbeddedData } from '../../../data/V1_EmbeddedData.js';
+import { CORE_HASH_STRUCTURE } from '../../../../../../../../graph/Core_HashUtils.js';
+
+export class V1_FunctionStoreTestData implements Hashable {
+  doc: string | undefined;
+  store!: string;
+  data!: V1_EmbeddedData;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.FUNCTION_STORE_TEST_DATA,
+      this.doc ?? '',
+      this.store,
+      this.data,
+    ]);
+  }
+}

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/test/V1_FunctionTest.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { hashArray, type Hashable } from '@finos/legend-shared';
+import { V1_AtomicTest } from '../../../test/V1_AtomicTest.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../../../../../graph/Core_HashUtils.js';
+
+export class V1_FunctionParameterValue implements Hashable {
+  name!: string;
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  value!: object;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.FUNCTION_PARAMETER_VALUE,
+      this.name,
+      hashObjectWithoutSourceInformation(this.value),
+    ]);
+  }
+}
+
+export class V1_FunctionTest extends V1_AtomicTest {
+  parameters: V1_FunctionParameterValue[] | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.FUNCTION_TEST,
+      this.id,
+      this.doc ?? '',
+      this.parameters ? hashArray(this.parameters) : '',
+    ]);
+  }
+}

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/test/V1_FunctionTestSuite.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { hashArray } from '@finos/legend-shared';
+import { V1_TestSuite } from '../../../test/V1_TestSuite.js';
+import { CORE_HASH_STRUCTURE } from '../../../../../../../../graph/Core_HashUtils.js';
+import type { V1_FunctionStoreTestData } from './V1_FunctionStoreTestData.js';
+
+export class V1_FunctionTestSuite extends V1_TestSuite {
+  testData: V1_FunctionStoreTestData[] | undefined;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.FUNCTION_TEST_SUITE,
+      this.id,
+      this.doc ?? '',
+      this.testData ? hashArray(this.testData) : '',
+      hashArray(this.tests),
+    ]);
+  }
+}

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/from/V1_DomainTransformer.ts

@@ -54,6 +54,17 @@ import { V1_DerivedProperty } from '../../../model/packageableElements/domain/V1
 import type { V1_RawVariable } from '../../../model/rawValueSpecification/V1_RawVariable.js';
 import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext.js';
 import { isStubbed_RawLambda } from '../../../../../../../graph/helpers/creator/RawValueSpecificationCreatorHelper.js';
+import type { FunctionTestSuite } from '../../../../../../../graph/metamodel/pure/packageableElements/function/test/FunctionTestSuite.js';
+import { V1_FunctionTestSuite } from '../../../model/packageableElements/function/test/V1_FunctionTestSuite.js';
+import { FunctionTest } from '../../../../../../../graph/metamodel/pure/packageableElements/function/test/FunctionTest.js';
+import {
+  V1_FunctionParameterValue,
+  V1_FunctionTest,
+} from '../../../model/packageableElements/function/test/V1_FunctionTest.js';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+import { V1_FunctionStoreTestData } from '../../../model/packageableElements/function/test/V1_FunctionStoreTestData.js';
+import { V1_transformEmbeddedData } from './V1_DataElementTransformer.js';
+import { V1_transformTestAssertion } from './V1_TestTransformer.js';
 
 export const V1_transformProfile = (element: Profile): V1_Profile => {
   const profile = new V1_Profile();
@@ -224,6 +235,49 @@ export const V1_transformAssociation = (
   return association;
 };
 
+const V1_transformFunctionTest = (element: FunctionTest): V1_FunctionTest => {
+  const functionTest = new V1_FunctionTest();
+  functionTest.id = element.id;
+  functionTest.doc = element.doc;
+  functionTest.assertions = element.assertions.map((assertion) =>
+    V1_transformTestAssertion(assertion),
+  );
+  functionTest.parameters = element.parameters?.map((p) => {
+    const parameterValue = new V1_FunctionParameterValue();
+    parameterValue.name = p.name;
+    parameterValue.value = p.value;
+    return parameterValue;
+  });
+  return functionTest;
+};
+
+const V1_transformFunctionSuite = (
+  element: FunctionTestSuite,
+  context: V1_GraphTransformerContext,
+): V1_FunctionTestSuite => {
+  const testSuite = new V1_FunctionTestSuite();
+  testSuite.id = element.id;
+  testSuite.doc = element.doc;
+  if (element.testData?.length) {
+    testSuite.testData = element.testData.map((elementData) => {
+      const pTestData = new V1_FunctionStoreTestData();
+      pTestData.doc = elementData.doc;
+      pTestData.store = elementData.store.valueForSerialization ?? '';
+      pTestData.data = V1_transformEmbeddedData(elementData.data, context);
+      return pTestData;
+    });
+  }
+  testSuite.tests = element.tests.map((el) => {
+    if (el instanceof FunctionTest) {
+      return V1_transformFunctionTest(el);
+    }
+    throw new UnsupportedOperationError(
+      'Unsupported function test to transform',
+    );
+  });
+  return testSuite;
+};
+
 export const V1_transformFunction = (
   element: ConcreteFunctionDefinition,
   context: V1_GraphTransformerContext,
@@ -243,5 +297,10 @@ export const V1_transformFunction = (
   _function.returnMultiplicity = V1_transformMultiplicity(
     element.returnMultiplicity,
   );
+  if (element.tests.length) {
+    _function.tests = element.tests.map((suite) =>
+      V1_transformFunctionSuite(suite, context),
+    );
+  }
   return _function;
 };

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementSecondPassBuilder.ts

@@ -50,6 +50,7 @@ import {
   V1_buildVariable,
   V1_buildUnit,
   V1_buildTaggedValue,
+  V1_buildFunctionSuite,
 } from './helpers/V1_DomainBuilderHelper.js';
 import {
   V1_buildServiceExecution,
@@ -322,6 +323,11 @@ export class V1_ElementSecondPassBuilder
     );
     func.expressionSequence = protocol.body;
     func.functionName = getFunctionName(func, func.name);
+    if (protocol.tests?.length) {
+      func.tests = protocol.tests.map((l) =>
+        V1_buildFunctionSuite(l, this.context),
+      );
+    }
   }
 
   visit_FlatData(element: V1_FlatData): void {

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/helpers/V1_DomainBuilderHelper.ts

@@ -58,6 +58,18 @@ import {
 } from '../../../../../../../../graph/helpers/DomainHelper.js';
 import { AggregationKind } from '../../../../../../../../graph/metamodel/pure/packageableElements/domain/AggregationKind.js';
 import { GraphBuilderError } from '../../../../../../../GraphManagerUtils.js';
+import type { V1_FunctionTestSuite } from '../../../../model/packageableElements/function/test/V1_FunctionTestSuite.js';
+import { FunctionTestSuite } from '../../../../../../../../graph/metamodel/pure/packageableElements/function/test/FunctionTestSuite.js';
+import type { V1_FunctionStoreTestData } from '../../../../model/packageableElements/function/test/V1_FunctionStoreTestData.js';
+import { FunctionStoreTestData } from '../../../../../../../../graph/metamodel/pure/packageableElements/function/test/FunctionStoreTestData.js';
+import { V1_buildEmbeddedData } from './V1_DataElementBuilderHelper.js';
+import { V1_FunctionTest } from '../../../../model/packageableElements/function/test/V1_FunctionTest.js';
+import {
+  FunctionParameterValue,
+  FunctionTest,
+} from '../../../../../../../../graph/metamodel/pure/packageableElements/function/test/FunctionTest.js';
+import { V1_buildTestAssertion } from './V1_TestBuilderHelper.js';
+import type { TestSuite } from '../../../../../../../../graph/metamodel/pure/test/Test.js';
 
 export const V1_buildTaggedValue = (
   taggedValue: V1_TaggedValue,
@@ -335,3 +347,59 @@ export const V1_getAppliedProperty = (
     `Property '${name}' not found in class '${parentClass.path}'`,
   );
 };
+
+// Function Suite
+const V1_buildFunctionTest = (
+  element: V1_FunctionTest,
+  parentSuite: TestSuite,
+  context: V1_GraphBuilderContext,
+): FunctionTest => {
+  const functionTest = new FunctionTest();
+  functionTest.id = element.id;
+  functionTest.__parent = parentSuite;
+  functionTest.doc = element.doc;
+  functionTest.assertions = element.assertions.map((assertion) =>
+    V1_buildTestAssertion(assertion, functionTest, context),
+  );
+  functionTest.parameters = element.parameters?.map((param) => {
+    const parameterValue = new FunctionParameterValue();
+    parameterValue.name = param.name;
+    parameterValue.value = param.value;
+    return parameterValue;
+  });
+  return functionTest;
+};
+
+const V1_buildFunctionStoreTestData = (
+  element: V1_FunctionStoreTestData,
+  context: V1_GraphBuilderContext,
+): FunctionStoreTestData => {
+  const storeTestData = new FunctionStoreTestData();
+  storeTestData.doc = element.doc;
+  storeTestData.store = context.resolveStore(element.store);
+  storeTestData.data = V1_buildEmbeddedData(element.data, context);
+  return storeTestData;
+};
+
+export const V1_buildFunctionSuite = (
+  element: V1_FunctionTestSuite,
+  context: V1_GraphBuilderContext,
+): FunctionTestSuite => {
+  const functionSuite = new FunctionTestSuite();
+  functionSuite.id = element.id;
+  functionSuite.doc = element.doc;
+  if (element.testData?.length) {
+    functionSuite.testData = element.testData.map((e) =>
+      V1_buildFunctionStoreTestData(e, context),
+    );
+  }
+  functionSuite.tests = element.tests.map((test) => {
+    if (test instanceof V1_FunctionTest) {
+      return V1_buildFunctionTest(test, functionSuite, context);
+    }
+    throw new UnsupportedOperationError(
+      'Unable to build function test: Unsupported function test type',
+    );
+  });
+  return functionSuite;
+};