getsentry · denrase · Aug 26, 2021 · Aug 5, 2021 · Aug 5, 2021 · Aug 5, 2021
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
@@ -1765,18 +1765,34 @@ public final class io/sentry/protocol/SentryPackage : io/sentry/IUnknownProperti
 	public fun setVersion (Ljava/lang/String;)V
 }
 
-public final class io/sentry/protocol/SentryRuntime : io/sentry/IUnknownPropertiesConsumer {
+public final class io/sentry/protocol/SentryRuntime : io/sentry/IUnknownPropertiesConsumer, io/sentry/JsonSerializable, io/sentry/JsonUnknown {
 	public static final field TYPE Ljava/lang/String;
 	public fun <init> ()V
 	public fun acceptUnknownProperties (Ljava/util/Map;)V
 	public fun getName ()Ljava/lang/String;
 	public fun getRawDescription ()Ljava/lang/String;
+	public fun getUnknown ()Ljava/util/Map;
 	public fun getVersion ()Ljava/lang/String;
+	public fun serialize (Lio/sentry/JsonObjectWriter;Lio/sentry/ILogger;)V
 	public fun setName (Ljava/lang/String;)V
 	public fun setRawDescription (Ljava/lang/String;)V
+	public fun setUnknown (Ljava/util/Map;)V
 	public fun setVersion (Ljava/lang/String;)V
 }
 
+public final class io/sentry/protocol/SentryRuntime$Deserializer : io/sentry/JsonDeserializer {
+	public fun <init> ()V
+	public fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Lio/sentry/protocol/SentryRuntime;
+	public synthetic fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Ljava/lang/Object;
+}
+
+public final class io/sentry/protocol/SentryRuntime$JsonKeys {
+	public static final field NAME Ljava/lang/String;
+	public static final field RAW_DESCRIPTION Ljava/lang/String;
+	public static final field VERSION Ljava/lang/String;
+	public fun <init> ()V
+}
+
 public final class io/sentry/protocol/SentrySpan {
 	public fun <init> (Lio/sentry/Span;)V
 	public fun <init> (Lio/sentry/Span;Ljava/util/Map;)V

diff --git a/sentry/src/main/java/io/sentry/protocol/SentryRuntime.java b/sentry/src/main/java/io/sentry/protocol/SentryRuntime.java
@@ -1,15 +1,22 @@
 package io.sentry.protocol;
 
+import io.sentry.ILogger;
 import io.sentry.IUnknownPropertiesConsumer;
+import io.sentry.JsonDeserializer;
+import io.sentry.JsonObjectReader;
+import io.sentry.JsonObjectWriter;
+import io.sentry.JsonSerializable;
+import io.sentry.JsonUnknown;
 import io.sentry.util.CollectionUtils;
+import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.TestOnly;
 
-public final class SentryRuntime implements IUnknownPropertiesConsumer {
+public final class SentryRuntime
+    implements IUnknownPropertiesConsumer, JsonUnknown, JsonSerializable {
   public static final String TYPE = "runtime";
 
   /** Runtime name. */
@@ -61,15 +68,86 @@ public void setRawDescription(final @Nullable String rawDescription) {
     this.rawDescription = rawDescription;
   }
 
-  @TestOnly
+  @ApiStatus.Internal
+  @Override
+  public void acceptUnknownProperties(final @NotNull Map<String, Object> unknown) {
+    this.unknown = new ConcurrentHashMap<>(unknown);
+  }
+
+  // region JsonSerializable
+
+  public static final class JsonKeys {
+    public static final String NAME = "name";
+    public static final String VERSION = "version";
+    public static final String RAW_DESCRIPTION = "raw_description";
+  }
+
+  @Override
+  public void serialize(@NotNull JsonObjectWriter writer, @NotNull ILogger logger)
+      throws IOException {
+    writer.beginObject();
+    if (name != null) {
+      writer.name(JsonKeys.NAME).value(name);
+    }
+    if (version != null) {
+      writer.name(JsonKeys.VERSION).value(version);
+    }
+    if (rawDescription != null) {
+      writer.name(JsonKeys.RAW_DESCRIPTION).value(rawDescription);
+    }
+    if (unknown != null) {
+      for (String key : unknown.keySet()) {
+        Object value = unknown.get(key);
+        writer.name(key);
+        writer.value(logger, value);
+      }
+    }
+    writer.endObject();
+  }
+
   @Nullable
-  Map<String, Object> getUnknown() {
+  @Override
+  public Map<String, Object> getUnknown() {
     return unknown;
   }
 
-  @ApiStatus.Internal
   @Override
-  public void acceptUnknownProperties(final @NotNull Map<String, Object> unknown) {
-    this.unknown = new ConcurrentHashMap<>(unknown);
+  public void setUnknown(@Nullable Map<String, Object> unknown) {
+    this.unknown = unknown;
+  }
+
+  public static final class Deserializer implements JsonDeserializer<SentryRuntime> {
+    @Override
+    public @NotNull SentryRuntime deserialize(
+        @NotNull JsonObjectReader reader, @NotNull ILogger logger) throws Exception {
+      reader.beginObject();
+      SentryRuntime runtime = new SentryRuntime();
+      Map<String, Object> unknown = null;
+      do {
+        final String nextName = reader.nextName();
+        switch (nextName) {
+          case JsonKeys.NAME:
+            runtime.name = reader.nextStringOrNull();
+            break;
+          case JsonKeys.VERSION:
+            runtime.version = reader.nextStringOrNull();
+            break;
+          case JsonKeys.RAW_DESCRIPTION:
+            runtime.rawDescription = reader.nextStringOrNull();
+            break;
+          default:
+            if (unknown == null) {
+              unknown = new ConcurrentHashMap<>();
+            }
+            reader.nextUnknown(logger, unknown, nextName);
+            break;
+        }
+      } while (reader.hasNext());
+      runtime.setUnknown(unknown);
+      reader.endObject();
+      return runtime;
+    }
   }
+
+  // endregion
 }
diff --git a/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt b/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt
@@ -6,6 +6,7 @@ import io.sentry.protocol.App
 import io.sentry.protocol.Browser
 import io.sentry.protocol.OperatingSystem
 import io.sentry.protocol.SentryId
+import io.sentry.protocol.SentryRuntime
 import java.io.StringReader
 import java.io.StringWriter
 import kotlin.test.assertEquals
@@ -35,6 +36,10 @@ class JsonUnknownSerializationTest {
             return givenJsonUnknown(OperatingSystem())
         }
 
+        fun getSentryRuntime(): SentryRuntime {
+            return givenJsonUnknown(SentryRuntime())
+        }
+
         private fun <T : JsonUnknown> givenJsonUnknown(jsonUnknown: T): T {
             return jsonUnknown.apply {
                 unknown = mapOf(
@@ -83,7 +88,6 @@ class JsonUnknownSerializationTest {
     }
 
     @Test
-
     fun `serializing unknown calls json object writer for app`() {
         val writer: JsonObjectWriter = mock()
         val logger: ILogger = mock()
@@ -143,6 +147,30 @@ class JsonUnknownSerializationTest {
         verify(writer).value(logger, "fixture-value")
     }
 
+    // SentryRuntime
+
+    @Test
+    fun `serializing and deserialize sentry runtime`() {
+        val sut = fixture.getSentryRuntime()
+
+        val serialized = serialize(sut)
+        val deserialized = deserialize(serialized, SentryRuntime.Deserializer())
+
+        assertEquals(sut.unknown, deserialized.unknown)
+    }
+
+    @Test
+    fun `serializing unknown calls json object writer for sentry runtime`() {
+        val writer: JsonObjectWriter = mock()
+        val logger: ILogger = mock()
+        val sut = fixture.getUserFeedback()
+
+        sut.serialize(writer, logger)
+
+        verify(writer).name("fixture-key")
+        verify(writer).value(logger, "fixture-value")
+    }
+
     // Helper
 
     private fun serialize(jsonSerializable: JsonSerializable): String {

diff --git a/sentry/src/test/java/io/sentry/protocol/SentryRuntimeSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/SentryRuntimeSerializationTest.kt
@@ -0,0 +1,65 @@
+package io.sentry.protocol
+
+import com.nhaarman.mockitokotlin2.mock
+import io.sentry.FileFromResources
+import io.sentry.ILogger
+import io.sentry.JsonObjectReader
+import io.sentry.JsonObjectWriter
+import io.sentry.JsonSerializable
+import java.io.StringReader
+import java.io.StringWriter
+import kotlin.test.assertEquals
+import org.junit.Test
+
+class SentryRuntimeSerializationTest {
+
+    private class Fixture {
+        var logger: ILogger = mock()
+
+        fun getSut() = SentryRuntime().apply {
+            name = "4ed019c4-9af9-43e0-830e-bfde9fe4461c"
+            version = "16534f6b-1670-4bb8-aec2-647a1b97669b"
+            rawDescription = "773b5b05-a0f9-4ee6-9f3b-13155c37ad6e"
+        }
+    }
+    private val fixture = Fixture()
+
+    @Test
+    fun serialize() {
+        val expected = sanitizedFile("gson/sentry_runtime.json")
+        val actual = serializeToString(fixture.getSut())
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun deserialize() {
+        val expectedJson = sanitizedFile("gson/sentry_runtime.json")
+        val actual = deserialize(expectedJson)
+        val actualJson = serializeToString(actual)
+        assertEquals(expectedJson, actualJson)
+    }
+
+    // Helper
+
+    private fun sanitizedFile(path: String): String {
+        return FileFromResources.invoke(path)
+            .replace(Regex("[\n\r]"), "")
+            .replace(" ", "")
+    }
+
+    private fun serializeToString(jsonSerializable: JsonSerializable): String {
+        return this.serializeToString { wrt -> jsonSerializable.serialize(wrt, fixture.logger) }
+    }
+
+    private fun serializeToString(serialize: (JsonObjectWriter) -> Unit): String {
+        val wrt = StringWriter()
+        val jsonWrt = JsonObjectWriter(wrt)
+        serialize(jsonWrt)
+        return wrt.toString()
+    }
+
+    private fun deserialize(json: String): SentryRuntime {
+        val reader = JsonObjectReader(StringReader(json))
+        return SentryRuntime.Deserializer().deserialize(reader, fixture.logger)
+    }
+}
diff --git a/sentry/src/test/resources/gson/sentry_runtime.json b/sentry/src/test/resources/gson/sentry_runtime.json
@@ -0,0 +1,5 @@
+{
+    "name": "4ed019c4-9af9-43e0-830e-bfde9fe4461c",
+    "version": "16534f6b-1670-4bb8-aec2-647a1b97669b",
+    "raw_description": "773b5b05-a0f9-4ee6-9f3b-13155c37ad6e"
+}