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
@@ -1641,24 +1641,43 @@ public final class io/sentry/protocol/Message : io/sentry/IUnknownPropertiesCons
 	public fun setParams (Ljava/util/List;)V
 }
 
-public final class io/sentry/protocol/OperatingSystem : io/sentry/IUnknownPropertiesConsumer {
+public final class io/sentry/protocol/OperatingSystem : 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 getBuild ()Ljava/lang/String;
 	public fun getKernelVersion ()Ljava/lang/String;
 	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 isRooted ()Ljava/lang/Boolean;
+	public fun serialize (Lio/sentry/JsonObjectWriter;Lio/sentry/ILogger;)V
 	public fun setBuild (Ljava/lang/String;)V
 	public fun setKernelVersion (Ljava/lang/String;)V
 	public fun setName (Ljava/lang/String;)V
 	public fun setRawDescription (Ljava/lang/String;)V
 	public fun setRooted (Ljava/lang/Boolean;)V
+	public fun setUnknown (Ljava/util/Map;)V
 	public fun setVersion (Ljava/lang/String;)V
 }
 
+public final class io/sentry/protocol/OperatingSystem$Deserializer : io/sentry/JsonDeserializer {
+	public fun <init> ()V
+	public fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Lio/sentry/protocol/OperatingSystem;
+	public synthetic fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Ljava/lang/Object;
+}
+
+public final class io/sentry/protocol/OperatingSystem$JsonKeys {
+	public static final field BUILD Ljava/lang/String;
+	public static final field KERNEL_VERSION Ljava/lang/String;
+	public static final field NAME Ljava/lang/String;
+	public static final field RAW_DESCRIPTION Ljava/lang/String;
+	public static final field ROOTED Ljava/lang/String;
+	public static final field VERSION Ljava/lang/String;
+	public fun <init> ()V
+}
+
 public final class io/sentry/protocol/Request : io/sentry/IUnknownPropertiesConsumer {
 	public fun <init> ()V
 	public fun <init> (Lio/sentry/protocol/Request;)V

diff --git a/sentry/src/main/java/io/sentry/protocol/OperatingSystem.java b/sentry/src/main/java/io/sentry/protocol/OperatingSystem.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 OperatingSystem implements IUnknownPropertiesConsumer {
+public final class OperatingSystem
+    implements IUnknownPropertiesConsumer, JsonUnknown, JsonSerializable {
   public static final String TYPE = "os";
 
   /** Name of the operating system. */
@@ -98,15 +105,106 @@ public void setRooted(final @Nullable Boolean rooted) {
     this.rooted = rooted;
   }
 
-  @TestOnly
+  @ApiStatus.Internal
+  @Override
+  public void acceptUnknownProperties(final @NotNull Map<String, Object> unknown) {
+    this.unknown = new ConcurrentHashMap<>(unknown);
+  }
+
+  // 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";
+    public static final String BUILD = "build";
+    public static final String KERNEL_VERSION = "kernel_version";
+    public static final String ROOTED = "rooted";
+  }
+
+  @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 (build != null) {
+      writer.name(JsonKeys.BUILD).value(build);
+    }
+    if (kernelVersion != null) {
+      writer.name(JsonKeys.KERNEL_VERSION).value(kernelVersion);
+    }
+    if (rooted != null) {
+      writer.name(JsonKeys.ROOTED).value(rooted);
+    }
+    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<OperatingSystem> {
+
+    @Override
+    public @NotNull OperatingSystem deserialize(
+        @NotNull JsonObjectReader reader, @NotNull ILogger logger) throws Exception {
+      reader.beginObject();
+      OperatingSystem operatingSystem = new OperatingSystem();
+      Map<String, Object> unknown = null;
+      do {
+        final String nextName = reader.nextName();
+        switch (nextName) {
+          case JsonKeys.NAME:
+            operatingSystem.name = reader.nextStringOrNull();
+            break;
+          case JsonKeys.VERSION:
+            operatingSystem.version = reader.nextStringOrNull();
+            break;
+          case JsonKeys.RAW_DESCRIPTION:
+            operatingSystem.rawDescription = reader.nextStringOrNull();
+            break;
+          case JsonKeys.BUILD:
+            operatingSystem.build = reader.nextStringOrNull();
+            break;
+          case JsonKeys.KERNEL_VERSION:
+            operatingSystem.kernelVersion = reader.nextStringOrNull();
+            break;
+          case JsonKeys.ROOTED:
+            operatingSystem.rooted = reader.nextBooleanOrNull();
+            break;
+          default:
+            if (unknown == null) {
+              unknown = new ConcurrentHashMap<>();
+            }
+            reader.nextUnknown(logger, unknown, nextName);
+            break;
+        }
+      } while (reader.hasNext());
+      operatingSystem.setUnknown(unknown);
+      reader.endObject();
+      return operatingSystem;
+    }
   }
 }
diff --git a/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt b/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt
@@ -4,6 +4,7 @@ import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.verify
 import io.sentry.protocol.App
 import io.sentry.protocol.Browser
+import io.sentry.protocol.OperatingSystem
 import io.sentry.protocol.SentryId
 import java.io.StringReader
 import java.io.StringWriter
@@ -30,6 +31,10 @@ class JsonUnknownSerializationTest {
             return givenJsonUnknown(Browser())
         }
 
+        fun getOperatingSystem(): OperatingSystem {
+            return givenJsonUnknown(OperatingSystem())
+        }
+
         private fun <T : JsonUnknown> givenJsonUnknown(jsonUnknown: T): T {
             return jsonUnknown.apply {
                 unknown = mapOf(
@@ -41,7 +46,7 @@ class JsonUnknownSerializationTest {
 
     private val fixture = Fixture()
 
-    // user feedback
+    // UserFeedback
 
     @Test
     fun `serializing and deserialize user feedback`() {
@@ -65,7 +70,7 @@ class JsonUnknownSerializationTest {
         verify(writer).value(logger, "fixture-value")
     }
 
-    // app
+    // App
 
     @Test
     fun `serializing and deserialize app`() {
@@ -90,7 +95,7 @@ class JsonUnknownSerializationTest {
         verify(writer).value(logger, "fixture-value")
     }
 
-    // browser
+    // Browser
 
     @Test
     fun `serializing and deserialize browser`() {
@@ -114,6 +119,30 @@ class JsonUnknownSerializationTest {
         verify(writer).value(logger, "fixture-value")
     }
 
+    // OperatingSystem
+
+    @Test
+    fun `serializing and deserialize operating system`() {
+        val sut = fixture.getOperatingSystem()
+
+        val serialized = serialize(sut)
+        val deserialized = deserialize(serialized, OperatingSystem.Deserializer())
+
+        assertEquals(sut.unknown, deserialized.unknown)
+    }
+
+    @Test
+    fun `serializing unknown calls json object writer for operating system`() {
+        val writer: JsonObjectWriter = mock()
+        val logger: ILogger = mock()
+        val sut = fixture.getOperatingSystem()
+
+        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/OeratingSystemSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/OeratingSystemSerializationTest.kt
@@ -0,0 +1,67 @@
+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 OperatingSystemSerializationTest {
+    private class Fixture {
+        var logger: ILogger = mock()
+
+        fun getSut() = OperatingSystem().apply {
+            name = "686a11a8-eae7-4393-aa10-a1368d523cb2"
+            version = "3033f32d-6a27-4715-80c8-b232ce84ca61"
+            rawDescription = "eb2d0c5e-f5d4-49c7-b876-d8a654ee87cf"
+            build = "bd197b97-eb68-49c3-9d07-ef789caf3069"
+            kernelVersion = "1df24aec-3a6f-49a9-8b50-69ae5f9dde08"
+            isRooted = true
+        }
+    }
+    private val fixture = Fixture()
+
+    @Test
+    fun serialize() {
+        val expected = sanitizedFile("gson/operating_system.json")
+        val actual = serializeToString(fixture.getSut())
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun deserialize() {
+        val expectedJson = sanitizedFile("gson/operating_system.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): OperatingSystem {
+        val reader = JsonObjectReader(StringReader(json))
+        return OperatingSystem.Deserializer().deserialize(reader, fixture.logger)
+    }
+}
diff --git a/sentry/src/test/resources/gson/operating_system.json b/sentry/src/test/resources/gson/operating_system.json
@@ -0,0 +1,8 @@
+{
+    "name": "686a11a8-eae7-4393-aa10-a1368d523cb2",
+    "version": "3033f32d-6a27-4715-80c8-b232ce84ca61",
+    "raw_description": "eb2d0c5e-f5d4-49c7-b876-d8a654ee87cf",
+    "build": "bd197b97-eb68-49c3-9d07-ef789caf3069",
+    "kernel_version": "1df24aec-3a6f-49a9-8b50-69ae5f9dde08",
+    "rooted": true
+}