def test_has_value_assigned_repeated(self):
class Foo(messages.Message):
pete = messages.StringField(repeated=True)
message = to_dict.decode_message(Foo, {"pete": []})
self.assertTrue(message.has_value_assigned('pete'))
message = to_dict.decode_message(Foo, {"pete": ["sat"]})
self.assertTrue(message.has_value_assigned('pete'))
message = to_dict.decode_message(Foo, {"pete": ["sat", "in", "a", "boat"]})
self.assertTrue(message.has_value_assigned('pete'))
def test_has_value_assigned_repeated(self):
class Foo(messages.Message):
pete = messages.StringField(repeated=True)
message = to_dict.decode_message(Foo, {"pete": []})
self.assertTrue(message.has_value_assigned('pete'))
message = to_dict.decode_message(Foo, {"pete": ["sat"]})
self.assertTrue(message.has_value_assigned('pete'))
message = to_dict.decode_message(Foo,
{"pete": ["sat", "in", "a", "boat"]})
self.assertTrue(message.has_value_assigned('pete'))
def test_untyped_field_decode(self):
class Foo(messages.Message):
bar = messages.UntypedField()
f = Foo()
self.assertEquals(f, to_dict.decode_message(Foo, {}))
f = Foo()
f.bar = 123
self.assertEquals(f, to_dict.decode_message(Foo, {"bar": 123}))
f = Foo()
f.bar = "meow"
self.assertEquals(f, to_dict.decode_message(Foo, {"bar": "meow"}))
f = Foo()
f.bar = True
self.assertEquals(f, to_dict.decode_message(Foo, {"bar": True}))
f = Foo()
f.bar = 1.23
self.assertEquals(f, to_dict.decode_message(Foo, {"bar": 1.23}))
f = Foo()
f.bar = 1.23
self.assertEquals(f, to_dict.decode_message(Foo, {"bar": 1.23}))
f = Foo()
f.bar = None
self.assertEquals(f, to_dict.decode_message(Foo, {"bar": None}))
f = Foo()
f.bar = [[123, 1.23, "woof", True], "meow"]
self.assertEquals(f, to_dict.decode_message(Foo, {"bar": [[123, 1.23, "woof", True], "meow"]}))
def testUnrecognizedFieldVariants(self):
"""Test that unrecognized fields are mapped to the right variants."""
for encoded, expected_variant in (({
"an_integer": 1,
"unknown_val": 2
}, messages.Variant.INT64), ({
"an_integer": 1,
"unknown_val": 2.0
}, messages.Variant.DOUBLE), ({
"an_integer": 1,
"unknown_val": "string value"
}, messages.Variant.STRING), ({
"an_integer": 1,
"unknown_val": [1, 2, 3]
}, messages.Variant.INT64), ({
"an_integer": 1,
"unknown_val": [1, 2.0, 3]
}, messages.Variant.DOUBLE), ({
"an_integer": 1,
"unknown_val": [1, "foo", 3]
}, messages.Variant.STRING), ({
"an_integer": 1,
"unknown_val": True
}, messages.Variant.BOOL)):
decoded = to_dict.decode_message(MyMessage, encoded)
self.assertEqual(decoded.an_integer, 1)
self.assertEqual(1, len(decoded.all_unrecognized_fields()))
self.assertEqual('unknown_val',
decoded.all_unrecognized_fields()[0])
_, decoded_variant = decoded.get_unrecognized_field_info(
'unknown_val')
self.assertEqual(expected_variant, decoded_variant)
def testProtodictUnrecognizedNull(self):
"""Test that unrecognized fields that are None are skipped."""
decoded = to_dict.decode_message(
MyMessage,
{"an_integer": 1, "unrecognized_null": None})
self.assertEquals(decoded.an_integer, 1)
self.assertEquals(decoded.all_unrecognized_fields(), [])
def test_untyped_field_repeated_decode(self):
class Foo(messages.Message):
bar = messages.UntypedField(repeated=True)
f = Foo()
f.bar = [123, "woof", 1.23, True]
self.assertEquals(f, to_dict.decode_message(Foo, {"bar": [123, "woof", 1.23, True]}))
def testEmptyList(self):
"""Test that empty lists are not ignored."""
m = MyMessage()
m.a_repeated = []
self.assertEquals(m,
to_dict.decode_message(MyMessage,
{"a_repeated": []}))
def testNullValues(self):
"""Test that null values overwrite existing values."""
m = MyMessage()
m.an_integer = None
m.a_nested = None
self.assertEquals(m, to_dict.decode_message(MyMessage, ({"an_integer": None, "a_nested": None})))
def testNumericEnumeration(self):
"""Test that numbers work for enum values."""
message = to_dict.decode_message(MyMessage, {"an_enum": 2})
expected_message = MyMessage()
expected_message.an_enum = MyMessage.Color.GREEN
self.assertEqual(expected_message, message)
def test_untyped_field_repeated_decode(self):
class Foo(messages.Message):
bar = messages.UntypedField(repeated=True)
f = Foo()
f.bar = [123, "woof", 1.23, True]
self.assertEqual(
f, to_dict.decode_message(Foo, {"bar": [123, "woof", 1.23, True]}))
def testNumericEnumeration(self):
"""Test that numbers work for enum values."""
message = to_dict.decode_message(MyMessage, {"an_enum": 2})
expected_message = MyMessage()
expected_message.an_enum = MyMessage.Color.GREEN
self.assertEquals(expected_message, message)
def testProtodictUnrecognizedNull(self):
"""Test that unrecognized fields that are None are skipped."""
decoded = to_dict.decode_message(MyMessage, {
"an_integer": 1,
"unrecognized_null": None
})
self.assertEqual(decoded.an_integer, 1)
self.assertEqual(decoded.all_unrecognized_fields(), [])
def testProtodictUnrecognizedFieldName(self):
"""Test that unrecognized fields are saved and can be accessed."""
decoded = to_dict.decode_message(MyMessage,
({"an_integer": 1, "unknown_val": 2}))
self.assertEquals(decoded.an_integer, 1)
self.assertEquals(1, len(decoded.all_unrecognized_fields()))
self.assertEquals('unknown_val', decoded.all_unrecognized_fields()[0])
self.assertEquals((2, messages.Variant.INT64),
decoded.get_unrecognized_field_info('unknown_val'))
def test_has_value_assigned(self):
class Foo(messages.Message):
not_set = messages.StringField()
set_null = messages.StringField()
message = to_dict.decode_message(Foo, {"set_null": None})
self.assertFalse(message.has_value_assigned('not_set'))
self.assertTrue(message.has_value_assigned('set_null'))
self.assertIsNone(message.not_set)
self.assertIsNone(message.set_null)
def test_explicit_field_name_round_trip(self):
class Foo(messages.Message):
bob = messages.StringField(name="robert")
ryan = messages.StringField()
f = Foo(bob="smith", ryan="morlok")
m = to_dict.decode_message(Foo, to_dict.encode_message(f))
self.assertEquals("smith", m.bob)
self.assertEquals("morlok", m.ryan)
def test_explicit_field_name_round_trip(self):
class Foo(messages.Message):
bob = messages.StringField(name="robert")
ryan = messages.StringField()
f = Foo(bob="smith", ryan="morlok")
m = to_dict.decode_message(Foo, to_dict.encode_message(f))
self.assertEqual("smith", m.bob)
self.assertEqual("morlok", m.ryan)
def test_has_value_assigned(self):
class Foo(messages.Message):
not_set = messages.StringField()
set_null = messages.StringField()
message = to_dict.decode_message(Foo, {"set_null": None})
self.assertFalse(message.has_value_assigned('not_set'))
self.assertTrue(message.has_value_assigned('set_null'))
self.assertIsNone(message.not_set)
self.assertIsNone(message.set_null)
def testProtodictUnrecognizedFieldName(self):
"""Test that unrecognized fields are saved and can be accessed."""
decoded = to_dict.decode_message(MyMessage, ({
"an_integer": 1,
"unknown_val": 2
}))
self.assertEqual(decoded.an_integer, 1)
self.assertEqual(1, len(decoded.all_unrecognized_fields()))
self.assertEqual('unknown_val', decoded.all_unrecognized_fields()[0])
self.assertEqual((2, messages.Variant.INT64),
decoded.get_unrecognized_field_info('unknown_val'))
def testNullValues(self):
"""Test that null values overwrite existing values."""
m = MyMessage()
m.an_integer = None
m.a_nested = None
self.assertEqual(
m,
to_dict.decode_message(MyMessage, ({
"an_integer": None,
"a_nested": None
})))
def testProtodictUnrecognizedFieldNumber(self):
"""Test that unrecognized fields are saved and can be accessed."""
decoded = to_dict.decode_message(MyMessage, {"an_integer": 1, "1001": "unknown", "-123": "negative", "456_mixed": 2})
self.assertEquals(decoded.an_integer, 1)
self.assertEquals(3, len(decoded.all_unrecognized_fields()))
self.assertIn(1001, decoded.all_unrecognized_fields())
self.assertEquals(('unknown', messages.Variant.STRING),
decoded.get_unrecognized_field_info(1001))
self.assertIn('-123', decoded.all_unrecognized_fields())
self.assertEquals(('negative', messages.Variant.STRING),
decoded.get_unrecognized_field_info('-123'))
self.assertIn('456_mixed', decoded.all_unrecognized_fields())
self.assertEquals((2, messages.Variant.INT64),
decoded.get_unrecognized_field_info('456_mixed'))
def testDecodeRepeatedDateTimeMsInteger(self):
message = to_dict.decode_message(MyMessage, {"a_repeated_datetime_ms_integer": [
datetime.datetime(2012, 9, 30, 15, 31, 50, 262000),
datetime.datetime(2010, 1, 21, 9, 52),
datetime.datetime(2000, 1, 1, 1, 0, 59, 999999)
]})
expected_message = MyMessage(
a_repeated_datetime_ms_integer=[
datetime.datetime(2012, 9, 30, 15, 31, 50, 262000),
datetime.datetime(2010, 1, 21, 9, 52),
datetime.datetime(2000, 1, 1, 1, 0, 59, 999999)])
self.assertEquals(expected_message, message)
def testConvertStringToNumbers(self):
"""Test that strings passed to integer fields are converted."""
message = to_dict.decode_message(MyMessage,
{"an_integer": "10",
"a_float": "3.5",
"a_repeated": ["1", "2"],
"a_repeated_float": ["1.5", "2", 10]
})
self.assertEquals(MyMessage(an_integer=10,
a_float=3.5,
a_repeated=[1, 2],
a_repeated_float=[1.5, 2.0, 10.0]),
message)
def test_explicit_field_name(self):
class Foo(messages.Message):
bob = messages.StringField(name="robert")
ryan = messages.StringField()
m = to_dict.decode_message(Foo, {"robert": "smith", "ryan": "morlok"})
self.assertEquals("smith", m.bob)
self.assertEquals("morlok", m.ryan)
f = Foo()
f.bob = "smith"
f.ryan = "morlok"
self.assertEquals({"robert": "smith", "ryan": "morlok"}, to_dict.encode_message(f))
def test_explicit_field_name_repeated(self):
class Foo(messages.Message):
bob = messages.StringField(name="robert", repeated=True)
ryan = messages.StringField()
m = to_dict.decode_message(Foo, {"robert": ["smith", "jones"], "ryan": "morlok"})
self.assertEquals(["smith", "jones"], m.bob)
self.assertEquals("morlok", m.ryan)
f = Foo()
f.bob = ["smith", "jones"]
f.ryan = "morlok"
self.assertEquals({"robert": ["smith", "jones"], "ryan": "morlok"}, to_dict.encode_message(f))
def testConvertStringToNumbers(self):
"""Test that strings passed to integer fields are converted."""
message = to_dict.decode_message(
MyMessage, {
"an_integer": "10",
"a_float": "3.5",
"a_repeated": ["1", "2"],
"a_repeated_float": ["1.5", "2", 10]
})
self.assertEqual(
MyMessage(an_integer=10,
a_float=3.5,
a_repeated=[1, 2],
a_repeated_float=[1.5, 2.0, 10.0]), message)
def testDecodeRepeatedDateTimeMsInteger(self):
message = to_dict.decode_message(
MyMessage, {
"a_repeated_datetime_ms_integer": [
datetime.datetime(2012, 9, 30, 15, 31, 50, 262000),
datetime.datetime(2010, 1, 21, 9, 52),
datetime.datetime(2000, 1, 1, 1, 0, 59, 999999)
]
})
expected_message = MyMessage(a_repeated_datetime_ms_integer=[
datetime.datetime(2012, 9, 30, 15, 31, 50, 262000),
datetime.datetime(2010, 1, 21, 9, 52),
datetime.datetime(2000, 1, 1, 1, 0, 59, 999999)
])
self.assertEqual(expected_message, message)
def test_explicit_field_name(self):
class Foo(messages.Message):
bob = messages.StringField(name="robert")
ryan = messages.StringField()
m = to_dict.decode_message(Foo, {"robert": "smith", "ryan": "morlok"})
self.assertEqual("smith", m.bob)
self.assertEqual("morlok", m.ryan)
f = Foo()
f.bob = "smith"
f.ryan = "morlok"
self.assertEqual({
"robert": "smith",
"ryan": "morlok"
}, to_dict.encode_message(f))
def testDecodeRepeatedUUID(self):
from uuid import UUID
message = to_dict.decode_message(
MyMessage, {
"a_repeated_uuid": [
UUID("06335e84-2872-4914-8c5d-3ed07d2a2f16"),
UUID("16335e84-2872-4914-8c5d-3ed07d2a2f16"),
UUID("26335e84-2872-4914-8c5d-3ed07d2a2f16"),
]
})
expected_message = MyMessage(a_repeated_uuid=[
UUID("06335e84-2872-4914-8c5d-3ed07d2a2f16"),
UUID("16335e84-2872-4914-8c5d-3ed07d2a2f16"),
UUID("26335e84-2872-4914-8c5d-3ed07d2a2f16"),
])
self.assertEqual(expected_message, message)
def testUnrecognizedFieldVariants(self):
"""Test that unrecognized fields are mapped to the right variants."""
for encoded, expected_variant in (
({"an_integer": 1, "unknown_val": 2}, messages.Variant.INT64),
({"an_integer": 1, "unknown_val": 2.0}, messages.Variant.DOUBLE),
({"an_integer": 1, "unknown_val": "string value"},
messages.Variant.STRING),
({"an_integer": 1, "unknown_val": [1, 2, 3]}, messages.Variant.INT64),
({"an_integer": 1, "unknown_val": [1, 2.0, 3]},
messages.Variant.DOUBLE),
({"an_integer": 1, "unknown_val": [1, "foo", 3]},
messages.Variant.STRING),
({"an_integer": 1, "unknown_val": True}, messages.Variant.BOOL)):
decoded = to_dict.decode_message(MyMessage, encoded)
self.assertEquals(decoded.an_integer, 1)
self.assertEquals(1, len(decoded.all_unrecognized_fields()))
self.assertEquals('unknown_val', decoded.all_unrecognized_fields()[0])
_, decoded_variant = decoded.get_unrecognized_field_info('unknown_val')
self.assertEquals(expected_variant, decoded_variant)
def testProtodictUnrecognizedFieldNumber(self):
"""Test that unrecognized fields are saved and can be accessed."""
decoded = to_dict.decode_message(MyMessage, {
"an_integer": 1,
"1001": "unknown",
"-123": "negative",
"456_mixed": 2
})
self.assertEqual(decoded.an_integer, 1)
self.assertEqual(3, len(decoded.all_unrecognized_fields()))
self.assertIn(1001, decoded.all_unrecognized_fields())
self.assertEqual(('unknown', messages.Variant.STRING),
decoded.get_unrecognized_field_info(1001))
self.assertIn('-123', decoded.all_unrecognized_fields())
self.assertEqual(('negative', messages.Variant.STRING),
decoded.get_unrecognized_field_info('-123'))
self.assertIn('456_mixed', decoded.all_unrecognized_fields())
self.assertEqual((2, messages.Variant.INT64),
decoded.get_unrecognized_field_info('456_mixed'))
def test_explicit_field_name_repeated(self):
class Foo(messages.Message):
bob = messages.StringField(name="robert", repeated=True)
ryan = messages.StringField()
m = to_dict.decode_message(Foo, {
"robert": ["smith", "jones"],
"ryan": "morlok"
})
self.assertEqual(["smith", "jones"], m.bob)
self.assertEqual("morlok", m.ryan)
f = Foo()
f.bob = ["smith", "jones"]
f.ryan = "morlok"
self.assertEqual({
"robert": ["smith", "jones"],
"ryan": "morlok"
}, to_dict.encode_message(f))
def test_untyped_field_decode(self):
class Foo(messages.Message):
bar = messages.UntypedField()
f = Foo()
self.assertEqual(f, to_dict.decode_message(Foo, {}))
f = Foo()
f.bar = 123
self.assertEqual(f, to_dict.decode_message(Foo, {"bar": 123}))
f = Foo()
f.bar = "meow"
self.assertEqual(f, to_dict.decode_message(Foo, {"bar": "meow"}))
f = Foo()
f.bar = True
self.assertEqual(f, to_dict.decode_message(Foo, {"bar": True}))
f = Foo()
f.bar = 1.23
self.assertEqual(f, to_dict.decode_message(Foo, {"bar": 1.23}))
f = Foo()
f.bar = 1.23
self.assertEqual(f, to_dict.decode_message(Foo, {"bar": 1.23}))
f = Foo()
f.bar = None
self.assertEqual(f, to_dict.decode_message(Foo, {"bar": None}))
f = Foo()
f.bar = [[123, 1.23, "woof", True], "meow"]
self.assertEqual(
f,
to_dict.decode_message(
Foo, {"bar": [[123, 1.23, "woof", True], "meow"]}))
def test_repeated_value_null_not_allowed(self):
class Foo(messages.Message):
pete = messages.StringField(repeated=True)
self.assertRaises(messages.ValidationError,
lambda: to_dict.decode_message(Foo, {"pete": None}))
def testDecodeCustom(self):
message = to_dict.decode_message(MyMessage, {"a_custom": 1})
self.assertEquals(MyMessage(a_custom=1), message)
def testDecodeRepeatedCustom(self):
message = to_dict.decode_message(
MyMessage, {"a_repeated_custom": [1, 2, 3]})
self.assertEquals(MyMessage(a_repeated_custom=[1, 2, 3]), message)
def testDecodeCustom(self):
message = to_dict.decode_message(MyMessage, {"a_custom": 1})
self.assertEqual(MyMessage(a_custom=1), message)
def test_repeated_value_null_not_allowed(self):
class Foo(messages.Message):
pete = messages.StringField(repeated=True)
self.assertRaises(messages.ValidationError, lambda: to_dict.decode_message(Foo, {"pete": None}))
def testDecodeRepeatedCustom(self):
message = to_dict.decode_message(MyMessage,
{"a_repeated_custom": [1, 2, 3]})
self.assertEqual(MyMessage(a_repeated_custom=[1, 2, 3]), message)
def testEmptyList(self):
"""Test that empty lists are not ignored."""
m = MyMessage()
m.a_repeated = []
self.assertEqual(m,
to_dict.decode_message(MyMessage, {"a_repeated": []}))
