Serialize default values in oneofs when calling to_dict() or to_json() (#110)

* Serialize default values in oneofs when calling to_dict() or to_json()

This change is consistent with the official protobuf implementation. If
a default value is set when using a oneof, and then a message is
translated from message -> JSON -> message, the default value is kept in
tact. Also, if no default value is set, they remain null.

* Some cleanup + testing for nested messages with oneofs

* Cleanup oneof_enum test cases, they should be fixed

This _should_ address:
https://github.com/danielgtaylor/python-betterproto/issues/63

* Include default value oneof fields when serializing to bytes

This will cause oneof fields with default values to explicitly be sent
to clients. Note that does not mean that all fields are serialized and
sent to clients, just those that _could_ be null and are not.

* Remove assignment when populating a sub-message within a proto

Also, move setattr out one indentation level

* Properly transform proto with empty string in oneof to bytes

Also, updated tests to ensure that which_one_of picks up the set field

* Formatting betterproto/__init__.py

* Adding test cases demonstrating equivalent behaviour with google impl

* Removing a temporary file I made locally

* Adding some clarifying comments

* Fixing tests for python38

tests/inputs/google_impl_behavior_equivalence/google_impl_behavior_equivalence.proto

@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+message Foo{
+  int64 bar = 1;
+}
+
+message Test{
+  oneof group{
+    string string = 1;
+    int64 integer = 2;
+    Foo foo = 3;
+  }
+}

tests/inputs/google_impl_behavior_equivalence/test_google_impl_behavior_equivalence.py

@@ -0,0 +1,55 @@
+import pytest
+
+from google.protobuf import json_format
+import betterproto
+from tests.output_betterproto.google_impl_behavior_equivalence import (
+    Test,
+    Foo,
+)
+from tests.output_reference.google_impl_behavior_equivalence.google_impl_behavior_equivalence_pb2 import (
+    Test as ReferenceTest,
+    Foo as ReferenceFoo,
+)
+
+
+def test_oneof_serializes_similar_to_google_oneof():
+
+    tests = [
+        (Test(string="abc"), ReferenceTest(string="abc")),
+        (Test(integer=2), ReferenceTest(integer=2)),
+        (Test(foo=Foo(bar=1)), ReferenceTest(foo=ReferenceFoo(bar=1))),
+        # Default values should also behave the same within oneofs
+        (Test(string=""), ReferenceTest(string="")),
+        (Test(integer=0), ReferenceTest(integer=0)),
+        (Test(foo=Foo(bar=0)), ReferenceTest(foo=ReferenceFoo(bar=0))),
+    ]
+    for message, message_reference in tests:
+        # NOTE: As of July 2020, MessageToJson inserts newlines in the output string so,
+        # just compare dicts
+        assert message.to_dict() == json_format.MessageToDict(message_reference)
+
+
+def test_bytes_are_the_same_for_oneof():
+
+    message = Test(string="")
+    message_reference = ReferenceTest(string="")
+
+    message_bytes = bytes(message)
+    message_reference_bytes = message_reference.SerializeToString()
+
+    assert message_bytes == message_reference_bytes
+
+    message2 = Test().parse(message_reference_bytes)
+    message_reference2 = ReferenceTest()
+    message_reference2.ParseFromString(message_reference_bytes)
+
+    assert message == message2
+    assert message_reference == message_reference2
+
+    # None of these fields were explicitly set BUT they should not actually be null
+    # themselves
+    assert isinstance(message.foo, Foo)
+    assert isinstance(message2.foo, Foo)
+
+    assert isinstance(message_reference.foo, ReferenceFoo)
+    assert isinstance(message_reference2.foo, ReferenceFoo)

tests/inputs/oneof_default_value_serialization/oneof_default_value_serialization.proto

@@ -0,0 +1,28 @@
+syntax = "proto3";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/wrappers.proto";
+
+message Message{
+  int64 value = 1;
+}
+
+message NestedMessage{
+  int64 id = 1;
+  oneof value_type{
+    Message wrapped_message_value = 2;
+  }
+}
+
+message Test{
+  oneof value_type {
+      bool bool_value = 1;
+      int64 int64_value = 2;
+      google.protobuf.Timestamp timestamp_value = 3;
+      google.protobuf.Duration duration_value = 4;
+      Message wrapped_message_value = 5;
+      NestedMessage wrapped_nested_message_value = 6;
+      google.protobuf.BoolValue wrapped_bool_value = 7;
+  }
+}

tests/inputs/oneof_default_value_serialization/test_oneof_default_value_serialization.py

@@ -0,0 +1,74 @@
+import pytest
+import datetime
+
+import betterproto
+from tests.output_betterproto.oneof_default_value_serialization import (
+    Test,
+    Message,
+    NestedMessage,
+)
+
+
+def assert_round_trip_serialization_works(message: Test) -> None:
+    assert betterproto.which_one_of(message, "value_type") == betterproto.which_one_of(
+        Test().from_json(message.to_json()), "value_type"
+    )
+
+
+def test_oneof_default_value_serialization_works_for_all_values():
+    """
+    Serialization from message with oneof set to default -> JSON -> message should keep
+    default value field intact.
+    """
+
+    test_cases = [
+        Test(bool_value=False),
+        Test(int64_value=0),
+        Test(
+            timestamp_value=datetime.datetime(
+                year=1970,
+                month=1,
+                day=1,
+                hour=0,
+                minute=0,
+                tzinfo=datetime.timezone.utc,
+            )
+        ),
+        Test(duration_value=datetime.timedelta(0)),
+        Test(wrapped_message_value=Message(value=0)),
+        # NOTE: Do NOT use betterproto.BoolValue here, it will cause JSON serialization
+        # errors.
+        # TODO: Do we want to allow use of BoolValue directly within a wrapped field or
+        # should we simply hard fail here?
+        Test(wrapped_bool_value=False),
+    ]
+    for message in test_cases:
+        assert_round_trip_serialization_works(message)
+
+
+def test_oneof_no_default_values_passed():
+    message = Test()
+    assert (
+        betterproto.which_one_of(message, "value_type")
+        == betterproto.which_one_of(Test().from_json(message.to_json()), "value_type")
+        == ("", None)
+    )
+
+
+def test_oneof_nested_oneof_messages_are_serialized_with_defaults():
+    """
+    Nested messages with oneofs should also be handled
+    """
+    message = Test(
+        wrapped_nested_message_value=NestedMessage(
+            id=0, wrapped_message_value=Message(value=0)
+        )
+    )
+    assert (
+        betterproto.which_one_of(message, "value_type")
+        == betterproto.which_one_of(Test().from_json(message.to_json()), "value_type")
+        == (
+            "wrapped_nested_message_value",
+            NestedMessage(id=0, wrapped_message_value=Message(value=0)),
+        )
+    )

tests/inputs/oneof_enum/test_oneof_enum.py

@@ -9,34 +9,36 @@ from tests.output_betterproto.oneof_enum import (
 from tests.util import get_test_case_json_data
 
 
-@pytest.mark.xfail
 def test_which_one_of_returns_enum_with_default_value():
     """
     returns first field when it is enum and set with default value
     """
     message = Test()
     message.from_json(get_test_case_json_data("oneof_enum", "oneof_enum-enum-0.json"))
-    assert message.move is None
+
+    assert message.move == Move(
+        x=0, y=0
+    )  # Proto3 will default this as there is no null
     assert message.signal == Signal.PASS
     assert betterproto.which_one_of(message, "action") == ("signal", Signal.PASS)
 
 
-@pytest.mark.xfail
 def test_which_one_of_returns_enum_with_non_default_value():
     """
     returns first field when it is enum and set with non default value
     """
     message = Test()
     message.from_json(get_test_case_json_data("oneof_enum", "oneof_enum-enum-1.json"))
-    assert message.move is None
-    assert message.signal == Signal.PASS
+    assert message.move == Move(
+        x=0, y=0
+    )  # Proto3 will default this as there is no null
+    assert message.signal == Signal.RESIGN
     assert betterproto.which_one_of(message, "action") == ("signal", Signal.RESIGN)
 
 
-@pytest.mark.xfail
 def test_which_one_of_returns_second_field_when_set():
     message = Test()
     message.from_json(get_test_case_json_data("oneof_enum"))
     assert message.move == Move(x=2, y=3)
-    assert message.signal == 0
+    assert message.signal == Signal.PASS
     assert betterproto.which_one_of(message, "action") == ("move", Move(x=2, y=3))

tests/test_features.py

@@ -282,3 +282,38 @@ def test_to_dict_default_values():
         "someDouble": 1.2,
         "someMessage": {"someOtherInt": 0},
     }
+
+
+def test_oneof_default_value_set_causes_writes_wire():
+    @dataclass
+    class Foo(betterproto.Message):
+        bar: int = betterproto.int32_field(1, group="group1")
+        baz: str = betterproto.string_field(2, group="group1")
+
+    def _round_trip_serialization(foo: Foo) -> Foo:
+        return Foo().parse(bytes(foo))
+
+    foo1 = Foo(bar=0)
+    foo2 = Foo(baz="")
+    foo3 = Foo()
+
+    assert bytes(foo1) == b"\x08\x00"
+    assert (
+        betterproto.which_one_of(foo1, "group1")
+        == betterproto.which_one_of(_round_trip_serialization(foo1), "group1")
+        == ("bar", 0)
+    )
+
+    assert bytes(foo2) == b"\x12\x00"  # Baz is just an empty string
+    assert (
+        betterproto.which_one_of(foo2, "group1")
+        == betterproto.which_one_of(_round_trip_serialization(foo2), "group1")
+        == ("baz", "")
+    )
+
+    assert bytes(foo3) == b""
+    assert (
+        betterproto.which_one_of(foo3, "group1")
+        == betterproto.which_one_of(_round_trip_serialization(foo3), "group1")
+        == ("", None)
+    )