def testWithModules(self):
"""Test what happens when no modules provided."""
modules = [types.ModuleType('package1'), types.ModuleType('package1')]
file1 = descriptor.FileDescriptor()
file1.package = 'package1'
file2 = descriptor.FileDescriptor()
file2.package = 'package2'
expected = descriptor.FileSet()
expected.files = [file1, file1]
described = descriptor.describe_file_set(modules)
described.check_initialized()
self.assertEquals(expected, described)
def MakeFileDescriptor(self, package):
"""Helper method to construct FileDescriptors.
Creates FileDescriptor with a MessageDescriptor and an EnumDescriptor.
Args:
package: Package name to give new file descriptors.
Returns:
New FileDescriptor instance.
"""
enum_descriptor = descriptor.EnumDescriptor()
enum_descriptor.name = u'MyEnum'
message_descriptor = descriptor.MessageDescriptor()
message_descriptor.name = u'MyMessage'
service_descriptor = descriptor.ServiceDescriptor()
service_descriptor.name = u'MyService'
file_descriptor = descriptor.FileDescriptor()
file_descriptor.package = package
file_descriptor.enum_types = [enum_descriptor]
file_descriptor.message_types = [message_descriptor]
file_descriptor.service_types = [service_descriptor]
return file_descriptor
def DoMessageTest(self,
field_descriptors,
message_types=None,
enum_types=None):
"""Execute message generation test based on FieldDescriptor objects.
Args:
field_descriptor: List of FieldDescriptor object to generate and test.
message_types: List of other MessageDescriptor objects that the new
Message class depends on.
enum_types: List of EnumDescriptor objects that the new Message class
depends on.
"""
file_descriptor = descriptor.FileDescriptor()
file_descriptor.package = 'my_package'
message_descriptor = descriptor.MessageDescriptor()
message_descriptor.name = 'MyMessage'
message_descriptor.fields = list(field_descriptors)
file_descriptor.message_types = message_types or []
file_descriptor.message_types.append(message_descriptor)
if enum_types:
file_descriptor.enum_types = list(enum_types)
self.DoPythonTest(file_descriptor)
def testNoPackageName(self):
"""Test describing a module with no module name."""
module = types.ModuleType('')
expected = descriptor.FileDescriptor()
described = descriptor.describe_file(module)
described.check_initialized()
self.assertEquals(expected, described)
def setUp(self):
self.original_path = list(sys.path)
self.original_modules = dict(sys.modules)
sys.path = list(sys.path)
self.file_descriptor = descriptor.FileDescriptor()
# Create temporary directory and add to Python path so that generated
# Python code can be easily parsed, imported and executed.
self.temp_dir = tempfile.mkdtemp()
sys.path.append(self.temp_dir)
def testEmptyModule(self):
"""Test describing an empty file."""
module = types.ModuleType('my.package.name')
expected = descriptor.FileDescriptor()
expected.package = 'my.package.name'
described = descriptor.describe_file(module)
described.check_initialized()
self.assertEquals(expected, described)
def testPackageName(self):
"""Test using the 'package' module attribute."""
module = types.ModuleType('my.module.name')
module.package = 'my.package.name'
expected = descriptor.FileDescriptor()
expected.package = 'my.package.name'
described = descriptor.describe_file(module)
described.check_initialized()
self.assertEquals(expected, described)
def testMain(self):
"""Test using the 'package' module attribute."""
module = types.ModuleType('__main__')
module.__file__ = '/blim/blam/bloom/my_package.py'
expected = descriptor.FileDescriptor()
expected.package = 'my_package'
described = descriptor.describe_file(module)
described.check_initialized()
self.assertEquals(expected, described)
def testNestedEnum(self):
message = descriptor.MessageDescriptor()
message.name = 'OuterMessage'
inner_enum = descriptor.EnumDescriptor()
inner_enum.name = 'InnerEnum'
message.enum_types = [inner_enum]
file_descriptor = descriptor.FileDescriptor()
file_descriptor.message_types = [message]
self.DoPythonTest(file_descriptor)
def testService(self):
service = descriptor.ServiceDescriptor()
service.name = 'TheService'
method1 = descriptor.MethodDescriptor()
method1.name = 'method1'
method1.request_type = 'protorpc.descriptor.FileDescriptor'
method1.response_type = 'protorpc.descriptor.MethodDescriptor'
service.methods = [method1]
file_descriptor = descriptor.FileDescriptor()
file_descriptor.service_types = [service]
self.DoPythonTest(file_descriptor)
# Test to make sure that implementation methods raise an exception.
import blank
service_instance = blank.TheService()
self.assertRaisesWithRegexpMatch(NotImplementedError,
'Method method1 is not implemented',
service_instance.method1,
descriptor.FileDescriptor())
def testNestedMessage(self):
message = descriptor.MessageDescriptor()
message.name = 'OuterMessage'
inner_message = descriptor.MessageDescriptor()
inner_message.name = 'InnerMessage'
inner_inner_message = descriptor.MessageDescriptor()
inner_inner_message.name = 'InnerInnerMessage'
inner_message.message_types = [inner_inner_message]
message.message_types = [inner_message]
file_descriptor = descriptor.FileDescriptor()
file_descriptor.message_types = [message]
self.DoPythonTest(file_descriptor)
def testMessages(self):
"""Test that messages are described."""
module = self.LoadModule(
'my.package', 'class Message1(messages.Message): pass\n'
'class Message2(messages.Message): pass\n')
message1 = descriptor.MessageDescriptor()
message1.name = 'Message1'
message2 = descriptor.MessageDescriptor()
message2.name = 'Message2'
expected = descriptor.FileDescriptor()
expected.package = 'my.package'
expected.message_types = [message1, message2]
described = descriptor.describe_file(module)
described.check_initialized()
self.assertEquals(expected, described)
def testEnums(self):
"""Test that enums are described."""
module = self.LoadModule(
'my.package', 'class Enum1(messages.Enum): pass\n'
'class Enum2(messages.Enum): pass\n')
enum1 = descriptor.EnumDescriptor()
enum1.name = 'Enum1'
enum2 = descriptor.EnumDescriptor()
enum2.name = 'Enum2'
expected = descriptor.FileDescriptor()
expected.package = 'my.package'
expected.enum_types = [enum1, enum2]
described = descriptor.describe_file(module)
described.check_initialized()
self.assertEquals(expected, described)
def testServices(self):
"""Test that services are described."""
module = self.LoadModule(
'my.package', 'class Service1(remote.Service): pass\n'
'class Service2(remote.Service): pass\n')
service1 = descriptor.ServiceDescriptor()
service1.name = 'Service1'
service2 = descriptor.ServiceDescriptor()
service2.name = 'Service2'
expected = descriptor.FileDescriptor()
expected.package = 'my.package'
expected.service_types = [service1, service2]
described = descriptor.describe_file(module)
described.check_initialized()
self.assertEquals(expected, described)
def setUp(self): self.file_descriptor = descriptor.FileDescriptor() self.output = cStringIO.StringIO()
def testEmptyPackage(self):
file_descriptor = descriptor.FileDescriptor()
file_descriptor.package = 'mypackage'
self.DoPythonTest(file_descriptor)
def testBlankPackage(self):
self.DoPythonTest(descriptor.FileDescriptor())
