update test

HHS · Feb 11, 2025 · 2c36596 · 2c36596
1 parent 5ed4854
commit 2c36596
Show file tree

Hide file tree

Showing 2 changed files with 164 additions and 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
@@ -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
@@ -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);
     }
 }