From 2c36596d9994374353f615672279a3fcda3ced94 Mon Sep 17 00:00:00 2001 From: bischoffz Date: Mon, 10 Feb 2025 22:40:39 -0500 Subject: [PATCH] update test --- .../protobuf/engine/TaskitObjectHelper.java | 20 +- .../engine/AT_TaskitObjectHelper.java | 190 ++++++++++++++---- 2 files changed, 164 insertions(+), 46 deletions(-) diff --git a/protobuf/src/main/java/gov/hhs/aspr/ms/taskit/protobuf/engine/TaskitObjectHelper.java b/protobuf/src/main/java/gov/hhs/aspr/ms/taskit/protobuf/engine/TaskitObjectHelper.java index c3886f2..8c2229d 100644 --- a/protobuf/src/main/java/gov/hhs/aspr/ms/taskit/protobuf/engine/TaskitObjectHelper.java +++ b/protobuf/src/main/java/gov/hhs/aspr/ms/taskit/protobuf/engine/TaskitObjectHelper.java @@ -68,45 +68,45 @@ public static TaskitObjectInput getTaskitObjectInput(Object value, ProtobufTaski case "LocalDate": return getDateTaskitInput((Date) taskitEngine.translateObject(value)); case "Enum": - return getEnumTaskitInput(taskitEngine.translateObjectAsClassSafe(Enum.class.cast(value), Enum.class)); + return getEnumTaskitInput(taskitEngine.translateObjectAsClassSafe(Enum.class.cast(value), Enum.class)); default: return getAnyTaskitInput(taskitEngine.getAnyFromObject(value)); } } - public static TaskitObjectInput getIntegerTaskitInput(Integer value) { + static TaskitObjectInput getIntegerTaskitInput(Integer value) { return TaskitObjectInput.newBuilder().setI32Val(value).build(); } - public static TaskitObjectInput getAnyTaskitInput(Any value) { + static TaskitObjectInput getAnyTaskitInput(Any value) { return TaskitObjectInput.newBuilder().setMVal(value).build(); } - public static TaskitObjectInput getLongTaskitInput(Long value) { + static TaskitObjectInput getLongTaskitInput(Long value) { return TaskitObjectInput.newBuilder().setI64Val(value).build(); } - public static TaskitObjectInput getFloatTaskitInput(Float value) { + static TaskitObjectInput getFloatTaskitInput(Float value) { return TaskitObjectInput.newBuilder().setFVal(value).build(); } - public static TaskitObjectInput getDoubleTaskitInput(Double value) { + static TaskitObjectInput getDoubleTaskitInput(Double value) { return TaskitObjectInput.newBuilder().setDVal(value).build(); } - public static TaskitObjectInput getDateTaskitInput(Date value) { + static TaskitObjectInput getDateTaskitInput(Date value) { return TaskitObjectInput.newBuilder().setDateVal(value).build(); } - public static TaskitObjectInput getStringTaskitInput(String value) { + static TaskitObjectInput getStringTaskitInput(String value) { return TaskitObjectInput.newBuilder().setSVal(value).build(); } - public static TaskitObjectInput getEnumTaskitInput(WrapperEnumValue value) { + static TaskitObjectInput getEnumTaskitInput(WrapperEnumValue value) { return TaskitObjectInput.newBuilder().setEnumVal(value).build(); } - public static TaskitObjectInput getBooleanTaskitInput(Boolean value) { + static TaskitObjectInput getBooleanTaskitInput(Boolean value) { return TaskitObjectInput.newBuilder().setBVal(value).build(); } } diff --git a/protobuf/src/test/java/gov/hhs/aspr/ms/taskit/protobuf/engine/AT_TaskitObjectHelper.java b/protobuf/src/test/java/gov/hhs/aspr/ms/taskit/protobuf/engine/AT_TaskitObjectHelper.java index db59fb6..e76a53f 100644 --- a/protobuf/src/test/java/gov/hhs/aspr/ms/taskit/protobuf/engine/AT_TaskitObjectHelper.java +++ b/protobuf/src/test/java/gov/hhs/aspr/ms/taskit/protobuf/engine/AT_TaskitObjectHelper.java @@ -1,75 +1,193 @@ package gov.hhs.aspr.ms.taskit.protobuf.engine; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.time.LocalDate; + import org.junit.jupiter.api.Test; import com.google.protobuf.Any; import com.google.type.Date; +import gov.hhs.aspr.ms.taskit.protobuf.testsupport.TestObjectUtil; +import gov.hhs.aspr.ms.taskit.core.testsupport.objects.TestAppEnum; +import gov.hhs.aspr.ms.taskit.core.testsupport.objects.TestAppObject; import gov.hhs.aspr.ms.taskit.protobuf.objects.TaskitObjectInput; import gov.hhs.aspr.ms.taskit.protobuf.objects.WrapperEnumValue; -import gov.hhs.aspr.ms.util.annotations.UnitTag; +import gov.hhs.aspr.ms.taskit.protobuf.testsupport.translation.specs.TestProtobufComplexObjectTranslationSpec; +import gov.hhs.aspr.ms.taskit.protobuf.testsupport.translation.specs.TestProtobufEnumTranslationSpec; +import gov.hhs.aspr.ms.taskit.protobuf.testsupport.translation.specs.TestProtobufObjectTranslationSpec; import gov.hhs.aspr.ms.util.annotations.UnitTestMethod; +import gov.hhs.aspr.ms.util.errors.ContractException; public class AT_TaskitObjectHelper { @Test @UnitTestMethod(target = TaskitObjectHelper.class, name = "getValue", args = { - TaskitObjectInput.class }, tags = UnitTag.INCOMPLETE) + TaskitObjectInput.class }) public void testHasObjectVal() { + Boolean expectedBoolean = false; + TaskitObjectInput input = TaskitObjectInput.newBuilder().setBVal(expectedBoolean).build(); - } + Object actualObject = TaskitObjectHelper.getValue(input); - @Test - @UnitTestMethod(target = TaskitObjectHelper.class, name = "getIntegerTaskitInput", args = { Integer.class }, tags = UnitTag.INCOMPLETE) - public void testGetObjectVal() { + assertEquals(expectedBoolean, actualObject); - } + Date expectedDate = Date.getDefaultInstance(); + input = TaskitObjectInput.newBuilder().setDateVal(expectedDate).build(); - @Test - @UnitTestMethod(target = TaskitObjectHelper.class, name = "getAnyTaskitInput", args = { Any.class }, tags = UnitTag.INCOMPLETE) - public void testGetIntVal() { + actualObject = TaskitObjectHelper.getValue(input); - } + assertEquals(expectedDate, actualObject); - @Test - @UnitTestMethod(target = TaskitObjectHelper.class, name = "getLongTaskitInput", args = { Long.class }, tags = UnitTag.INCOMPLETE) - public void testGetDoubleVal() { + Double expectedDouble = 0.0; + input = TaskitObjectInput.newBuilder().setDVal(expectedDouble).build(); - } + actualObject = TaskitObjectHelper.getValue(input); - @Test - @UnitTestMethod(target = TaskitObjectHelper.class, name = "getFloatTaskitInput", args = { Float.class }, tags = UnitTag.INCOMPLETE) - public void testGetBooleanVal() { + assertEquals(expectedDouble, actualObject); - } + WrapperEnumValue expectedEnum = WrapperEnumValue.getDefaultInstance(); + input = TaskitObjectInput.newBuilder().setEnumVal(expectedEnum).build(); - @Test - @UnitTestMethod(target = TaskitObjectHelper.class, name = "getDoubleTaskitInput", args = { Double.class }, tags = UnitTag.INCOMPLETE) - public void testGetFloatVal() { + actualObject = TaskitObjectHelper.getValue(input); - } + assertEquals(expectedEnum, actualObject); - @Test - @UnitTestMethod(target = TaskitObjectHelper.class, name = "getDateTaskitInput", args = { Date.class }, tags = UnitTag.INCOMPLETE) - public void testGetLongVal() { + Float expectedFloat = 0.0f; + input = TaskitObjectInput.newBuilder().setFVal(expectedFloat).build(); - } + actualObject = TaskitObjectHelper.getValue(input); - @Test - @UnitTestMethod(target = TaskitObjectHelper.class, name = "getStringTaskitInput", args = { String.class }, tags = UnitTag.INCOMPLETE) - public void testGetStringVal() { + assertEquals(expectedFloat, actualObject); - } + Integer expectedInt = 0; + input = TaskitObjectInput.newBuilder().setI32Val(expectedInt).build(); - @Test - @UnitTestMethod(target = TaskitObjectHelper.class, name = "getEnumTaskitInput", args = { WrapperEnumValue.class }, tags = UnitTag.INCOMPLETE) - public void testGetDateVal() { + actualObject = TaskitObjectHelper.getValue(input); + + assertEquals(expectedInt, actualObject); + + Long expectedLong = 0L; + input = TaskitObjectInput.newBuilder().setI64Val(expectedLong).build(); + + actualObject = TaskitObjectHelper.getValue(input); + + assertEquals(expectedLong, actualObject); + + Any expectedAny = Any.pack(WrapperEnumValue.getDefaultInstance()); + input = TaskitObjectInput.newBuilder().setMVal(expectedAny).build(); + + actualObject = TaskitObjectHelper.getValue(input); + + assertEquals(expectedAny, actualObject); + + String expectedString = ""; + input = TaskitObjectInput.newBuilder().setSVal(expectedString).build(); + + actualObject = TaskitObjectHelper.getValue(input); + + assertEquals(expectedString, actualObject); + // preconditions: + // value was not set + ContractException contractException = assertThrows(ContractException.class, () -> { + TaskitObjectHelper.getValue(TaskitObjectInput.newBuilder().build()); + }); + + assertEquals(ProtobufTaskitError.INVALID_RETRIEVAL, contractException.getErrorType()); } @Test - @UnitTestMethod(target = TaskitObjectHelper.class, name = "getBooleanTaskitInput", args = { Boolean.class }, tags = UnitTag.INCOMPLETE) - public void testGetEnumVal() { + @UnitTestMethod(target = TaskitObjectHelper.class, name = "getTaskitObjectInput", args = { Object.class, + ProtobufTaskitEngine.class }) + public void testGetTaskitObjectInput() { + + ProtobufTaskitEngine taskitEngine = ProtobufJsonTaskitEngine.builder() + .addTranslationSpec(new TestProtobufComplexObjectTranslationSpec()) + .addTranslationSpec(new TestProtobufEnumTranslationSpec()) + .addTranslationSpec(new TestProtobufObjectTranslationSpec()) + .build(); + + Boolean expectedBoolean = false; + TaskitObjectInput expectedInput = TaskitObjectInput.newBuilder().setBVal(expectedBoolean).build(); + TaskitObjectInput actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedBoolean, taskitEngine); + + assertEquals(expectedInput, actualInput); + + boolean expectedBoolean2 = false; + expectedInput = TaskitObjectInput.newBuilder().setBVal(expectedBoolean2).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedBoolean2, taskitEngine); + + assertEquals(expectedInput, actualInput); + + LocalDate date = LocalDate.now(); + Date expectedDate = taskitEngine.translateObject(date); + expectedInput = TaskitObjectInput.newBuilder().setDateVal(expectedDate).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(date, taskitEngine); + + assertEquals(expectedInput, actualInput); + + Double expectedDouble = 0.0; + expectedInput = TaskitObjectInput.newBuilder().setDVal(expectedDouble).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedDouble, taskitEngine); + + assertEquals(expectedInput, actualInput); + + WrapperEnumValue expectedEnum = taskitEngine.translateObjectAsClassSafe(TestAppEnum.TEST1, Enum.class); + expectedInput = TaskitObjectInput.newBuilder().setEnumVal(expectedEnum).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(TestAppEnum.TEST1, taskitEngine); + + assertEquals(expectedInput, actualInput); + + Float expectedFloat = 0.0f; + expectedInput = TaskitObjectInput.newBuilder().setFVal(expectedFloat).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedFloat, taskitEngine); + + assertEquals(expectedInput, actualInput); + + float expectedFloat2 = 0.0f; + expectedInput = TaskitObjectInput.newBuilder().setFVal(expectedFloat2).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedFloat2, taskitEngine); + + assertEquals(expectedInput, actualInput); + + Integer expectedInt = 0; + expectedInput = TaskitObjectInput.newBuilder().setI32Val(expectedInt).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedInt, taskitEngine); + + assertEquals(expectedInput, actualInput); + + int expectedInt2 = 0; + expectedInput = TaskitObjectInput.newBuilder().setI32Val(expectedInt2).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedInt2, taskitEngine); + + assertEquals(expectedInput, actualInput); + + Long expectedLong = 0L; + expectedInput = TaskitObjectInput.newBuilder().setI64Val(expectedLong).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedLong, taskitEngine); + + assertEquals(expectedInput, actualInput); + + long expectedLong2 = 0L; + expectedInput = TaskitObjectInput.newBuilder().setI64Val(expectedLong2).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedLong2, taskitEngine); + + assertEquals(expectedInput, actualInput); + + TestAppObject obj = TestObjectUtil.generateTestAppObject(); + Any expectedAny = taskitEngine.getAnyFromObject(obj); + expectedInput = TaskitObjectInput.newBuilder().setMVal(expectedAny).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(obj, taskitEngine); + + assertEquals(expectedInput, actualInput); + + String expectedString = ""; + expectedInput = TaskitObjectInput.newBuilder().setSVal(expectedString).build(); + actualInput = TaskitObjectHelper.getTaskitObjectInput(expectedString, taskitEngine); + assertEquals(expectedInput, actualInput); } }