Delegate byte[] to gson as well for parsing and writing

Author: papegaaij

components/serialization/json/src/main/java/com/microsoft/kiota/serialization/DefaultGsonBuilder.java

@@ -15,6 +15,7 @@
 import java.time.OffsetDateTime;
 import java.time.ZoneOffset;
 import java.time.format.DateTimeParseException;
+import java.util.Base64;
 
 public class DefaultGsonBuilder {
 
@@ -116,6 +117,32 @@ public void write(JsonWriter out, PeriodAndDuration value) throws IOException {
                 }
             };
 
+    private static final TypeAdapter<byte[]> BYTE_ARRAY =
+            new TypeAdapter<>() {
+                @Override
+                public byte[] read(JsonReader in) throws IOException {
+                    String stringValue = in.nextString();
+                    try {
+                        if (stringValue.isEmpty()) {
+                            return null;
+                        }
+                        return Base64.getDecoder().decode(stringValue);
+                    } catch (IllegalArgumentException ex) {
+                        throw new JsonSyntaxException(
+                                "Failed parsing '"
+                                        + stringValue
+                                        + "' as byte[]; at path "
+                                        + in.getPreviousPath(),
+                                ex);
+                    }
+                }
+
+                @Override
+                public void write(JsonWriter out, byte[] value) throws IOException {
+                    out.value(Base64.getEncoder().encodeToString(value));
+                }
+            };
+
     private static final Gson defaultInstance = getDefaultBuilder().create();
 
     public static Gson getDefaultInstance() {
@@ -127,6 +154,7 @@ public static GsonBuilder getDefaultBuilder() {
                 .registerTypeAdapter(OffsetDateTime.class, OFFSET_DATE_TIME.nullSafe())
                 .registerTypeAdapter(LocalDate.class, LOCAL_DATE.nullSafe())
                 .registerTypeAdapter(LocalTime.class, LOCAL_TIME.nullSafe())
-                .registerTypeAdapter(PeriodAndDuration.class, PERIOD_AND_DURATION.nullSafe());
+                .registerTypeAdapter(PeriodAndDuration.class, PERIOD_AND_DURATION.nullSafe())
+                .registerTypeAdapter(byte[].class, BYTE_ARRAY.nullSafe());
     }
 }

components/serialization/json/src/main/java/com/microsoft/kiota/serialization/JsonParseNode.java

@@ -15,7 +15,6 @@
 import java.time.LocalTime;
 import java.time.OffsetDateTime;
 import java.util.ArrayList;
-import java.util.Base64;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -312,10 +311,6 @@ public void setOnAfterAssignFieldValues(@Nullable final Consumer<Parsable> value
     }
 
     @Nullable public byte[] getByteArrayValue() {
-        final String base64 = this.getStringValue();
-        if (base64 == null || base64.isEmpty()) {
-            return null;
-        }
-        return Base64.getDecoder().decode(base64);
+        return gson.fromJson(currentNode, byte[].class);
     }
 }

components/serialization/json/src/main/java/com/microsoft/kiota/serialization/JsonSerializationWriter.java

@@ -18,7 +18,6 @@
 import java.time.LocalDate;
 import java.time.LocalTime;
 import java.time.OffsetDateTime;
-import java.util.Base64;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.Map;
@@ -540,6 +539,14 @@ public void setOnStartObjectSerialization(
     }
 
     public void writeByteArrayValue(@Nullable final String key, @Nullable final byte[] value) {
-        if (value != null) this.writeStringValue(key, Base64.getEncoder().encodeToString(value));
+        if (value != null)
+            try {
+                if (key != null && !key.isEmpty()) {
+                    writer.name(key);
+                }
+                gson.getAdapter(byte[].class).write(writer, value);
+            } catch (IOException ex) {
+                throw new RuntimeException("could not serialize value", ex);
+            }
     }
 }

components/serialization/json/src/test/java/com/microsoft/kiota/serialization/JsonSerializationWriterTests.java

@@ -1,5 +1,6 @@
 package com.microsoft.kiota.serialization;
 
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
@@ -268,6 +269,10 @@ void parseWrittenValues() throws IOException {
                 ParseNode::getPeriodAndDurationValue,
                 SerializationWriter::writePeriodAndDurationValue,
                 PeriodAndDuration.of(Period.ofYears(3), Duration.ofHours(6)));
+        writeAndParse(
+                ParseNode::getByteArrayValue,
+                SerializationWriter::writeByteArrayValue,
+                new byte[] {8, 10, 127, -50, 0});
     }
 
     private <T> void writeAndParse(
@@ -283,7 +288,11 @@ private <T> void writeAndParse(
         var parseNode =
                 parseNodeFactory.getParseNode("application/json", writer.getSerializedContent());
         var result = parseNode.getObjectValue(TestParsable.factory(parseMethod, writeMethod));
-        assertEquals(value, result.getRealValue());
+        if (value instanceof byte[] bytea) {
+            assertArrayEquals(bytea, (byte[]) result.getRealValue());
+        } else {
+            assertEquals(value, result.getRealValue());
+        }
         assertNull(result.getNullValue());
         writer.close();
     }