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_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 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}'))