def testMergeEmptyString(self):
"""Test merging the empty or space only string."""
message = to_json.decode_message(test_util.OptionalMessage, '')
self.assertEquals(test_util.OptionalMessage(), message)
message = to_json.decode_message(test_util.OptionalMessage, ' ')
self.assertEquals(test_util.OptionalMessage(), message)
def testMergeEmptyString(self):
"""Test merging the empty or space only string."""
message = to_json.decode_message(test_util.OptionalMessage, '')
self.assertEqual(test_util.OptionalMessage(), message)
message = to_json.decode_message(test_util.OptionalMessage, ' ')
self.assertEqual(test_util.OptionalMessage(), message)
def test_dict_field_decode(self):
class GrabBag(messages.Message):
item_count = messages.IntegerField()
items = messages.DictField()
gb = GrabBag()
self.assertEquals(gb, to_json.decode_message(GrabBag, '{}'))
gb = GrabBag()
gb.item_count = 123
self.assertEquals(gb, to_json.decode_message(GrabBag, '{"item_count": 123}'))
gb = GrabBag()
gb.item_count = 123
gb.items = {}
self.assertEquals(gb, to_json.decode_message(GrabBag, '{"items": {}, "item_count": 123}'))
gb = GrabBag()
gb.item_count = 123
gb.items = {'a': 'b', 'foo': 'bar'}
self.assertEquals(gb, to_json.decode_message(GrabBag, '{"items": {"a": "b", "foo": "bar"}, "item_count": 123}'))
gb = GrabBag()
gb.items = {u'a': u"2010-11-13T14:15:16", u'b': u"01:02:03", u'c': u"2009-10-11"}
# Decode doesn't reverse dates in arbitrary dicts
self.assertEquals(gb, to_json.decode_message(GrabBag, '{"items": {"a": "2010-11-13T14:15:16", "b": "01:02:03", "c": "2009-10-11"}}'))
def test_dict_field_decode(self):
class GrabBag(messages.Message):
item_count = messages.IntegerField()
items = messages.DictField()
gb = GrabBag()
self.assertEqual(gb, to_json.decode_message(GrabBag, '{}'))
gb = GrabBag()
gb.item_count = 123
self.assertEqual(gb, to_json.decode_message(GrabBag, '{"item_count": 123}'))
gb = GrabBag()
gb.item_count = 123
gb.items = {}
self.assertEqual(gb, to_json.decode_message(GrabBag, '{"items": {}, "item_count": 123}'))
gb = GrabBag()
gb.item_count = 123
gb.items = {'a': 'b', 'foo': 'bar'}
self.assertEqual(gb, to_json.decode_message(GrabBag, '{"items": {"a": "b", "foo": "bar"}, "item_count": 123}'))
gb = GrabBag()
gb.items = {u'a': u"2010-11-13T14:15:16", u'b': u"01:02:03", u'c': u"2009-10-11"}
# Decode doesn't reverse dates in arbitrary dicts
self.assertEqual(gb, to_json.decode_message(GrabBag, '{"items": {"a": "2010-11-13T14:15:16", "b": "01:02:03", "c": "2009-10-11"}}'))
def test_has_value_assigned_repeated(self):
class Foo(messages.Message):
pete = messages.StringField(repeated=True)
message = to_json.decode_message(Foo, '{"pete": []}')
self.assertTrue(message.has_value_assigned('pete'))
message = to_json.decode_message(Foo, '{"pete": ["sat"]}')
self.assertTrue(message.has_value_assigned('pete'))
message = to_json.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_json.decode_message(Foo, '{"pete": []}')
self.assertTrue(message.has_value_assigned('pete'))
message = to_json.decode_message(Foo, '{"pete": ["sat"]}')
self.assertTrue(message.has_value_assigned('pete'))
message = to_json.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_json.decode_message(Foo, '{}'))
f = Foo()
f.bar = 123
self.assertEquals(f, to_json.decode_message(Foo, '{"bar": 123}'))
f = Foo()
f.bar = "meow"
self.assertEquals(f, to_json.decode_message(Foo, '{"bar": "meow"}'))
f = Foo()
f.bar = True
self.assertEquals(f, to_json.decode_message(Foo, '{"bar": true}'))
f = Foo()
f.bar = 1.23
self.assertEquals(f, to_json.decode_message(Foo, '{"bar": 1.23}'))
f = Foo()
f.bar = 1.23
self.assertEquals(f, to_json.decode_message(Foo, '{"bar": 1.23}'))
f = Foo()
f.bar = None
self.assertEquals(f, to_json.decode_message(Foo, '{"bar": null}'))
f = Foo()
f.bar = [[123, 1.23, "woof", True], "meow"]
self.assertEquals(f, to_json.decode_message(Foo, '{"bar": [[123, 1.23, "woof", true], "meow"]}'))
def test_untyped_field_decode(self):
class Foo(messages.Message):
bar = messages.UntypedField()
f = Foo()
self.assertEqual(f, to_json.decode_message(Foo, '{}'))
f = Foo()
f.bar = 123
self.assertEqual(f, to_json.decode_message(Foo, '{"bar": 123}'))
f = Foo()
f.bar = "meow"
self.assertEqual(f, to_json.decode_message(Foo, '{"bar": "meow"}'))
f = Foo()
f.bar = True
self.assertEqual(f, to_json.decode_message(Foo, '{"bar": true}'))
f = Foo()
f.bar = 1.23
self.assertEqual(f, to_json.decode_message(Foo, '{"bar": 1.23}'))
f = Foo()
f.bar = 1.23
self.assertEqual(f, to_json.decode_message(Foo, '{"bar": 1.23}'))
f = Foo()
f.bar = None
self.assertEqual(f, to_json.decode_message(Foo, '{"bar": null}'))
f = Foo()
f.bar = [[123, 1.23, "woof", True], "meow"]
self.assertEqual(f, to_json.decode_message(Foo, '{"bar": [[123, 1.23, "woof", true], "meow"]}'))
def testProtojsonUnrecognizedNull(self):
"""Test that unrecognized fields that are None are skipped."""
decoded = to_json.decode_message(
MyMessage,
'{"an_integer": 1, "unrecognized_null": null}')
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_json.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.assertEqual(m,
to_json.decode_message(MyMessage,
'{"a_repeated": []}'))
def test_uuid_field_decode_repeated(self):
from uuid import UUID
class Foo(messages.Message):
bar = messages.UUIDField(repeated=True)
f = Foo(bar=[UUID("11115e84-2872-4914-8c5d-3ed07d2a2f16"), UUID("22225e84-2872-4914-8c5d-3ed07d2a2f16")])
self.assertEqual(f, to_json.decode_message(Foo, '{"bar": ["11115e84-2872-4914-8c5d-3ed07d2a2f16", "22225e84-2872-4914-8c5d-3ed07d2a2f16"]}'))
def testProtojsonUnrecognizedNull(self):
"""Test that unrecognized fields that are None are skipped."""
decoded = to_json.decode_message(
MyMessage,
'{"an_integer": 1, "unrecognized_null": null}')
self.assertEqual(decoded.an_integer, 1)
self.assertEqual(decoded.all_unrecognized_fields(), [])
def testEmptyList(self):
"""Test that empty lists are not ignored."""
m = MyMessage()
m.a_repeated = []
self.assertEquals(m,
to_json.decode_message(MyMessage,
'{"a_repeated": []}'))
def test_uuid_field_decode(self):
from uuid import UUID
class Foo(messages.Message):
bar = messages.UUIDField()
f = Foo(bar=UUID("06335e84-2872-4914-8c5d-3ed07d2a2f16"))
self.assertEqual(f, to_json.decode_message(Foo, '{"bar": "06335e84-2872-4914-8c5d-3ed07d2a2f16"}'))
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_json.decode_message(Foo, '{"bar": [123, "woof", 1.23, true]}'))
def testNumericEnumeration(self):
"""Test that numbers work for enum values."""
message = to_json.decode_message(MyMessage, '{"an_enum": 2}')
expected_message = MyMessage()
expected_message.an_enum = MyMessage.Color.GREEN
self.assertEquals(expected_message, message)
def testNumericEnumeration(self):
"""Test that numbers work for enum values."""
message = to_json.decode_message(MyMessage, '{"an_enum": 2}')
expected_message = MyMessage()
expected_message.an_enum = MyMessage.Color.GREEN
self.assertEqual(expected_message, message)
def testProtojsonUnrecognizedFieldName(self):
"""Test that unrecognized fields are saved and can be accessed."""
decoded = to_json.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 testConvertIntegerToFloat(self):
"""Test that integers passed in to float fields are converted.
This is necessary because JSON outputs integers for numbers with 0 decimals.
"""
message = to_json.decode_message(MyMessage, '{"a_float": 10}')
self.assertTrue(isinstance(message.a_float, float))
self.assertEqual(10.0, message.a_float)
def testProtojsonUnrecognizedFieldName(self):
"""Test that unrecognized fields are saved and can be accessed."""
decoded = to_json.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 testConvertIntegerToFloat(self):
"""Test that integers passed in to float fields are converted.
This is necessary because JSON outputs integers for numbers with 0 decimals.
"""
message = to_json.decode_message(MyMessage, '{"a_float": 10}')
self.assertTrue(isinstance(message.a_float, float))
self.assertEquals(10.0, message.a_float)
def testDecodeDateTimeMsInteger(self):
for datetime_int, datetime_vals in (
(1349019110262, (2012, 9, 30, 15, 31, 50, 262000)),
(1349019110000, (2012, 9, 30, 15, 31, 50, 0))):
message = to_json.decode_message(
MyMessage, '{"a_datetime_ms_integer": %d}' % datetime_int)
expected_message = MyMessage(
a_datetime_ms_integer=datetime(*datetime_vals))
self.assertEqual(expected_message, message)
def testDecodeDateTimeMsInteger(self):
for datetime_int, datetime_vals in (
(1349019110262, (2012, 9, 30, 15, 31, 50, 262000)),
(1349019110000, (2012, 9, 30, 15, 31, 50, 0))):
message = to_json.decode_message(
MyMessage, '{"a_datetime_ms_integer": %d}' % datetime_int)
expected_message = MyMessage(
a_datetime_ms_integer=datetime(*datetime_vals))
self.assertEquals(expected_message, message)
def test_has_value_assigned(self):
class Foo(messages.Message):
not_set = messages.StringField()
set_null = messages.StringField()
message = to_json.decode_message(Foo, '{"set_null": null}')
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 testDecodeDateTime(self):
for datetime_string, datetime_vals in (
('2012-09-30T15:31:50.262', (2012, 9, 30, 15, 31, 50, 262000)),
('2012-09-30T15:31:50', (2012, 9, 30, 15, 31, 50, 0))):
message = to_json.decode_message(
MyMessage, '{"a_datetime_iso8601": "%s"}' % datetime_string)
expected_message = MyMessage(
a_datetime_iso8601=datetime(*datetime_vals))
self.assertEquals(expected_message, message)
def test_has_value_assigned(self):
class Foo(messages.Message):
not_set = messages.StringField()
set_null = messages.StringField()
message = to_json.decode_message(Foo, '{"set_null": null}')
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 testDecodeDateTime(self):
for datetime_string, datetime_vals in (
('2012-09-30T15:31:50.262', (2012, 9, 30, 15, 31, 50, 262000)),
('2012-09-30T15:31:50', (2012, 9, 30, 15, 31, 50, 0))):
message = to_json.decode_message(
MyMessage, '{"a_datetime_iso8601": "%s"}' % datetime_string)
expected_message = MyMessage(
a_datetime_iso8601=datetime(*datetime_vals))
self.assertEqual(expected_message, message)
def testNullValues(self):
"""Test that null values overwrite existing values."""
m = MyMessage()
m.an_integer = None
m.a_nested = None
self.assertEqual(m,
to_json.decode_message(MyMessage,
('{"an_integer": null,'
' "a_nested": null'
'}')))
def testNullValues(self):
"""Test that null values overwrite existing values."""
m = MyMessage()
m.an_integer = None
m.a_nested = None
self.assertEquals(m,
to_json.decode_message(MyMessage,
('{"an_integer": null,'
' "a_nested": null'
'}')))
def testDecodeRepeatedDateTimeISO8601(self):
message = to_json.decode_message(
MyMessage,
'{"a_repeated_datetime_iso8601": ["2012-09-30T15:31:50.262", '
'"2010-01-21T09:52:00", "2000-01-01T01:00:59.999999"]}')
expected_message = MyMessage(
a_repeated_datetime_iso8601=[
datetime(2012, 9, 30, 15, 31, 50, 262000),
datetime(2010, 1, 21, 9, 52),
datetime(2000, 1, 1, 1, 0, 59, 999999)])
self.assertEquals(expected_message, message)
def testDecodeRepeatedDateTimeMsInteger(self):
message = to_json.decode_message(
MyMessage,
'{"a_repeated_datetime_ms_integer": [1349019110262, '
'1264067520000, 946688459999]}')
expected_message = MyMessage(
a_repeated_datetime_ms_integer=[
datetime(2012, 9, 30, 15, 31, 50, 262000),
datetime(2010, 1, 21, 9, 52),
datetime(2000, 1, 1, 1, 0, 59, 999000)])
self.assertEquals(expected_message, message)
def testDecodeRepeatedDateTimeISO8601(self):
message = to_json.decode_message(
MyMessage,
'{"a_repeated_datetime_iso8601": ["2012-09-30T15:31:50.262", '
'"2010-01-21T09:52:00", "2000-01-01T01:00:59.999999"]}')
expected_message = MyMessage(
a_repeated_datetime_iso8601=[
datetime(2012, 9, 30, 15, 31, 50, 262000),
datetime(2010, 1, 21, 9, 52),
datetime(2000, 1, 1, 1, 0, 59, 999999)])
self.assertEqual(expected_message, message)
def testDecodeRepeatedDateTimeMsInteger(self):
message = to_json.decode_message(
MyMessage,
'{"a_repeated_datetime_ms_integer": [1349019110262, '
'1264067520000, 946688459999]}')
expected_message = MyMessage(
a_repeated_datetime_ms_integer=[
datetime(2012, 9, 30, 15, 31, 50, 262000),
datetime(2010, 1, 21, 9, 52),
datetime(2000, 1, 1, 1, 0, 59, 999000)])
self.assertEqual(expected_message, message)
def testConvertStringToNumbers(self):
"""Test that strings passed to integer fields are converted."""
message = to_json.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 testConvertStringToNumbers(self):
"""Test that strings passed to integer fields are converted."""
message = to_json.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_json.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(json.loads('{"robert": "smith", "ryan": "morlok"}'), json.loads(to_json.encode_message(f)))
def test_explicit_field_name(self):
class Foo(messages.Message):
bob = messages.StringField(name="robert")
ryan = messages.StringField()
m = to_json.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_json.encode_message(f))
def testProtojsonUnrecognizedFieldNumber(self):
"""Test that unrecognized fields are saved and can be accessed."""
decoded = to_json.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 testProtojsonUnrecognizedFieldNumber(self):
"""Test that unrecognized fields are saved and can be accessed."""
decoded = to_json.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 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_json.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 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_json.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 test_uuid_field_decode_bad(self):
class Foo(messages.Message):
bar = messages.UUIDField()
with self.assertRaises(messages.DecodeError):
to_json.decode_message(Foo, '{"bar": "bad"}')
def testDecodeRepeatedCustom(self):
message = to_json.decode_message(
MyMessage, '{"a_repeated_custom": [1, 2, 3]}')
self.assertEquals(MyMessage(a_repeated_custom=[1, 2, 3]), message)
def testDecodeCustom(self):
message = to_json.decode_message(MyMessage, '{"a_custom": 1}')
self.assertEquals(MyMessage(a_custom=1), message)
def testDecodeRepeatedCustom(self):
message = to_json.decode_message(
MyMessage, '{"a_repeated_custom": [1, 2, 3]}')
self.assertEqual(MyMessage(a_repeated_custom=[1, 2, 3]), message)
def testDecodeCustom(self):
message = to_json.decode_message(MyMessage, '{"a_custom": 1}')
self.assertEqual(MyMessage(a_custom=1), message)
def test_uuid_field_decode_bad_repeated(self):
class Foo(messages.Message):
bar = messages.UUIDField(repeated=True)
with self.assertRaises(messages.DecodeError):
to_json.decode_message(Foo, '{"bar": ["06335e84-2872-4914-8c5d-3ed07d2a2f16", "bad"]}')
def test_repeated_value_null_not_allowed(self):
class Foo(messages.Message):
pete = messages.StringField(repeated=True)
self.assertRaises(messages.ValidationError, lambda: to_json.decode_message(Foo, '{"pete": null}'))
def test_repeated_value_null_not_allowed(self):
class Foo(messages.Message):
pete = messages.StringField(repeated=True)
self.assertRaises(messages.ValidationError, lambda: to_json.decode_message(Foo, '{"pete": null}'))
