def testCustomDescriptorPool(self):
   # Create a new pool, and add a file descriptor.
   pool = descriptor_pool.DescriptorPool()
   file_desc = descriptor_pb2.FileDescriptorProto(
       name='some/file.proto', package='package')
   file_desc.message_type.add(name='Message')
   pool.Add(file_desc)
   self.assertEqual(pool.FindFileByName('some/file.proto').name,
                    'some/file.proto')
   self.assertEqual(pool.FindMessageTypeByName('package.Message').name,
                    'Message')
   # Test no package
   file_proto = descriptor_pb2.FileDescriptorProto(
       name='some/filename/container.proto')
   message_proto = file_proto.message_type.add(
       name='TopMessage')
   message_proto.field.add(
       name='bb',
       number=1,
       type=descriptor_pb2.FieldDescriptorProto.TYPE_INT32,
       label=descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL)
   enum_proto = file_proto.enum_type.add(name='TopEnum')
   enum_proto.value.add(name='FOREIGN_FOO', number=4)
   file_proto.service.add(name='TopService')
   pool = descriptor_pool.DescriptorPool()
   pool.Add(file_proto)
   self.assertEqual('TopMessage',
                    pool.FindMessageTypeByName('TopMessage').name)
   self.assertEqual('TopEnum', pool.FindEnumTypeByName('TopEnum').name)
   self.assertEqual('TopService', pool.FindServiceByName('TopService').name)
  def _TestEnum(self, prefix):
    pool = descriptor_pool.DescriptorPool()
    pool.AddEnumDescriptor(unittest_pb2.ForeignEnum.DESCRIPTOR)
    self.assertEqual(
        'protobuf_unittest.ForeignEnum',
        pool.FindEnumTypeByName(
            prefix + 'protobuf_unittest.ForeignEnum').full_name)

    # AddEnumDescriptor is not recursive.
    with self.assertRaises(KeyError):
      pool.FindEnumTypeByName(
          prefix + 'protobuf_unittest.ForeignEnum.NestedEnum')

    pool.AddEnumDescriptor(unittest_pb2.TestAllTypes.NestedEnum.DESCRIPTOR)
    self.assertEqual(
        'protobuf_unittest.TestAllTypes.NestedEnum',
        pool.FindEnumTypeByName(
            prefix + 'protobuf_unittest.TestAllTypes.NestedEnum').full_name)

    # Files are implicitly also indexed when enums are added.
    self.assertEqual(
        'google/protobuf/unittest.proto',
        pool.FindFileByName(
            'google/protobuf/unittest.proto').name)

    self.assertEqual(
        'google/protobuf/unittest.proto',
        pool.FindFileContainingSymbol(
            prefix + 'protobuf_unittest.TestAllTypes.NestedEnum').name)
 def testService(self):
   pool = descriptor_pool.DescriptorPool()
   with self.assertRaises(KeyError):
     pool.FindServiceByName('protobuf_unittest.TestService')
   pool.AddServiceDescriptor(unittest_pb2._TESTSERVICE)
   self.assertEqual(
       'protobuf_unittest.TestService',
       pool.FindServiceByName('protobuf_unittest.TestService').full_name)
 def testEmptyDescriptorPool(self):
   # Check that an empty DescriptorPool() contains no messages.
   pool = descriptor_pool.DescriptorPool()
   proto_file_name = descriptor_pb2.DESCRIPTOR.name
   self.assertRaises(KeyError, pool.FindFileByName, proto_file_name)
   # Add the above file to the pool
   file_descriptor = descriptor_pb2.FileDescriptorProto()
   descriptor_pb2.DESCRIPTOR.CopyToProto(file_descriptor)
   pool.Add(file_descriptor)
   # Now it exists.
   self.assertTrue(pool.FindFileByName(proto_file_name))
 def testAddSerializedFile(self):
   if isinstance(self, SecondaryDescriptorFromDescriptorDB):
     if api_implementation.Type() == 'cpp':
       # Cpp extension cannot call Add on a DescriptorPool
       # that uses a DescriptorDatabase.
       # TODO(jieluo): Fix python and cpp extension diff.
       return
   self.pool = descriptor_pool.DescriptorPool()
   self.pool.AddSerializedFile(self.factory_test1_fd.SerializeToString())
   self.pool.AddSerializedFile(self.factory_test2_fd.SerializeToString())
   self.testFindMessageTypeByName()
 def testAddTypeError(self):
   pool = descriptor_pool.DescriptorPool()
   with self.assertRaises(TypeError):
     pool.AddDescriptor(0)
   with self.assertRaises(TypeError):
     pool.AddEnumDescriptor(0)
   with self.assertRaises(TypeError):
     pool.AddServiceDescriptor(0)
   with self.assertRaises(TypeError):
     pool.AddExtensionDescriptor(0)
   with self.assertRaises(TypeError):
     pool.AddFileDescriptor(0)
  def testFile(self):
    pool = descriptor_pool.DescriptorPool()
    pool.AddFileDescriptor(unittest_pb2.DESCRIPTOR)
    self.assertEqual(
        'google/protobuf/unittest.proto',
        pool.FindFileByName(
            'google/protobuf/unittest.proto').name)

    # AddFileDescriptor is not recursive; messages and enums within files must
    # be explicitly registered.
    with self.assertRaises(KeyError):
      pool.FindFileContainingSymbol(
          'protobuf_unittest.TestAllTypes')
 def setUp(self):
   self.factory_test1_fd = descriptor_pb2.FileDescriptorProto.FromString(
       factory_test1_pb2.DESCRIPTOR.serialized_pb)
   self.factory_test2_fd = descriptor_pb2.FileDescriptorProto.FromString(
       factory_test2_pb2.DESCRIPTOR.serialized_pb)
   db = descriptor_database.DescriptorDatabase()
   db.Add(self.factory_test1_fd)
   db.Add(self.factory_test2_fd)
   db.Add(descriptor_pb2.FileDescriptorProto.FromString(
       unittest_import_public_pb2.DESCRIPTOR.serialized_pb))
   db.Add(descriptor_pb2.FileDescriptorProto.FromString(
       unittest_import_pb2.DESCRIPTOR.serialized_pb))
   db.Add(descriptor_pb2.FileDescriptorProto.FromString(
       unittest_pb2.DESCRIPTOR.serialized_pb))
   self.pool = descriptor_pool.DescriptorPool(descriptor_db=db)
 def testFileDescriptorOptionsWithCustomDescriptorPool(self):
   # Create a descriptor pool, and add a new FileDescriptorProto to it.
   pool = descriptor_pool.DescriptorPool()
   file_name = 'file_descriptor_options_with_custom_descriptor_pool.proto'
   file_descriptor_proto = descriptor_pb2.FileDescriptorProto(name=file_name)
   extension_id = file_options_test_pb2.foo_options
   file_descriptor_proto.options.Extensions[extension_id].foo_name = 'foo'
   pool.Add(file_descriptor_proto)
   # The options set on the FileDescriptorProto should be available in the
   # descriptor even if they contain extensions that cannot be deserialized
   # using the pool.
   file_descriptor = pool.FindFileByName(file_name)
   options = file_descriptor.GetOptions()
   self.assertEqual('foo', options.Extensions[extension_id].foo_name)
   # The object returned by GetOptions() is cached.
   self.assertIs(options, file_descriptor.GetOptions())
 def testGetPrototype(self):
     db = descriptor_database.DescriptorDatabase()
     pool = descriptor_pool.DescriptorPool(db)
     db.Add(self.factory_test1_fd)
     db.Add(self.factory_test2_fd)
     factory = message_factory.MessageFactory()
     cls = factory.GetPrototype(
         pool.FindMessageTypeByName(
             'dis_sdk_python.dependency.google.protobuf.python.internal.Factory2Message'
         ))
     self.assertFalse(cls is factory_test2_pb2.Factory2Message)
     self._ExerciseDynamicClass(cls)
     cls2 = factory.GetPrototype(
         pool.FindMessageTypeByName(
             'dis_sdk_python.dependency.google.protobuf.python.internal.Factory2Message'
         ))
     self.assertTrue(cls is cls2)
  def testDefaultValueForCustomMessages(self):
    """Check the value returned by non-existent fields."""
    def _CheckValueAndType(value, expected_value, expected_type):
      self.assertEqual(value, expected_value)
      self.assertIsInstance(value, expected_type)

    def _CheckDefaultValues(msg):
      try:
        int64 = int
      except NameError:  # Python3
        int64 = int
      try:
        unicode_type = str
      except NameError:  # Python3
        unicode_type = str
      _CheckValueAndType(msg.optional_int32, 0, int)
      _CheckValueAndType(msg.optional_uint64, 0, (int64, int))
      _CheckValueAndType(msg.optional_float, 0, (float, int))
      _CheckValueAndType(msg.optional_double, 0, (float, int))
      _CheckValueAndType(msg.optional_bool, False, bool)
      _CheckValueAndType(msg.optional_string, '', unicode_type)
      _CheckValueAndType(msg.optional_bytes, b'', bytes)
      _CheckValueAndType(msg.optional_nested_enum, msg.FOO, int)
    # First for the generated message
    _CheckDefaultValues(unittest_pb2.TestAllTypes())
    # Then for a message built with from the DescriptorPool.
    pool = descriptor_pool.DescriptorPool()
    pool.Add(descriptor_pb2.FileDescriptorProto.FromString(
        unittest_import_public_pb2.DESCRIPTOR.serialized_pb))
    pool.Add(descriptor_pb2.FileDescriptorProto.FromString(
        unittest_import_pb2.DESCRIPTOR.serialized_pb))
    pool.Add(descriptor_pb2.FileDescriptorProto.FromString(
        unittest_pb2.DESCRIPTOR.serialized_pb))
    message_class = message_factory.MessageFactory(pool).GetPrototype(
        pool.FindMessageTypeByName(
            unittest_pb2.TestAllTypes.DESCRIPTOR.full_name))
    _CheckDefaultValues(message_class())
