From a0aea3777df7228ed3eabdbcd9cb093713440123 Mon Sep 17 00:00:00 2001 From: David Al-Kanani Date: Thu, 30 Jan 2025 09:22:18 +0000 Subject: [PATCH] Story/3511/with meta address and location (#911) * implement setting address and location * add test for setting location on object --- .../function/FunctionGeneratorMetaTest.java | 110 ++++++++++++++++-- .../java/function/FunctionGenerator.xtend | 12 +- 2 files changed, 109 insertions(+), 13 deletions(-) diff --git a/rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/function/FunctionGeneratorMetaTest.java b/rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/function/FunctionGeneratorMetaTest.java index 961e12896..91c1c425b 100644 --- a/rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/function/FunctionGeneratorMetaTest.java +++ b/rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/function/FunctionGeneratorMetaTest.java @@ -28,11 +28,105 @@ public class FunctionGeneratorMetaTest { @Inject CodeGeneratorTestHelper generatorTestHelper; - //TODO:canSetMetaLocationOnFunctionBasicOutput + @Test + void canSetMetaLocationOnFunctionObjectOutput() { + var model = """ + metaType location string + + type Foo: + field string (1..1) + + func MyFunc: + output: + result Foo (1..1) + [metadata location] + set result -> field: "someValue" + set result -> location: "someAddress" + """; + + var code = generatorTestHelper.generateCode(model); + + var classes = generatorTestHelper.compileToClasses(code); + var myFunc = functionGeneratorHelper.createFunc(classes, "MyFunc"); + + var result = functionGeneratorHelper.invokeFunc(myFunc, FieldWithMeta.class); + + var expected = generatorTestHelper.createInstanceUsingBuilder(classes, new RosettaJavaPackages.RootPackage("com.rosetta.test.model.metafields"), "FieldWithMetaFoo", Map.of( + "value", generatorTestHelper.createInstanceUsingBuilder(classes, new RosettaJavaPackages.RootPackage("com.rosetta.test.model"), "Foo", Map.of( + "field", "someValue" + )), + "meta", MetaFields.builder().setLocation("someAddress") + )); + + assertEquals(expected, result); + } + + @Test + void canSetMetaLocationOnFunctionBasicOutput() { + var model = """ + metaType location string + + func MyFunc: + output: + result string (1..1) + [metadata location] + set result: "someValue" + set result -> location: "someAddress" + """; + + var code = generatorTestHelper.generateCode(model); + + var classes = generatorTestHelper.compileToClasses(code); + var myFunc = functionGeneratorHelper.createFunc(classes, "MyFunc"); + + var result = functionGeneratorHelper.invokeFunc(myFunc, FieldWithMeta.class); + + var expected = generatorTestHelper.createInstanceUsingBuilder(classes, new RosettaJavaPackages.RootPackage("com.rosetta.model.metafields"), "FieldWithMetaString", Map.of( + "value", "someValue", + "meta", MetaFields.builder().setLocation("someAddress") + )); + + assertEquals(expected, result); + } + @Test + void canSetMetaAddressOnFunctionObjectOutput() { + var model = """ + metaType address string + + type Foo: + field string (1..1) + + func MyFunc: + output: + result Foo (1..1) + [metadata address] + set result -> field: "someValue" + set result -> address: "someLocation" + """; + + var code = generatorTestHelper.generateCode(model); + + generatorTestHelper.writeClasses(code, "canSetMetaAddressOnFunctionObjectOutput"); + + var classes = generatorTestHelper.compileToClasses(code); + + var myFunc = functionGeneratorHelper.createFunc(classes, "MyFunc"); + + var result = functionGeneratorHelper.invokeFunc(myFunc, FieldWithMeta.class); + + var expected = generatorTestHelper.createInstanceUsingBuilder(classes, new RosettaJavaPackages.RootPackage("com.rosetta.test.model.metafields"), "ReferenceWithMetaFoo", Map.of( + "value", generatorTestHelper.createInstanceUsingBuilder(classes, new RosettaJavaPackages.RootPackage("com.rosetta.test.model"), "Foo", Map.of( + "field", "someValue" + )), + "reference", Reference.builder().setReference("someLocation") + )); + + assertEquals(expected, result); + } @Test - void canSetMetaAddressOnFunctionBasicOutput() { + void canSetAddressOnFunctionBasicOutput() { var model = """ metaType address string @@ -45,7 +139,7 @@ result string (1..1) """; var code = generatorTestHelper.generateCode(model); - + var classes = generatorTestHelper.compileToClasses(code); @@ -63,7 +157,7 @@ result string (1..1) @Test - void canSetExternalIdOnFunctionObjectOutput() { + void canSetExternalIdOnFunctionBasicOutput() { var model = """ metaType id string @@ -139,7 +233,7 @@ result Foo (1..1) """; var code = generatorTestHelper.generateCode(model); - + var classes = generatorTestHelper.compileToClasses(code); var myFunc = functionGeneratorHelper.createFunc(classes, "MyFunc"); @@ -154,7 +248,7 @@ result Foo (1..1) @Disabled //TODO: implement setting nested meta @Test - void canSetMetaOnFunctionObjectOutputAndNestedMetaField() { + void canSetMetaOnFunctionObjectOutputAndNestedBasicMetaField() { var model = """ type Foo: a string (1..1) @@ -192,7 +286,7 @@ result Foo (1..1) } @Test - void canSetMetaSchemeOnFunctionObjectOutput() { + void canSetSchemeOnFunctionObjectOutput() { var model = """ type Foo: a string (1..1) @@ -225,7 +319,7 @@ result Foo (1..1) } @Test - void canSetMetaSchemeOnFunctionBasicOutput() { + void canSetSchemeOnFunctionBasicOutput() { var model = """ func MyFunc: output: diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/function/FunctionGenerator.xtend b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/function/FunctionGenerator.xtend index 87df8fdc8..6fd904bde 100644 --- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/function/FunctionGenerator.xtend +++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/function/FunctionGenerator.xtend @@ -486,7 +486,7 @@ class FunctionGenerator { expr = JavaExpression.from( ''' «oldExpr» - «generateMetaWrapperCreator(prop, outputExpressionType)».«IF op.ROperationType == ROperationType.ADD»add«ELSE»set«ENDIF»«seg.toPojoPropertyNames.toFirstUpper»(«it»)''', + «generateMetaWrapperCreator(seg, prop, outputExpressionType)».«IF op.ROperationType == ROperationType.ADD»add«ELSE»set«ENDIF»«seg.toPojoPropertyNames.toFirstUpper»(«it»)''', JavaPrimitiveType.VOID ) } else { @@ -503,10 +503,12 @@ class FunctionGenerator { } } - private def StringConcatenationClient generateMetaWrapperCreator(JavaPojoProperty prop, RJavaWithMetaValue outputExpressionType) { + private def StringConcatenationClient generateMetaWrapperCreator(RFeature seg, JavaPojoProperty prop, RJavaWithMetaValue outputExpressionType) { switch (outputExpressionType) { - RJavaFieldWithMeta: '''.«prop.getOrCreateName»()''' - RJavaReferenceWithMeta: '''«IF prop.name === "reference"».«prop.getOrCreateName»()«ENDIF»''' + RJavaFieldWithMeta: '''«IF seg instanceof RMetaAttribute».getOrCreateMeta()«ELSE».«prop.getOrCreateName»()«ENDIF»''' + RJavaReferenceWithMeta case seg instanceof RMetaAttribute && seg.name == "address": '''.«prop.getOrCreateName»()''' + RJavaReferenceWithMeta case !(seg instanceof RMetaAttribute): '''.getOrCreateValue()''' + default: '''''' } } @@ -515,7 +517,7 @@ class FunctionGenerator { if (seg instanceof RMetaAttribute && outputExpressionType.itemType instanceof RJavaFieldWithMeta) { (outputExpressionType as JavaPojoInterface).findProperty("meta") } else if (seg instanceof RMetaAttribute && outputExpressionType.itemType instanceof RJavaReferenceWithMeta) { - (outputExpressionType as JavaPojoInterface).findProperty(toPojoPropertyNames(seg)) + (outputExpressionType as JavaPojoInterface).findProperty("reference") } else if (outputExpressionType.itemType instanceof RJavaWithMetaValue) { (outputExpressionType as JavaPojoInterface).findProperty("value") } else {