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
@@ -1432,16 +1432,31 @@ public final class io/sentry/protocol/App$JsonKeys {
 	public fun <init> ()V
 }
 
-public final class io/sentry/protocol/Browser : io/sentry/IUnknownPropertiesConsumer {
+public final class io/sentry/protocol/Browser : 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 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 setUnknown (Ljava/util/Map;)V
 	public fun setVersion (Ljava/lang/String;)V
 }
 
+public final class io/sentry/protocol/Browser$Deserializer : io/sentry/JsonDeserializer {
+	public fun <init> ()V
+	public fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Lio/sentry/protocol/Browser;
+	public synthetic fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Ljava/lang/Object;
+}
+
+public final class io/sentry/protocol/Browser$JsonKeys {
+	public static final field NAME Ljava/lang/String;
+	public static final field VERSION Ljava/lang/String;
+	public fun <init> ()V
+}
+
 public final class io/sentry/protocol/Contexts : java/util/concurrent/ConcurrentHashMap {
 	public fun <init> ()V
 	public fun <init> (Lio/sentry/protocol/Contexts;)V

diff --git a/sentry/src/main/java/io/sentry/protocol/Browser.java b/sentry/src/main/java/io/sentry/protocol/Browser.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 io.sentry.vendor.gson.stream.JsonToken;
+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 Browser implements IUnknownPropertiesConsumer {
+public final class Browser implements IUnknownPropertiesConsumer, JsonUnknown, JsonSerializable {
   public static final String TYPE = "browser";
   /** Display name of the browser application. */
   private @Nullable String name;
@@ -43,15 +50,79 @@ public void setVersion(final @Nullable String version) {
     this.version = version;
   }
 
-  @TestOnly
+  @ApiStatus.Internal
+  @Override
+  public void acceptUnknownProperties(final @NotNull Map<String, Object> unknown) {
+    this.unknown = new ConcurrentHashMap<>(unknown);
+  }
+
+  // region json
+
   @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 JsonKeys {
+    public static final String NAME = "name";
+    public static final String VERSION = "version";
   }
+
+  @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 (unknown != null) {
+      for (String key : unknown.keySet()) {
+        Object value = unknown.get(key);
+        writer.name(key);
+        writer.value(logger, value);
+      }
+    }
+    writer.endObject();
+  }
+
+  public static final class Deserializer implements JsonDeserializer<Browser> {
+    @Override
+    public @NotNull Browser deserialize(@NotNull JsonObjectReader reader, @NotNull ILogger logger)
+        throws Exception {
+      reader.beginObject();
+      Browser browser = new Browser();
+      Map<String, Object> unknown = null;
+      do {
+        final String nextName = reader.nextName();
+        switch (nextName) {
+          case JsonKeys.NAME:
+            browser.name = reader.nextStringOrNull();
+            break;
+          case JsonKeys.VERSION:
+            browser.version = reader.nextStringOrNull();
+            break;
+          default:
+            if (unknown == null) {
+              unknown = new ConcurrentHashMap<>();
+            }
+            reader.nextUnknown(logger, unknown, nextName);
+            break;
+        }
+      } while (reader.hasNext() && reader.peek() == JsonToken.NAME);
+      browser.setUnknown(unknown);
+      reader.endObject();
+      return browser;
+    }
+  }
+
+  // endregion
 }
diff --git a/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt b/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt
@@ -3,6 +3,7 @@ package io.sentry
 import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.verify
 import io.sentry.protocol.App
+import io.sentry.protocol.Browser
 import io.sentry.protocol.SentryId
 import java.io.StringReader
 import java.io.StringWriter
@@ -25,6 +26,10 @@ class JsonUnknownSerializationTest {
             return givenJsonUnknown(App())
         }
 
+        fun getBrowser(): Browser {
+            return givenJsonUnknown(Browser())
+        }
+
         private fun <T : JsonUnknown> givenJsonUnknown(jsonUnknown: T): T {
             return jsonUnknown.apply {
                 unknown = mapOf(
@@ -73,6 +78,7 @@ class JsonUnknownSerializationTest {
     }
 
     @Test
+
     fun `serializing unknown calls json object writer for app`() {
         val writer: JsonObjectWriter = mock()
         val logger: ILogger = mock()
@@ -84,6 +90,30 @@ class JsonUnknownSerializationTest {
         verify(writer).value(logger, "fixture-value")
     }
 
+    // browser
+
+    @Test
+    fun `serializing and deserialize browser`() {
+        val sut = fixture.getBrowser()
+
+        val serialized = serialize(sut)
+        val deserialized = deserialize(serialized, Browser.Deserializer())
+
+        assertEquals(sut.unknown, deserialized.unknown)
+    }
+
+    @Test
+    fun `serializing unknown calls json object writer for browser`() {
+        val writer: JsonObjectWriter = mock()
+        val logger: ILogger = mock()
+        val sut = fixture.getBrowser()
+
+        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/BrowserSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/BrowserSerializationTest.kt
@@ -0,0 +1,60 @@
+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 BrowserSerializationTest {
+
+    private class Fixture {
+        var logger: ILogger = mock()
+
+        fun getSut() = Browser().apply {
+            name = "e1c723db-7408-4043-baa7-f4e96234e5dc"
+            version = "724a48e9-2d35-416b-9f79-132beba2473a"
+        }
+    }
+    private val fixture = Fixture()
+
+    @Test
+    fun serialize() {
+        val expected = sanitizedFile("gson/browser.json")
+        val actual = serialize(fixture.getSut())
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun deserialize() {
+        val expectedJson = sanitizedFile("gson/browser.json")
+        val actual = deserialize(expectedJson)
+        val actualJson = serialize(actual)
+        assertEquals(expectedJson, actualJson)
+    }
+
+    // Helper
+
+    private fun sanitizedFile(path: String): String {
+        return FileFromResources.invoke(path)
+            .replace(Regex("[\n\r]"), "")
+            .replace(" ", "")
+    }
+
+    private fun serialize(jsonSerializable: JsonSerializable): String {
+        val wrt = StringWriter()
+        val jsonWrt = JsonObjectWriter(wrt)
+        jsonSerializable.serialize(jsonWrt, fixture.logger)
+        return wrt.toString()
+    }
+
+    private fun deserialize(json: String): Browser {
+        val reader = JsonObjectReader(StringReader(json))
+        return Browser.Deserializer().deserialize(reader, fixture.logger)
+    }
+}
diff --git a/sentry/src/test/resources/gson/browser.json b/sentry/src/test/resources/gson/browser.json
@@ -0,0 +1,4 @@
+{
+    "name": "e1c723db-7408-4043-baa7-f4e96234e5dc",
+    "version": "724a48e9-2d35-416b-9f79-132beba2473a"
+}