Utility to convert type proto to field type (if possible). (#4814)

Author: bgogul

java/arcs/core/data/proto/TypeProtoDecoders.kt

@@ -11,10 +11,11 @@
 
 package arcs.core.data.proto
 
+import arcs.core.data.FieldType
 import arcs.core.data.PrimitiveType
 
 /**
- * Converts a [PrimitiveTypeProto] protobuf instance into a native kotlin [PrimitiveType] instance.
+ * Converts a [PrimitiveTypeProto] protobuf instance into a Kotlin [PrimitiveType] instance.
  */
 fun PrimitiveTypeProto.decode(): PrimitiveType =
     when (this) {
@@ -24,3 +25,25 @@ fun PrimitiveTypeProto.decode(): PrimitiveType =
         PrimitiveTypeProto.UNRECOGNIZED ->
             throw IllegalArgumentException("Unknown PrimitiveTypeProto value.")
     }
+
+/**
+ * Converts a [PrimitiveTypeProto] protobuf instance into a Kotlin [FieldType] instance.
+ */
+fun PrimitiveTypeProto.decodeAsFieldType(): FieldType.Primitive = FieldType.Primitive(decode())
+
+/**
+ * Converts a [TypeProto] protobuf instance into a Kotlin [FieldType] instance.
+ *
+ * @throws [IllegalArgumentexception] if the type cannot be converted to [FieldType].
+ */
+fun TypeProto.decodeAsFieldType(): FieldType =
+    when (getDataCase()) {
+        TypeProto.DataCase.PRIMITIVE -> getPrimitive().decodeAsFieldType()
+        // TODO: Handle FieldType.EntityRef. It is not clear how it is
+        // represented in the proto.
+        TypeProto.DataCase.DATA_NOT_SET ->
+            throw IllegalArgumentException("Unknown data field in TypeProto.")
+        else ->
+            throw IllegalArgumentException(
+                "Cannot decode a ${getDataCase().name} type to a [FieldType].")
+    }

javatests/arcs/core/data/proto/TypeProtoDecodersTest.kt

@@ -1,7 +1,8 @@
 package arcs.core.data.proto
 
-import arcs.core.data.PrimitiveType
+import arcs.core.data.*
 import arcs.core.testutil.assertThrows
+import arcs.core.testutil.fail
 import arcs.repoutils.runfilesDir
 import com.google.common.truth.Truth.assertThat
 import com.google.protobuf.Message.Builder
@@ -12,6 +13,15 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 
+/**
+ * Parses a given proto text as [TypeProto].
+ */
+fun parseTypeProtoText(protoText: String): TypeProto {
+    val builder = TypeProto.newBuilder()
+    TextFormat.getParser().merge(protoText, builder)
+    return builder.build()
+}
+
 @RunWith(JUnit4::class)
 class TypeProtoDecodersTest {
     @Test
@@ -23,4 +33,33 @@ class TypeProtoDecodersTest {
             PrimitiveTypeProto.UNRECOGNIZED.decode()
         }
     }
+
+    @Test
+    fun decodesPrimitiveTypeAsFieldType() {
+        val textField = PrimitiveTypeProto.TEXT.decodeAsFieldType()
+        assertThat(textField.primitiveType).isEqualTo(PrimitiveType.Text)
+        val numberField = PrimitiveTypeProto.NUMBER.decodeAsFieldType()
+        assertThat(numberField.primitiveType).isEqualTo(PrimitiveType.Number)
+        val booleanField = PrimitiveTypeProto.BOOLEAN.decodeAsFieldType()
+        assertThat(booleanField.primitiveType).isEqualTo(PrimitiveType.Boolean)
+    }
+
+    @Test
+    fun decodesTypeProtoAsFieldType() {
+        fun checkPrimitive(textProto: String, expected: PrimitiveType) {
+            val primitiveTypeProto = parseTypeProtoText(textProto)
+            val field = primitiveTypeProto.decodeAsFieldType()
+            when (field) {
+                is FieldType.Primitive ->
+                    assertThat(field.primitiveType).isEqualTo(expected)
+                else -> fail("TypeProto should have been decoded to [FieldType.Primitive].")
+            }
+        }
+        checkPrimitive("primitive: TEXT", PrimitiveType.Text)
+        checkPrimitive("primitive: BOOLEAN", PrimitiveType.Boolean)
+        checkPrimitive("primitive: NUMBER", PrimitiveType.Number)
+        assertThrows(IllegalArgumentException::class) {
+            checkPrimitive("""variable: { name: "Blah"}""", PrimitiveType.Text)
+        }
+    }
 }