Esempio n. 12
0
 def GetDescriptorPool(self):
     return descriptor_pool.DescriptorPool()
Esempio n. 13
0
    def __init__(self, pool=None):
        """Initializes a new factory."""
        self.pool = pool or descriptor_pool.DescriptorPool()

        # local cache of all classes built from protobuf descriptors
        self._classes = {}
    def testDuplicateExtensionNumber(self):
        pool = descriptor_pool.DescriptorPool()
        factory = message_factory.MessageFactory(pool=pool)

        # Add Container message.
        f = descriptor_pb2.FileDescriptorProto()
        f.name = 'google/protobuf/internal/container.proto'
        f.package = 'dis_sdk_python.dependency.google.protobuf.python.internal'
        msg = f.message_type.add()
        msg.name = 'Container'
        rng = msg.extension_range.add()
        rng.start = 1
        rng.end = 10
        pool.Add(f)
        msgs = factory.GetMessages([f.name])
        self.assertIn(
            'dis_sdk_python.dependency.google.protobuf.python.internal.Container',
            msgs)

        # Extend container.
        f = descriptor_pb2.FileDescriptorProto()
        f.name = 'google/protobuf/internal/extension.proto'
        f.package = 'dis_sdk_python.dependency.google.protobuf.python.internal'
        f.dependency.append('google/protobuf/internal/container.proto')
        msg = f.message_type.add()
        msg.name = 'Extension'
        ext = msg.extension.add()
        ext.name = 'extension_field'
        ext.number = 2
        ext.label = descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL
        ext.type_name = 'Extension'
        ext.extendee = 'Container'
        pool.Add(f)
        msgs = factory.GetMessages([f.name])
        self.assertIn(
            'dis_sdk_python.dependency.google.protobuf.python.internal.Extension',
            msgs)

        # Add Duplicate extending the same field number.
        f = descriptor_pb2.FileDescriptorProto()
        f.name = 'google/protobuf/internal/duplicate.proto'
        f.package = 'dis_sdk_python.dependency.google.protobuf.python.internal'
        f.dependency.append('google/protobuf/internal/container.proto')
        msg = f.message_type.add()
        msg.name = 'Duplicate'
        ext = msg.extension.add()
        ext.name = 'extension_field'
        ext.number = 2
        ext.label = descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL
        ext.type_name = 'Duplicate'
        ext.extendee = 'Container'
        pool.Add(f)

        with self.assertRaises(Exception) as cm:
            factory.GetMessages([f.name])

        self.assertIn(str(cm.exception), [
            'Extensions '
            '"dis_sdk_python.dependency.google.protobuf.python.internal.Duplicate.extension_field" and'
            ' "dis_sdk_python.dependency.google.protobuf.python.internal.Extension.extension_field"'
            ' both try to extend message type'
            ' "dis_sdk_python.dependency.google.protobuf.python.internal.Container"'
            ' with field number 2.', 'Double registration of Extensions'
        ])
 def testUserDefinedDB(self):
   db = descriptor_database.DescriptorDatabase()
   self.pool = descriptor_pool.DescriptorPool(db)
   db.Add(self.factory_test1_fd)
   db.Add(self.factory_test2_fd)
   self.testFindMessageTypeByName()