| # Protocol Buffers - Google's data interchange format |
| # Copyright 2008 Google Inc. All rights reserved. |
| # |
| # Use of this source code is governed by a BSD-style |
| # license that can be found in the LICENSE file or at |
| # https://developers.google.com/open-source/licenses/bsd |
| |
| """Test for google.protobuf.json_format.""" |
| |
| __author__ = 'jieluo@google.com (Jie Luo)' |
| |
| import json |
| import math |
| import struct |
| import unittest |
| |
| from google.protobuf import descriptor_pool |
| from google.protobuf import json_format |
| from google.protobuf.internal import more_messages_pb2 |
| from google.protobuf.internal import test_proto2_pb2 |
| from google.protobuf.internal import test_proto3_optional_pb2 |
| |
| from google.protobuf import any_pb2 |
| from google.protobuf import duration_pb2 |
| from google.protobuf import field_mask_pb2 |
| from google.protobuf import struct_pb2 |
| from google.protobuf import timestamp_pb2 |
| from google.protobuf import wrappers_pb2 |
| from google.protobuf import any_test_pb2 |
| from google.protobuf import unittest_mset_pb2 |
| from google.protobuf import unittest_pb2 |
| from google.protobuf.util import json_format_pb2 |
| from google.protobuf.util import json_format_proto3_pb2 |
| |
| |
| class JsonFormatBase(unittest.TestCase): |
| |
| def FillAllFields(self, message): |
| message.int32_value = 20 |
| message.int64_value = -20 |
| message.uint32_value = 3120987654 |
| message.uint64_value = 12345678900 |
| message.float_value = float('-inf') |
| message.double_value = 3.1415 |
| message.bool_value = True |
| message.string_value = 'foo' |
| message.bytes_value = b'bar' |
| message.message_value.value = 10 |
| message.enum_value = json_format_proto3_pb2.BAR |
| # Repeated |
| message.repeated_int32_value.append(0x7FFFFFFF) |
| message.repeated_int32_value.append(-2147483648) |
| message.repeated_int64_value.append(9007199254740992) |
| message.repeated_int64_value.append(-9007199254740992) |
| message.repeated_uint32_value.append(0xFFFFFFF) |
| message.repeated_uint32_value.append(0x7FFFFFF) |
| message.repeated_uint64_value.append(9007199254740992) |
| message.repeated_uint64_value.append(9007199254740991) |
| message.repeated_float_value.append(0) |
| |
| message.repeated_double_value.append(1e-15) |
| message.repeated_double_value.append(float('inf')) |
| message.repeated_bool_value.append(True) |
| message.repeated_bool_value.append(False) |
| message.repeated_string_value.append('Few symbols!#$,;') |
| message.repeated_string_value.append('bar') |
| message.repeated_bytes_value.append(b'foo') |
| message.repeated_bytes_value.append(b'bar') |
| message.repeated_message_value.add().value = 10 |
| message.repeated_message_value.add().value = 11 |
| message.repeated_enum_value.append(json_format_proto3_pb2.FOO) |
| message.repeated_enum_value.append(json_format_proto3_pb2.BAR) |
| self.message = message |
| |
| def CheckParseBack(self, message, parsed_message): |
| json_format.Parse(json_format.MessageToJson(message), parsed_message) |
| self.assertEqual(message, parsed_message) |
| |
| def CheckError(self, text, error_message): |
| message = json_format_proto3_pb2.TestMessage() |
| self.assertRaisesRegex( |
| json_format.ParseError, error_message, json_format.Parse, text, message |
| ) |
| |
| |
| class JsonFormatTest(JsonFormatBase): |
| |
| def testEmptyMessageToJson(self): |
| message = json_format_proto3_pb2.TestMessage() |
| self.assertEqual(json_format.MessageToJson(message), '{}') |
| parsed_message = json_format_proto3_pb2.TestMessage() |
| self.CheckParseBack(message, parsed_message) |
| |
| def testPartialMessageToJson(self): |
| message = json_format_proto3_pb2.TestMessage( |
| string_value='test', repeated_int32_value=[89, 4] |
| ) |
| self.assertEqual( |
| json.loads(json_format.MessageToJson(message)), |
| json.loads('{"stringValue": "test", "repeatedInt32Value": [89, 4]}'), |
| ) |
| parsed_message = json_format_proto3_pb2.TestMessage() |
| self.CheckParseBack(message, parsed_message) |
| |
| def testAllFieldsToJson(self): |
| message = json_format_proto3_pb2.TestMessage() |
| text = ( |
| '{"int32Value": 20, ' |
| '"int64Value": "-20", ' |
| '"uint32Value": 3120987654,' |
| '"uint64Value": "12345678900",' |
| '"floatValue": "-Infinity",' |
| '"doubleValue": 3.1415,' |
| '"boolValue": true,' |
| '"stringValue": "foo",' |
| '"bytesValue": "YmFy",' |
| '"messageValue": {"value": 10},' |
| '"enumValue": "BAR",' |
| '"repeatedInt32Value": [2147483647, -2147483648],' |
| '"repeatedInt64Value": ["9007199254740992", "-9007199254740992"],' |
| '"repeatedUint32Value": [268435455, 134217727],' |
| '"repeatedUint64Value": ["9007199254740992", "9007199254740991"],' |
| '"repeatedFloatValue": [0],' |
| '"repeatedDoubleValue": [1e-15, "Infinity"],' |
| '"repeatedBoolValue": [true, false],' |
| '"repeatedStringValue": ["Few symbols!#$,;", "bar"],' |
| '"repeatedBytesValue": ["Zm9v", "YmFy"],' |
| '"repeatedMessageValue": [{"value": 10}, {"value": 11}],' |
| '"repeatedEnumValue": ["FOO", "BAR"]' |
| '}' |
| ) |
| self.FillAllFields(message) |
| self.assertEqual( |
| json.loads(json_format.MessageToJson(message)), json.loads(text) |
| ) |
| parsed_message = json_format_proto3_pb2.TestMessage() |
| json_format.Parse(text, parsed_message) |
| self.assertEqual(message, parsed_message) |
| |
| def testUnknownEnumToJsonAndBack(self): |
| text = '{\n "enumValue": 999\n}' |
| message = json_format_proto3_pb2.TestMessage() |
| message.enum_value = 999 |
| self.assertEqual(json_format.MessageToJson(message), text) |
| parsed_message = json_format_proto3_pb2.TestMessage() |
| json_format.Parse(text, parsed_message) |
| self.assertEqual(message, parsed_message) |
| |
| def testExtensionToJsonAndBack(self): |
| message = unittest_mset_pb2.TestMessageSetContainer() |
| ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension |
| ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension |
| message.message_set.Extensions[ext1].i = 23 |
| message.message_set.Extensions[ext2].str = 'foo' |
| message_text = json_format.MessageToJson(message) |
| parsed_message = unittest_mset_pb2.TestMessageSetContainer() |
| json_format.Parse(message_text, parsed_message) |
| self.assertEqual(message, parsed_message) |
| |
| def testExtensionErrors(self): |
| self.CheckError( |
| '{"[extensionField]": {}}', |
| 'Message type proto3.TestMessage does not have extensions', |
| ) |
| |
| def testExtensionToDictAndBack(self): |
| message = unittest_mset_pb2.TestMessageSetContainer() |
| ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension |
| ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension |
| message.message_set.Extensions[ext1].i = 23 |
| message.message_set.Extensions[ext2].str = 'foo' |
| message_dict = json_format.MessageToDict(message) |
| parsed_message = unittest_mset_pb2.TestMessageSetContainer() |
| json_format.ParseDict(message_dict, parsed_message) |
| self.assertEqual(message, parsed_message) |
| |
| def testExtensionToDictAndBackWithScalar(self): |
| message = unittest_pb2.TestAllExtensions() |
| ext1 = unittest_pb2.TestNestedExtension.test |
| message.Extensions[ext1] = 'data' |
| message_dict = json_format.MessageToDict(message) |
| parsed_message = unittest_pb2.TestAllExtensions() |
| json_format.ParseDict(message_dict, parsed_message) |
| self.assertEqual(message, parsed_message) |
| |
| def testJsonParseDictToAnyDoesNotAlterInput(self): |
| orig_dict = { |
| 'int32Value': 20, |
| '@type': 'type.googleapis.com/proto3.TestMessage', |
| } |
| copied_dict = json.loads(json.dumps(orig_dict)) |
| parsed_message = any_pb2.Any() |
| json_format.ParseDict(copied_dict, parsed_message) |
| self.assertEqual(copied_dict, orig_dict) |
| |
| def testExtensionSerializationDictMatchesProto3Spec(self): |
| """See go/proto3-json-spec for spec.""" |
| message = unittest_mset_pb2.TestMessageSetContainer() |
| ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension |
| ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension |
| message.message_set.Extensions[ext1].i = 23 |
| message.message_set.Extensions[ext2].str = 'foo' |
| message_dict = json_format.MessageToDict(message) |
| golden_dict = { |
| 'messageSet': { |
| '[protobuf_unittest.TestMessageSetExtension1.message_set_extension]': { |
| 'i': 23, |
| }, |
| '[protobuf_unittest.TestMessageSetExtension2.message_set_extension]': { |
| 'str': 'foo', |
| }, |
| }, |
| } |
| self.assertEqual(golden_dict, message_dict) |
| parsed_msg = unittest_mset_pb2.TestMessageSetContainer() |
| json_format.ParseDict(golden_dict, parsed_msg) |
| self.assertEqual(message, parsed_msg) |
| |
| def testExtensionSerializationDictMatchesProto3SpecMore(self): |
| """See go/proto3-json-spec for spec.""" |
| message = json_format_pb2.TestMessageWithExtension() |
| ext = json_format_pb2.TestExtension.ext |
| message.Extensions[ext].value = 'stuff' |
| message_dict = json_format.MessageToDict(message) |
| expected_dict = { |
| '[protobuf_unittest.TestExtension.ext]': { |
| 'value': 'stuff', |
| }, |
| } |
| self.assertEqual(expected_dict, message_dict) |
| |
| def testExtensionSerializationJsonMatchesProto3Spec(self): |
| """See go/proto3-json-spec for spec.""" |
| message = unittest_mset_pb2.TestMessageSetContainer() |
| ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension |
| ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension |
| message.message_set.Extensions[ext1].i = 23 |
| message.message_set.Extensions[ext2].str = 'foo' |
| message_text = json_format.MessageToJson(message) |
| ext1_text = 'protobuf_unittest.TestMessageSetExtension1.message_set_extension' |
| ext2_text = 'protobuf_unittest.TestMessageSetExtension2.message_set_extension' |
| golden_text = ( |
| '{"messageSet": {' |
| ' "[%s]": {' |
| ' "i": 23' |
| ' },' |
| ' "[%s]": {' |
| ' "str": "foo"' |
| ' }' |
| '}}' |
| ) % (ext1_text, ext2_text) |
| self.assertEqual(json.loads(golden_text), json.loads(message_text)) |
| |
| def testJsonEscapeString(self): |
| message = json_format_proto3_pb2.TestMessage() |
| message.string_value = '&\n<"\r>\b\t\f\\\001/' |
| message.string_value += (b'\xe2\x80\xa8\xe2\x80\xa9').decode('utf-8') |
| self.assertEqual( |
| json_format.MessageToJson(message), |
| '{\n "stringValue": ' |
| '"&\\n<\\"\\r>\\b\\t\\f\\\\\\u0001/\\u2028\\u2029"\n}', |
| ) |
| parsed_message = json_format_proto3_pb2.TestMessage() |
| self.CheckParseBack(message, parsed_message) |
| text = '{"int32Value": "\u0031"}' |
| json_format.Parse(text, message) |
| self.assertEqual(message.int32_value, 1) |
| |
| def testProto3Optional_IncludingDefaultValueWithoutPresenceFields(self): |
| message = test_proto3_optional_pb2.TestProto3Optional() |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads('{"repeatedInt32": [], "repeatedNestedMessage": []}'), |
| ) |
| message.optional_int32 = 0 |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{"optionalInt32": 0,"repeatedInt32": [],' |
| ' "repeatedNestedMessage": []}' |
| ), |
| ) |
| |
| def testProto2_IncludingDefaultValueWithoutPresenceFields(self): |
| message = test_proto2_pb2.TestProto2() |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads('{"repeatedInt32": [], "repeatedNestedMessage": []}'), |
| ) |
| message.optional_int32 = 0 |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{"optionalInt32": 0,"repeatedInt32": [],' |
| ' "repeatedNestedMessage": []}' |
| ), |
| ) |
| |
| def testIntegersRepresentedAsFloat(self): |
| message = json_format_proto3_pb2.TestMessage() |
| json_format.Parse('{"int32Value": -2.147483648e9}', message) |
| self.assertEqual(message.int32_value, -2147483648) |
| json_format.Parse('{"int32Value": 1e5}', message) |
| self.assertEqual(message.int32_value, 100000) |
| json_format.Parse('{"int32Value": 1.0}', message) |
| self.assertEqual(message.int32_value, 1) |
| |
| def testMapFields(self): |
| message = json_format_proto3_pb2.TestNestedMap() |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{' |
| '"boolMap": {},' |
| '"int32Map": {},' |
| '"int64Map": {},' |
| '"uint32Map": {},' |
| '"uint64Map": {},' |
| '"stringMap": {},' |
| '"mapMap": {}' |
| '}' |
| ), |
| ) |
| message.bool_map[True] = 1 |
| message.bool_map[False] = 2 |
| message.int32_map[1] = 2 |
| message.int32_map[2] = 3 |
| message.int64_map[1] = 2 |
| message.int64_map[2] = 3 |
| message.uint32_map[1] = 2 |
| message.uint32_map[2] = 3 |
| message.uint64_map[1] = 2 |
| message.uint64_map[2] = 3 |
| message.string_map['1'] = 2 |
| message.string_map['null'] = 3 |
| message.map_map['1'].bool_map[True] = 3 |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=False |
| ) |
| ), |
| json.loads( |
| '{' |
| '"boolMap": {"false": 2, "true": 1},' |
| '"int32Map": {"1": 2, "2": 3},' |
| '"int64Map": {"1": 2, "2": 3},' |
| '"uint32Map": {"1": 2, "2": 3},' |
| '"uint64Map": {"1": 2, "2": 3},' |
| '"stringMap": {"1": 2, "null": 3},' |
| '"mapMap": {"1": {"boolMap": {"true": 3}}}' |
| '}' |
| ), |
| ) |
| parsed_message = json_format_proto3_pb2.TestNestedMap() |
| self.CheckParseBack(message, parsed_message) |
| |
| def testOneofFields(self): |
| message = json_format_proto3_pb2.TestOneof() |
| # Always print does not affect oneof fields. |
| self.assertEqual( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ), |
| '{}', |
| ) |
| message.oneof_int32_value = 0 |
| self.assertEqual( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ), |
| '{\n "oneofInt32Value": 0\n}', |
| ) |
| parsed_message = json_format_proto3_pb2.TestOneof() |
| self.CheckParseBack(message, parsed_message) |
| |
| def testSurrogates(self): |
| # Test correct surrogate handling. |
| message = json_format_proto3_pb2.TestMessage() |
| json_format.Parse('{"stringValue": "\\uD83D\\uDE01"}', message) |
| self.assertEqual( |
| message.string_value, b'\xF0\x9F\x98\x81'.decode('utf-8', 'strict') |
| ) |
| |
| # Error case: unpaired high surrogate. |
| self.CheckError( |
| '{"stringValue": "\\uD83D"}', |
| r'Invalid \\uXXXX escape|Unpaired.*surrogate', |
| ) |
| |
| # Unpaired low surrogate. |
| self.CheckError( |
| '{"stringValue": "\\uDE01"}', |
| r'Invalid \\uXXXX escape|Unpaired.*surrogate', |
| ) |
| |
| def testTimestampMessage(self): |
| message = json_format_proto3_pb2.TestTimestamp() |
| message.value.seconds = 0 |
| message.value.nanos = 0 |
| message.repeated_value.add().seconds = 20 |
| message.repeated_value[0].nanos = 1 |
| message.repeated_value.add().seconds = 0 |
| message.repeated_value[1].nanos = 10000 |
| message.repeated_value.add().seconds = 100000000 |
| message.repeated_value[2].nanos = 0 |
| # Maximum time |
| message.repeated_value.add().seconds = 253402300799 |
| message.repeated_value[3].nanos = 999999999 |
| # Minimum time |
| message.repeated_value.add().seconds = -62135596800 |
| message.repeated_value[4].nanos = 0 |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{' |
| '"value": "1970-01-01T00:00:00Z",' |
| '"repeatedValue": [' |
| ' "1970-01-01T00:00:20.000000001Z",' |
| ' "1970-01-01T00:00:00.000010Z",' |
| ' "1973-03-03T09:46:40Z",' |
| ' "9999-12-31T23:59:59.999999999Z",' |
| ' "0001-01-01T00:00:00Z"' |
| ']' |
| '}' |
| ), |
| ) |
| parsed_message = json_format_proto3_pb2.TestTimestamp() |
| self.CheckParseBack(message, parsed_message) |
| text = ( |
| r'{"value": "1970-01-01T00:00:00.01+08:00",' |
| r'"repeatedValue":[' |
| r' "1970-01-01T00:00:00.01+08:30",' |
| r' "1970-01-01T00:00:00.01-01:23"]}' |
| ) |
| json_format.Parse(text, parsed_message) |
| self.assertEqual(parsed_message.value.seconds, -8 * 3600) |
| self.assertEqual(parsed_message.value.nanos, 10000000) |
| self.assertEqual(parsed_message.repeated_value[0].seconds, -8.5 * 3600) |
| self.assertEqual(parsed_message.repeated_value[1].seconds, 3600 + 23 * 60) |
| |
| def testDurationMessage(self): |
| message = json_format_proto3_pb2.TestDuration() |
| message.value.seconds = 1 |
| message.repeated_value.add().seconds = 0 |
| message.repeated_value[0].nanos = 10 |
| message.repeated_value.add().seconds = -1 |
| message.repeated_value[1].nanos = -1000 |
| message.repeated_value.add().seconds = 10 |
| message.repeated_value[2].nanos = 11000000 |
| message.repeated_value.add().seconds = -315576000000 |
| message.repeated_value.add().seconds = 315576000000 |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{' |
| '"value": "1s",' |
| '"repeatedValue": [' |
| ' "0.000000010s",' |
| ' "-1.000001s",' |
| ' "10.011s",' |
| ' "-315576000000s",' |
| ' "315576000000s"' |
| ']' |
| '}' |
| ), |
| ) |
| parsed_message = json_format_proto3_pb2.TestDuration() |
| self.CheckParseBack(message, parsed_message) |
| |
| def testFieldMaskMessage(self): |
| message = json_format_proto3_pb2.TestFieldMask() |
| message.value.paths.append('foo.bar') |
| message.value.paths.append('bar') |
| self.assertEqual( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ), |
| '{\n "value": "foo.bar,bar"\n}', |
| ) |
| parsed_message = json_format_proto3_pb2.TestFieldMask() |
| self.CheckParseBack(message, parsed_message) |
| |
| message.value.Clear() |
| self.assertEqual( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ), |
| '{\n "value": ""\n}', |
| ) |
| self.CheckParseBack(message, parsed_message) |
| |
| def testWrapperMessage(self): |
| message = json_format_proto3_pb2.TestWrapper() |
| message.bool_value.value = False |
| message.int32_value.value = 0 |
| message.string_value.value = '' |
| message.bytes_value.value = b'' |
| message.repeated_bool_value.add().value = True |
| message.repeated_bool_value.add().value = False |
| message.repeated_int32_value.add() |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{\n' |
| ' "int32Value": 0,' |
| ' "boolValue": false,' |
| ' "stringValue": "",' |
| ' "bytesValue": "",' |
| ' "repeatedBoolValue": [true, false],' |
| ' "repeatedInt32Value": [0],' |
| ' "repeatedUint32Value": [],' |
| ' "repeatedFloatValue": [],' |
| ' "repeatedDoubleValue": [],' |
| ' "repeatedBytesValue": [],' |
| ' "repeatedInt64Value": [],' |
| ' "repeatedUint64Value": [],' |
| ' "repeatedStringValue": []' |
| '}' |
| ), |
| ) |
| parsed_message = json_format_proto3_pb2.TestWrapper() |
| self.CheckParseBack(message, parsed_message) |
| |
| def testStructMessage(self): |
| message = json_format_proto3_pb2.TestStruct() |
| message.value['name'] = 'Jim' |
| message.value['age'] = 10 |
| message.value['attend'] = True |
| message.value['email'] = None |
| message.value.get_or_create_struct('address')['city'] = 'SFO' |
| message.value['address']['house_number'] = 1024 |
| message.value.get_or_create_struct('empty_struct') |
| message.value.get_or_create_list('empty_list') |
| struct_list = message.value.get_or_create_list('list') |
| struct_list.extend([6, 'seven', True, False, None]) |
| struct_list.add_struct()['subkey2'] = 9 |
| message.repeated_value.add()['age'] = 11 |
| message.repeated_value.add() |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=False |
| ) |
| ), |
| json.loads( |
| '{' |
| ' "value": {' |
| ' "address": {' |
| ' "city": "SFO", ' |
| ' "house_number": 1024' |
| ' }, ' |
| ' "empty_struct": {}, ' |
| ' "empty_list": [], ' |
| ' "age": 10, ' |
| ' "name": "Jim", ' |
| ' "attend": true, ' |
| ' "email": null, ' |
| ' "list": [6, "seven", true, false, null, {"subkey2": 9}]' |
| ' },' |
| ' "repeatedValue": [{"age": 11}, {}]' |
| '}' |
| ), |
| ) |
| parsed_message = json_format_proto3_pb2.TestStruct() |
| self.CheckParseBack(message, parsed_message) |
| # check for regression; this used to raise |
| parsed_message.value['empty_struct'] |
| parsed_message.value['empty_list'] |
| |
| def testValueMessage(self): |
| message = json_format_proto3_pb2.TestValue() |
| message.value.string_value = 'hello' |
| message.repeated_value.add().number_value = 11.1 |
| message.repeated_value.add().bool_value = False |
| message.repeated_value.add().null_value = 0 |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=False |
| ) |
| ), |
| json.loads( |
| '{ "value": "hello", "repeatedValue": [11.1, false, null]}' |
| ), |
| ) |
| parsed_message = json_format_proto3_pb2.TestValue() |
| self.CheckParseBack(message, parsed_message) |
| # Can't parse back if the Value message is not set. |
| message.repeated_value.add() |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=False |
| ) |
| ), |
| json.loads( |
| '{ "value": "hello", "repeatedValue": [11.1, false, null, null]}' |
| ), |
| ) |
| message.Clear() |
| json_format.Parse('{"value": null}', message) |
| self.assertEqual(message.value.WhichOneof('kind'), 'null_value') |
| |
| def testValueMessageErrors(self): |
| message = json_format_proto3_pb2.TestValue() |
| message.value.number_value = math.inf |
| with self.assertRaises(json_format.SerializeToJsonError) as cm: |
| json_format.MessageToJson(message) |
| self.assertEqual( |
| 'Failed to serialize value field: Fail to serialize Infinity for ' |
| 'Value.number_value, which would parse as string_value.', |
| str(cm.exception), |
| ) |
| message.value.number_value = math.nan |
| with self.assertRaises(json_format.SerializeToJsonError) as cm: |
| json_format.MessageToJson(message) |
| self.assertEqual( |
| 'Failed to serialize value field: Fail to serialize NaN for ' |
| 'Value.number_value, which would parse as string_value.', |
| str(cm.exception), |
| ) |
| |
| def testListValueMessage(self): |
| message = json_format_proto3_pb2.TestListValue() |
| message.value.values.add().number_value = 11.1 |
| message.value.values.add().null_value = 0 |
| message.value.values.add().bool_value = True |
| message.value.values.add().string_value = 'hello' |
| message.value.values.add().struct_value['name'] = 'Jim' |
| message.repeated_value.add().values.add().number_value = 1 |
| message.repeated_value.add() |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=False |
| ) |
| ), |
| json.loads( |
| '{"value": [11.1, null, true, "hello", {"name": "Jim"}]\n,' |
| '"repeatedValue": [[1], []]}' |
| ), |
| ) |
| parsed_message = json_format_proto3_pb2.TestListValue() |
| self.CheckParseBack(message, parsed_message) |
| |
| def testNullValue(self): |
| message = json_format_proto3_pb2.TestOneof() |
| message.oneof_null_value = 0 |
| self.assertEqual( |
| json_format.MessageToJson(message), '{\n "oneofNullValue": null\n}' |
| ) |
| parsed_message = json_format_proto3_pb2.TestOneof() |
| self.CheckParseBack(message, parsed_message) |
| # Check old format is also accepted |
| new_message = json_format_proto3_pb2.TestOneof() |
| json_format.Parse('{\n "oneofNullValue": "NULL_VALUE"\n}', new_message) |
| self.assertEqual( |
| json_format.MessageToJson(new_message), '{\n "oneofNullValue": null\n}' |
| ) |
| |
| def testAnyMessage(self): |
| message = json_format_proto3_pb2.TestAny() |
| value1 = json_format_proto3_pb2.MessageType() |
| value2 = json_format_proto3_pb2.MessageType() |
| value1.value = 1234 |
| value2.value = 5678 |
| message.value.Pack(value1) |
| message.repeated_value.add().Pack(value1) |
| message.repeated_value.add().Pack(value2) |
| message.repeated_value.add() |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{\n' |
| ' "repeatedValue": [ {\n' |
| ' "@type": "type.googleapis.com/proto3.MessageType",\n' |
| ' "value": 1234\n' |
| ' }, {\n' |
| ' "@type": "type.googleapis.com/proto3.MessageType",\n' |
| ' "value": 5678\n' |
| ' },\n' |
| ' {}],\n' |
| ' "value": {\n' |
| ' "@type": "type.googleapis.com/proto3.MessageType",\n' |
| ' "value": 1234\n' |
| ' }\n' |
| '}\n' |
| ), |
| ) |
| parsed_message = json_format_proto3_pb2.TestAny() |
| self.CheckParseBack(message, parsed_message) |
| # Must print @type first |
| test_message = json_format_proto3_pb2.TestMessage( |
| bool_value=True, |
| int32_value=20, |
| int64_value=-20, |
| uint32_value=20, |
| uint64_value=20, |
| double_value=3.14, |
| string_value='foo', |
| ) |
| message.Clear() |
| message.value.Pack(test_message) |
| self.assertEqual( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=False |
| )[0:68], |
| '{\n' |
| ' "value": {\n' |
| ' "@type": "type.googleapis.com/proto3.TestMessage"', |
| ) |
| |
| def testAnyMessageDescriptorPoolMissingType(self): |
| packed_message = unittest_pb2.OneString() |
| packed_message.data = 'string' |
| message = any_test_pb2.TestAny() |
| message.any_value.Pack(packed_message) |
| empty_pool = descriptor_pool.DescriptorPool() |
| with self.assertRaises(TypeError) as cm: |
| json_format.MessageToJson( |
| message, |
| always_print_fields_with_no_presence=True, |
| descriptor_pool=empty_pool, |
| ) |
| self.assertEqual( |
| 'Can not find message descriptor by type_url:' |
| ' type.googleapis.com/protobuf_unittest.OneString', |
| str(cm.exception), |
| ) |
| |
| def testWellKnownInAnyMessage(self): |
| message = any_pb2.Any() |
| int32_value = wrappers_pb2.Int32Value() |
| int32_value.value = 1234 |
| message.Pack(int32_value) |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{\n' |
| ' "@type": "type.googleapis.com/google.protobuf.Int32Value",\n' |
| ' "value": 1234\n' |
| '}\n' |
| ), |
| ) |
| parsed_message = any_pb2.Any() |
| self.CheckParseBack(message, parsed_message) |
| |
| timestamp = timestamp_pb2.Timestamp() |
| message.Pack(timestamp) |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{\n' |
| ' "@type": "type.googleapis.com/google.protobuf.Timestamp",\n' |
| ' "value": "1970-01-01T00:00:00Z"\n' |
| '}\n' |
| ), |
| ) |
| self.CheckParseBack(message, parsed_message) |
| |
| duration = duration_pb2.Duration() |
| duration.seconds = 1 |
| message.Pack(duration) |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{\n' |
| ' "@type": "type.googleapis.com/google.protobuf.Duration",\n' |
| ' "value": "1s"\n' |
| '}\n' |
| ), |
| ) |
| self.CheckParseBack(message, parsed_message) |
| |
| field_mask = field_mask_pb2.FieldMask() |
| field_mask.paths.append('foo.bar') |
| field_mask.paths.append('bar') |
| message.Pack(field_mask) |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{\n' |
| ' "@type": "type.googleapis.com/google.protobuf.FieldMask",\n' |
| ' "value": "foo.bar,bar"\n' |
| '}\n' |
| ), |
| ) |
| self.CheckParseBack(message, parsed_message) |
| |
| struct_message = struct_pb2.Struct() |
| struct_message['name'] = 'Jim' |
| message.Pack(struct_message) |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{\n' |
| ' "@type": "type.googleapis.com/google.protobuf.Struct",\n' |
| ' "value": {"name": "Jim"}\n' |
| '}\n' |
| ), |
| ) |
| self.CheckParseBack(message, parsed_message) |
| |
| nested_any = any_pb2.Any() |
| int32_value.value = 5678 |
| nested_any.Pack(int32_value) |
| message.Pack(nested_any) |
| self.assertEqual( |
| json.loads( |
| json_format.MessageToJson( |
| message, always_print_fields_with_no_presence=True |
| ) |
| ), |
| json.loads( |
| '{\n' |
| ' "@type": "type.googleapis.com/google.protobuf.Any",\n' |
| ' "value": {\n' |
| ' "@type": "type.googleapis.com/google.protobuf.Int32Value",\n' |
| ' "value": 5678\n' |
| ' }\n' |
| '}\n' |
| ), |
| ) |
| self.CheckParseBack(message, parsed_message) |
| |
| def testParseNull(self): |
| message = json_format_proto3_pb2.TestMessage() |
| parsed_message = json_format_proto3_pb2.TestMessage() |
| self.FillAllFields(parsed_message) |
| json_format.Parse( |
| '{"int32Value": null, ' |
| '"int64Value": null, ' |
| '"uint32Value": null,' |
| '"uint64Value": null,' |
| '"floatValue": null,' |
| '"doubleValue": null,' |
| '"boolValue": null,' |
| '"stringValue": null,' |
| '"bytesValue": null,' |
| '"messageValue": null,' |
| '"enumValue": null,' |
| '"repeatedInt32Value": null,' |
| '"repeatedInt64Value": null,' |
| '"repeatedUint32Value": null,' |
| '"repeatedUint64Value": null,' |
| '"repeatedFloatValue": null,' |
| '"repeatedDoubleValue": null,' |
| '"repeatedBoolValue": null,' |
| '"repeatedStringValue": null,' |
| '"repeatedBytesValue": null,' |
| '"repeatedMessageValue": null,' |
| '"repeatedEnumValue": null' |
| '}', |
| parsed_message, |
| ) |
| self.assertEqual(message, parsed_message) |
| # Null and {} should have different behavior for sub message. |
| self.assertFalse(parsed_message.HasField('message_value')) |
| json_format.Parse('{"messageValue": {}}', parsed_message) |
| self.assertTrue(parsed_message.HasField('message_value')) |
| # Null is not allowed to be used as an element in repeated field. |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| r'Failed to parse repeatedInt32Value field: ' |
| r'null is not allowed to be used as an element in a repeated field ' |
| r'at TestMessage.repeatedInt32Value\[1\].', |
| json_format.Parse, |
| '{"repeatedInt32Value":[1, null]}', |
| parsed_message, |
| ) |
| self.CheckError( |
| '{"repeatedMessageValue":[null]}', |
| r'Failed to parse repeatedMessageValue field: null is not' |
| r' allowed to be used as an element in a repeated field ' |
| r'at TestMessage.repeatedMessageValue\[0\].', |
| ) |
| |
| def testNanFloat(self): |
| message = json_format_proto3_pb2.TestMessage() |
| message.float_value = float('nan') |
| text = '{\n "floatValue": "NaN"\n}' |
| self.assertEqual(json_format.MessageToJson(message), text) |
| parsed_message = json_format_proto3_pb2.TestMessage() |
| json_format.Parse(text, parsed_message) |
| self.assertTrue(math.isnan(parsed_message.float_value)) |
| |
| def testParseDoubleToFloat(self): |
| message = json_format_proto3_pb2.TestMessage() |
| text = '{"repeatedDoubleValue": [3.4028235e+39, 1.4028235e-39]\n}' |
| json_format.Parse(text, message) |
| self.assertEqual(message.repeated_double_value[0], 3.4028235e39) |
| self.assertEqual(message.repeated_double_value[1], 1.4028235e-39) |
| text = '{"repeatedFloatValue": [3.4028235e+39, 1.4028235e-39]\n}' |
| self.CheckError( |
| text, |
| r'Failed to parse repeatedFloatValue field: ' |
| r'Float value too large at TestMessage.repeatedFloatValue\[0\].', |
| ) |
| |
| def testFloatPrecision(self): |
| message = json_format_proto3_pb2.TestMessage() |
| message.float_value = 1.123456789 |
| # Set to 8 valid digits. |
| text = '{\n "floatValue": 1.1234568\n}' |
| self.assertEqual( |
| json_format.MessageToJson(message, float_precision=8), text |
| ) |
| # Set to 7 valid digits. |
| text = '{\n "floatValue": 1.123457\n}' |
| self.assertEqual( |
| json_format.MessageToJson(message, float_precision=7), text |
| ) |
| |
| # Default float_precision will automatic print shortest float. |
| message.float_value = 1.1000000011 |
| text = '{\n "floatValue": 1.1\n}' |
| self.assertEqual(json_format.MessageToJson(message), text) |
| message.float_value = 1.00000075e-36 |
| text = '{\n "floatValue": 1.00000075e-36\n}' |
| self.assertEqual(json_format.MessageToJson(message), text) |
| message.float_value = 12345678912345e11 |
| text = '{\n "floatValue": 1.234568e+24\n}' |
| self.assertEqual(json_format.MessageToJson(message), text) |
| |
| # Test a bunch of data and check json encode/decode do not |
| # lose precision |
| value_list = [0x00, 0xD8, 0x6E, 0x00] |
| msg2 = json_format_proto3_pb2.TestMessage() |
| for a in range(0, 256): |
| value_list[3] = a |
| for b in range(0, 256): |
| value_list[0] = b |
| byte_array = bytearray(value_list) |
| message.float_value = struct.unpack('<f', byte_array)[0] |
| self.CheckParseBack(message, msg2) |
| |
| def testParseEmptyText(self): |
| self.CheckError('', r'Failed to load JSON: (Expecting value)|(No JSON).') |
| |
| def testParseEnumValue(self): |
| message = json_format_proto3_pb2.TestMessage() |
| text = '{"enumValue": 0}' |
| json_format.Parse(text, message) |
| text = '{"enumValue": 1}' |
| json_format.Parse(text, message) |
| self.CheckError( |
| '{"enumValue": "baz"}', |
| 'Failed to parse enumValue field: Invalid enum value baz ' |
| 'for enum type proto3.EnumType at TestMessage.enumValue.', |
| ) |
| # Proto3 accepts numeric unknown enums. |
| text = '{"enumValue": 12345}' |
| json_format.Parse(text, message) |
| # Proto2 does not accept numeric unknown enums. |
| message = unittest_pb2.TestAllTypes() |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Failed to parse optionalNestedEnum field: Invalid enum value 12345 ' |
| 'for enum type protobuf_unittest.TestAllTypes.NestedEnum at ' |
| 'TestAllTypes.optionalNestedEnum.', |
| json_format.Parse, |
| '{"optionalNestedEnum": 12345}', |
| message, |
| ) |
| |
| def testParseUnknownEnumStringValue_Scalar_Proto2(self): |
| message = json_format_pb2.TestNumbers() |
| text = '{"a": "UNKNOWN_STRING_VALUE"}' |
| json_format.Parse(text, message, ignore_unknown_fields=True) |
| |
| self.assertFalse(message.HasField('a')) |
| |
| def testParseErrorForUnknownEnumValue_ScalarWithoutIgnore_Proto2(self): |
| message = json_format_pb2.TestNumbers() |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Invalid enum value', |
| json_format.Parse, '{"a": "UNKNOWN_STRING_VALUE"}', message) |
| |
| def testParseUnknownEnumStringValue_Repeated_Proto2(self): |
| message = json_format_pb2.TestRepeatedEnum() |
| text = '{"repeatedEnum": ["UNKNOWN_STRING_VALUE", "BUFFER"]}' |
| json_format.Parse(text, message, ignore_unknown_fields=True) |
| |
| self.assertEqual(len(message.repeated_enum), 1) |
| self.assertTrue(message.repeated_enum[0] == json_format_pb2.BUFFER) |
| |
| def testParseUnknownEnumStringValue_Map_Proto2(self): |
| message = json_format_pb2.TestMapOfEnums() |
| text = '{"enumMap": {"key1": "BUFFER", "key2": "UNKNOWN_STRING_VALUE"}}' |
| json_format.Parse(text, message, ignore_unknown_fields=True) |
| |
| self.assertTrue(message.enum_map['key1'] == json_format_pb2.BUFFER) |
| self.assertFalse('key2' in message.enum_map) |
| |
| def testParseUnknownEnumStringValue_ExtensionField_Proto2(self): |
| message = json_format_pb2.TestMessageWithExtension() |
| text = """ |
| {"[protobuf_unittest.TestExtension.enum_ext]": "UNKNOWN_STRING_VALUE"} |
| """ |
| json_format.Parse(text, message, ignore_unknown_fields=True) |
| |
| self.assertFalse(json_format_pb2.TestExtension.enum_ext in |
| message.Extensions) |
| |
| def testParseUnknownEnumStringValue_ExtensionFieldWithoutIgnore_Proto2(self): |
| message = json_format_pb2.TestMessageWithExtension() |
| text = """ |
| {"[protobuf_unittest.TestExtension.enum_ext]": "UNKNOWN_STRING_VALUE"} |
| """ |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Invalid enum value', |
| json_format.Parse, text, message) |
| |
| def testParseUnknownEnumStringValue_Scalar_Proto3(self): |
| message = json_format_proto3_pb2.TestMessage() |
| text = '{"enumValue": "UNKNOWN_STRING_VALUE"}' |
| |
| json_format.Parse(text, message, ignore_unknown_fields=True) |
| self.assertEqual(message.enum_value, 0) |
| |
| def testParseUnknownEnumStringValue_Repeated_Proto3(self): |
| message = json_format_proto3_pb2.TestMessage() |
| text = '{"repeatedEnumValue": ["UNKNOWN_STRING_VALUE", "FOO"]}' |
| json_format.Parse(text, message, ignore_unknown_fields=True) |
| |
| self.assertEqual(len(message.repeated_enum_value), 1) |
| self.assertTrue(message.repeated_enum_value[0] == |
| json_format_proto3_pb2.FOO) |
| |
| def testParseUnknownEnumStringValue_Map_Proto3(self): |
| message = json_format_proto3_pb2.MapOfEnums() |
| text = '{"map": {"key1": "FOO", "key2": "UNKNOWN_STRING_VALUE"}}' |
| json_format.Parse(text, message, ignore_unknown_fields=True) |
| |
| self.assertTrue(message.map['key1'] == json_format_proto3_pb2.FOO) |
| self.assertFalse('key2' in message.map) |
| |
| def testBytes(self): |
| message = json_format_proto3_pb2.TestMessage() |
| # Test url base64 |
| text = '{"bytesValue": "-_"}' |
| json_format.Parse(text, message) |
| self.assertEqual(message.bytes_value, b'\xfb') |
| # Test padding |
| text = '{"bytesValue": "AQI="}' |
| json_format.Parse(text, message) |
| self.assertEqual(message.bytes_value, b'\x01\x02') |
| text = '{"bytesValue": "AQI"}' |
| json_format.Parse(text, message) |
| self.assertEqual(message.bytes_value, b'\x01\x02') |
| text = '{"bytesValue": "AQI*"}' |
| json_format.Parse(text, message) |
| self.assertEqual(message.bytes_value, b'\x01\x02') |
| |
| def testParseBadIdentifer(self): |
| self.CheckError( |
| '{int32Value: 1}', |
| ( |
| r'Failed to load JSON: Expecting property name' |
| r'( enclosed in double quotes)?: line 1' |
| ), |
| ) |
| self.CheckError( |
| '{"unknownName": 1}', |
| 'Message type "proto3.TestMessage" has no field named ' |
| '"unknownName" at "TestMessage".', |
| ) |
| |
| def testIgnoreUnknownField(self): |
| text = '{"unknownName": 1}' |
| parsed_message = json_format_proto3_pb2.TestMessage() |
| json_format.Parse(text, parsed_message, ignore_unknown_fields=True) |
| text = ( |
| '{\n' |
| ' "repeatedValue": [ {\n' |
| ' "@type": "type.googleapis.com/proto3.MessageType",\n' |
| ' "unknownName": 1\n' |
| ' }]\n' |
| '}\n' |
| ) |
| parsed_message = json_format_proto3_pb2.TestAny() |
| json_format.Parse(text, parsed_message, ignore_unknown_fields=True) |
| |
| def testDuplicateField(self): |
| self.CheckError( |
| '{"int32Value": 1,\n"int32Value":2}', |
| 'Failed to load JSON: duplicate key int32Value.', |
| ) |
| |
| def testInvalidBoolValue(self): |
| self.CheckError( |
| '{"boolValue": 1}', |
| 'Failed to parse boolValue field: ' |
| 'Expected true or false without quotes at TestMessage.boolValue.', |
| ) |
| self.CheckError( |
| '{"boolValue": "true"}', |
| 'Failed to parse boolValue field: ' |
| 'Expected true or false without quotes at TestMessage.boolValue.', |
| ) |
| |
| def testInvalidIntegerValue(self): |
| message = json_format_proto3_pb2.TestMessage() |
| text = '{"int32Value": 0x12345}' |
| self.assertRaises(json_format.ParseError, json_format.Parse, text, message) |
| self.CheckError( |
| '{"int32Value": 1.5}', |
| 'Failed to parse int32Value field: ' |
| "Couldn't parse integer: 1.5 at TestMessage.int32Value.", |
| ) |
| self.CheckError( |
| '{"int32Value": 012345}', |
| (r'Failed to load JSON: Expecting \'?,\'? delimiter: ' r'line 1.'), |
| ) |
| self.CheckError( |
| '{"int32Value": " 1 "}', |
| 'Failed to parse int32Value field: ' |
| 'Couldn\'t parse integer: " 1 " at TestMessage.int32Value.', |
| ) |
| self.CheckError( |
| '{"int32Value": "1 "}', |
| 'Failed to parse int32Value field: ' |
| 'Couldn\'t parse integer: "1 " at TestMessage.int32Value.', |
| ) |
| self.CheckError( |
| '{"int32Value": false}', |
| 'Failed to parse int32Value field: Bool value False ' |
| 'is not acceptable for integer field at TestMessage.int32Value.', |
| ) |
| self.CheckError( |
| '{"int32Value": 12345678901234567890}', |
| 'Failed to parse int32Value field: Value out of range: ' |
| '12345678901234567890.', |
| ) |
| self.CheckError( |
| '{"uint32Value": -1}', |
| 'Failed to parse uint32Value field: Value out of range: -1.', |
| ) |
| |
| def testInvalidFloatValue(self): |
| self.CheckError( |
| '{"floatValue": "nan"}', |
| "Failed to parse floatValue field: Couldn't " |
| 'parse float "nan", use "NaN" instead at TestMessage.floatValue.', |
| ) |
| self.CheckError( |
| '{"floatValue": NaN}', |
| "Failed to parse floatValue field: Couldn't " |
| 'parse NaN, use quoted "NaN" instead.', |
| ) |
| self.CheckError( |
| '{"floatValue": Infinity}', |
| "Failed to parse floatValue field: Couldn't parse Infinity" |
| ' or value too large, use quoted "Infinity" instead.', |
| ) |
| self.CheckError( |
| '{"floatValue": -Infinity}', |
| "Failed to parse floatValue field: Couldn't parse " |
| '-Infinity or value too small, ' |
| 'use quoted "-Infinity" instead.', |
| ) |
| self.CheckError( |
| '{"doubleValue": -1.89769e+308}', |
| "Failed to parse doubleValue field: Couldn't parse " |
| '-Infinity or value too small, ' |
| 'use quoted "-Infinity" instead.', |
| ) |
| self.CheckError( |
| '{"floatValue": 3.4028235e+39}', |
| 'Failed to parse floatValue field: Float value too large.', |
| ) |
| self.CheckError( |
| '{"floatValue": -3.502823e+38}', |
| 'Failed to parse floatValue field: Float value too small.', |
| ) |
| |
| def testInvalidRepeated(self): |
| self.CheckError( |
| '{"repeatedInt32Value": 12345}', |
| ( |
| r'Failed to parse repeatedInt32Value field: repeated field' |
| r' repeatedInt32Value must be in \[\] which is 12345 at' |
| r' TestMessage.' |
| ), |
| ) |
| |
| def testInvalidMap(self): |
| message = json_format_proto3_pb2.TestMap() |
| text = '{"int32Map": {"null": 2, "2": 3}}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Failed to parse int32Map field: invalid literal', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| text = '{"int32Map": {1: 2, "2": 3}}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| ( |
| r'Failed to load JSON: Expecting property name' |
| r'( enclosed in double quotes)?: line 1' |
| ), |
| json_format.Parse, |
| text, |
| message, |
| ) |
| text = '{"boolMap": {"null": 1}}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Failed to parse boolMap field: Expected "true" or "false", not null at' |
| ' TestMap.boolMap.key', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| text = r'{"stringMap": {"a": 3, "\u0061": 2}}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Failed to load JSON: duplicate key a', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| text = r'{"stringMap": 0}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Failed to parse stringMap field: Map field string_map must be ' |
| 'in a dict which is 0 at TestMap.stringMap.', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| |
| def testInvalidTimestamp(self): |
| message = json_format_proto3_pb2.TestTimestamp() |
| text = '{"value": "10000-01-01T00:00:00.00Z"}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Failed to parse value field: ' |
| "time data '10000-01-01T00:00:00' does not match" |
| " format '%Y-%m-%dT%H:%M:%S' at TestTimestamp.value.", |
| json_format.Parse, |
| text, |
| message, |
| ) |
| text = '{"value": "1970-01-01T00:00:00.0123456789012Z"}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'nanos 0123456789012 more than 9 fractional digits.', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| text = '{"value": "1972-01-01T01:00:00.01+08"}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| r'Invalid timezone offset value: \+08.', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| # Time smaller than minimum time. |
| text = '{"value": "0000-01-01T00:00:00Z"}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Failed to parse value field: year (0 )?is out of range.', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| # Time bigger than maximum time. |
| message.value.seconds = 253402300800 |
| self.assertRaisesRegex(json_format.SerializeToJsonError, |
| 'Timestamp is not valid', |
| json_format.MessageToJson, message) |
| # Nanos smaller than 0 |
| message.value.seconds = 0 |
| message.value.nanos = -1 |
| self.assertRaisesRegex( |
| json_format.SerializeToJsonError, |
| 'Timestamp is not valid', |
| json_format.MessageToJson, |
| message, |
| ) |
| # Lower case t does not accept. |
| text = '{"value": "0001-01-01t00:00:00Z"}' |
| with self.assertRaises(json_format.ParseError) as e: |
| json_format.Parse(text, message) |
| self.assertEqual( |
| 'Failed to parse value field: ' |
| "time data '0001-01-01t00:00:00' does not match format " |
| "'%Y-%m-%dT%H:%M:%S', lowercase 't' is not accepted " |
| 'at TestTimestamp.value.', |
| str(e.exception), |
| ) |
| |
| def testInvalidOneof(self): |
| message = json_format_proto3_pb2.TestOneof() |
| text = '{"oneofInt32Value": 1, "oneofStringValue": "2"}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Message type "proto3.TestOneof"' |
| ' should not have multiple "oneof_value" oneof fields at "TestOneof".', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| |
| def testInvalidListValue(self): |
| message = json_format_proto3_pb2.TestListValue() |
| text = '{"value": 1234}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| r'Failed to parse value field: ListValue must be in \[\] which is ' |
| '1234 at TestListValue.value.', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| |
| class UnknownClass(object): |
| |
| def __str__(self): |
| return 'v' |
| |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| r' at TestListValue.value\[1\].fake.', |
| json_format.ParseDict, |
| {'value': ['hello', {'fake': UnknownClass()}]}, |
| message, |
| ) |
| |
| def testInvalidStruct(self): |
| message = json_format_proto3_pb2.TestStruct() |
| text = '{"value": 1234}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Failed to parse value field: Struct must be in a dict which is ' |
| '1234 at TestStruct.value', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| |
| def testTimestampInvalidStringValue(self): |
| message = json_format_proto3_pb2.TestTimestamp() |
| text = '{"value": {"foo": 123}}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| r"Timestamp JSON value not a string: {u?'foo': 123}", |
| json_format.Parse, |
| text, |
| message, |
| ) |
| |
| def testDurationInvalidStringValue(self): |
| message = json_format_proto3_pb2.TestDuration() |
| text = '{"value": {"foo": 123}}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| r"Duration JSON value not a string: {u?'foo': 123}", |
| json_format.Parse, |
| text, |
| message, |
| ) |
| |
| def testFieldMaskInvalidStringValue(self): |
| message = json_format_proto3_pb2.TestFieldMask() |
| text = '{"value": {"foo": 123}}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| r"FieldMask JSON value not a string: {u?'foo': 123}", |
| json_format.Parse, |
| text, |
| message, |
| ) |
| |
| def testInvalidAny(self): |
| message = any_pb2.Any() |
| text = '{"@type": "type.googleapis.com/google.protobuf.Int32Value"}' |
| self.assertRaisesRegex(json_format.ParseError, 'KeyError: \'value\'', json_format.Parse, text, message) |
| text = '{"value": 1234}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| '@type is missing when parsing any message at Any', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| text = '{"@type": "type.googleapis.com/MessageNotExist", "value": 1234}' |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Can not find message descriptor by type_url: ' |
| 'type.googleapis.com/MessageNotExist at Any', |
| json_format.Parse, |
| text, |
| message, |
| ) |
| # Only last part is to be used: b/25630112 |
| text = ( |
| r'{"@type": "incorrect.googleapis.com/google.protobuf.Int32Value",' |
| r'"value": 1234}' |
| ) |
| json_format.Parse(text, message) |
| |
| def testPreservingProtoFieldNames(self): |
| message = json_format_proto3_pb2.TestMessage() |
| message.int32_value = 12345 |
| self.assertEqual( |
| '{\n "int32Value": 12345\n}', json_format.MessageToJson(message) |
| ) |
| self.assertEqual( |
| '{\n "int32_value": 12345\n}', |
| json_format.MessageToJson( |
| message, |
| always_print_fields_with_no_presence=False, |
| preserving_proto_field_name=True, |
| ), |
| ) |
| # When always_print_fields_with_no_presence is True. |
| message = json_format_proto3_pb2.TestTimestamp() |
| self.assertEqual( |
| '{\n "repeatedValue": []\n}', |
| json_format.MessageToJson( |
| message, |
| always_print_fields_with_no_presence=True, |
| ), |
| ) |
| self.assertEqual( |
| '{\n "repeated_value": []\n}', |
| json_format.MessageToJson( |
| message, |
| always_print_fields_with_no_presence=True, |
| preserving_proto_field_name=True, |
| ), |
| ) |
| |
| # Parsers accept both original proto field names and lowerCamelCase names. |
| message = json_format_proto3_pb2.TestMessage() |
| json_format.Parse('{"int32Value": 54321}', message) |
| self.assertEqual(54321, message.int32_value) |
| json_format.Parse('{"int32_value": 12345}', message) |
| self.assertEqual(12345, message.int32_value) |
| |
| def testIndent(self): |
| message = json_format_proto3_pb2.TestMessage() |
| message.int32_value = 12345 |
| self.assertEqual( |
| '{\n"int32Value": 12345\n}', |
| json_format.MessageToJson(message, indent=0), |
| ) |
| |
| def testFormatEnumsAsInts(self): |
| message = json_format_proto3_pb2.TestMessage() |
| message.enum_value = json_format_proto3_pb2.BAR |
| message.repeated_enum_value.append(json_format_proto3_pb2.FOO) |
| message.repeated_enum_value.append(json_format_proto3_pb2.BAR) |
| self.assertEqual( |
| json.loads('{\n "enumValue": 1,\n "repeatedEnumValue": [0, 1]\n}\n'), |
| json.loads( |
| json_format.MessageToJson(message, use_integers_for_enums=True) |
| ), |
| ) |
| |
| def testParseDict(self): |
| expected = 12345 |
| js_dict = {'int32Value': expected} |
| message = json_format_proto3_pb2.TestMessage() |
| json_format.ParseDict(js_dict, message) |
| self.assertEqual(expected, message.int32_value) |
| |
| def testParseDictAnyDescriptorPoolMissingType(self): |
| # Confirm that ParseDict does not raise ParseError with default pool |
| js_dict = { |
| 'any_value': { |
| '@type': 'type.googleapis.com/proto3.MessageType', |
| 'value': 1234, |
| } |
| } |
| json_format.ParseDict(js_dict, any_test_pb2.TestAny()) |
| # Check ParseDict raises ParseError with empty pool |
| js_dict = { |
| 'any_value': { |
| '@type': 'type.googleapis.com/proto3.MessageType', |
| 'value': 1234, |
| } |
| } |
| with self.assertRaises(json_format.ParseError) as cm: |
| empty_pool = descriptor_pool.DescriptorPool() |
| json_format.ParseDict( |
| js_dict, any_test_pb2.TestAny(), descriptor_pool=empty_pool |
| ) |
| self.assertEqual( |
| str(cm.exception), |
| 'Failed to parse any_value field: Can not find message descriptor by' |
| ' type_url: type.googleapis.com/proto3.MessageType at ' |
| 'TestAny.any_value.', |
| ) |
| |
| def testParseDictUnknownValueType(self): |
| class UnknownClass(object): |
| |
| def __repr__(self): |
| return 'v' |
| |
| message = json_format_proto3_pb2.TestValue() |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| r"Value v has unexpected type <class '.*\.UnknownClass'>.", |
| json_format.ParseDict, |
| {'value': UnknownClass()}, |
| message, |
| ) |
| |
| def testMessageToDict(self): |
| message = json_format_proto3_pb2.TestMessage() |
| message.int32_value = 12345 |
| expected = {'int32Value': 12345} |
| self.assertEqual(expected, json_format.MessageToDict(message)) |
| |
| def testJsonName(self): |
| message = json_format_proto3_pb2.TestCustomJsonName() |
| message.value = 12345 |
| self.assertEqual( |
| '{\n "@value": 12345\n}', json_format.MessageToJson(message) |
| ) |
| parsed_message = json_format_proto3_pb2.TestCustomJsonName() |
| self.CheckParseBack(message, parsed_message) |
| |
| def testSortKeys(self): |
| # Testing sort_keys is not perfectly working, as by random luck we could |
| # get the output sorted. We just use a selection of names. |
| message = json_format_proto3_pb2.TestMessage( |
| bool_value=True, |
| int32_value=1, |
| int64_value=3, |
| uint32_value=4, |
| string_value='bla', |
| ) |
| self.assertEqual( |
| json_format.MessageToJson(message, sort_keys=True), |
| # We use json.dumps() instead of a hardcoded string due to differences |
| # between Python 2 and Python 3. |
| json.dumps( |
| { |
| 'boolValue': True, |
| 'int32Value': 1, |
| 'int64Value': '3', |
| 'uint32Value': 4, |
| 'stringValue': 'bla', |
| }, |
| indent=2, |
| sort_keys=True, |
| ), |
| ) |
| |
| def testNestedRecursiveLimit(self): |
| message = unittest_pb2.NestedTestAllTypes() |
| self.assertRaisesRegex( |
| json_format.ParseError, |
| 'Message too deep. Max recursion depth is 3', |
| json_format.Parse, |
| '{"child": {"child": {"child" : {}}}}', |
| message, |
| max_recursion_depth=3, |
| ) |
| # The following one can pass |
| json_format.Parse( |
| '{"payload": {}, "child": {"child":{}}}', message, max_recursion_depth=3 |
| ) |
| |
| def testJsonNameConflictSerilize(self): |
| message = more_messages_pb2.ConflictJsonName(value=2) |
| self.assertEqual( |
| json.loads('{"old_value": 2}'), |
| json.loads(json_format.MessageToJson(message)), |
| ) |
| |
| new_message = more_messages_pb2.ConflictJsonName(new_value=2) |
| self.assertEqual( |
| json.loads('{"value": 2}'), |
| json.loads(json_format.MessageToJson(new_message)), |
| ) |
| |
| def testJsonNameConflictParse(self): |
| message = more_messages_pb2.ConflictJsonName() |
| json_format.Parse('{"value": 2}', message) |
| self.assertEqual(2, message.new_value) |
| self.assertEqual(0, message.value) |
| |
| def testJsonNameConflictRoundTrip(self): |
| message = more_messages_pb2.ConflictJsonName(value=2) |
| parsed_message = more_messages_pb2.ConflictJsonName() |
| json_string = json_format.MessageToJson(message) |
| json_format.Parse(json_string, parsed_message) |
| self.assertEqual(message, parsed_message) |
| |
| new_message = more_messages_pb2.ConflictJsonName(new_value=2) |
| new_parsed_message = more_messages_pb2.ConflictJsonName() |
| json_string = json_format.MessageToJson(new_message) |
| json_format.Parse(json_string, new_parsed_message) |
| self.assertEqual(new_message, new_parsed_message) |
| |
| def testOtherParseErrors(self): |
| self.CheckError( |
| '9', |
| "Failed to parse JSON: TypeError: 'int' object is not iterable.", |
| ) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
