def testNormalizeSchemaName(self): class _1_lower_case_name_(messages.Message): pass parser = message_parser.MessageTypeToJsonSchema() # Test _, numbers, and case fixing. self.assertEqual(package + '1LowerCaseName', parser.add_message(_1_lower_case_name_))
def testSelfReferenceMessageField(self): """MessageFields should be recursively parsed.""" parser = message_parser.MessageTypeToJsonSchema() parser.add_message(SelfReference) schemas = parser.schemas() self.assertEquals(1, len(schemas)) self.assertTrue(package + 'SelfReference' in schemas)
def testRepeatedAndRequired(self): """Repeated and required fields should show up as such in the schema.""" class AllFields(messages.Message): """Documentation for AllFields.""" string = messages.StringField(1) string_required = messages.StringField(2, required=True) string_default_required = messages.StringField(3, required=True, default='Foo') string_repeated = messages.StringField(4, repeated=True) class SimpleEnum(messages.Enum): """Simple enumeration type.""" VAL1 = 1 VAL2 = 2 enum_value = messages.EnumField(SimpleEnum, 5, default=SimpleEnum.VAL2) parser = message_parser.MessageTypeToJsonSchema() parser.add_message(AllFields) schemas = parser.schemas() expected = { package + 'AllFields': { 'type': 'object', 'id': package + 'AllFields', 'description': 'Documentation for AllFields.', 'properties': { 'string': { 'type': 'string' }, 'string_required': { 'type': 'string', 'required': True }, 'string_default_required': { 'type': 'string', 'required': True, 'default': 'Foo' }, 'string_repeated': { 'items': { 'type': 'string', }, 'type': 'array' }, 'enum_value': { 'default': 'VAL2', 'type': 'string', 'enum': ['VAL1', 'VAL2'] }, } } } _assertSchemaEqual(expected, schemas, self)
def testSelfReferenceMessageField(self): """MessageFields should be recursively parsed.""" parser = message_parser.MessageTypeToJsonSchema() parser.add_message(SelfReference) schemas = parser.schemas() self.assertEquals(1, len(schemas)) self.assertTrue(_DESCRIPTOR_PATH_PREFIX + 'MessageParserTestSelfReference' in schemas)
def testNormalizeSchemaName(self): class _1_lower_case_name_(messages.Message): pass parser = message_parser.MessageTypeToJsonSchema() # Test _, numbers, and case fixing. self.assertEqual( _DESCRIPTOR_PATH_PREFIX + 'MessageParserTest1LowerCaseName', parser.add_message(_1_lower_case_name_))
def testNormalizeSchemaNameCollision(self): class A(messages.Message): pass class A_(messages.Message): pass parser = message_parser.MessageTypeToJsonSchema() parser.add_message(A) self.assertRaises(KeyError, parser.add_message, A_)
def testRefForMessage(self): class NoFields(messages.Message): pass parser = message_parser.MessageTypeToJsonSchema() self.assertRaises(KeyError, parser.ref_for_message_type, NoFields) parser.add_message(NoFields) self.assertEqual(package + 'NoFields', parser.ref_for_message_type(NoFields))
def testRefForMessage(self): class NoFields(messages.Message): pass parser = message_parser.MessageTypeToJsonSchema() self.assertRaises(KeyError, parser.ref_for_message_type, NoFields) parser.add_message(NoFields) self.assertEqual(_DESCRIPTOR_PATH_PREFIX + 'MessageParserTestNoFields', parser.ref_for_message_type(NoFields))
def testLargeEnum(self): """Test that an enum with lots of values works.""" class MyMessage(messages.Message): """Documentation for MyMessage.""" class LargeEnum(messages.Enum): """Large enumeration type, in a strange order.""" ALL = 1000 AND = 1050 BAR = 4 BIND = 3141 DARKNESS = 2123 FOO = 3 IN = 1200 ONE = 5 RING = 6 RULE = 8 THE = 1500 THEM1 = 9 THEM2 = 10000 TO = 7 VAL1 = 1 VAL2 = 2 enum_value = messages.EnumField(LargeEnum, 1) parser = message_parser.MessageTypeToJsonSchema() parser.add_message(MyMessage) schemas = parser.schemas() expected = { package + 'MyMessage': { 'type': 'object', 'id': package + 'MyMessage', 'description': 'Documentation for MyMessage.', 'properties': { 'enum_value': { 'type': 'string', 'enum': [ 'VAL1', 'VAL2', 'FOO', 'BAR', 'ONE', 'RING', 'TO', 'RULE', 'THEM1', 'ALL', 'AND', 'IN', 'THE', 'DARKNESS', 'BIND', 'THEM2' ] }, } } } _assertSchemaEqual(expected, schemas, self)
def testRecursiveDescent(self): """MessageFields should be recursively parsed.""" class C(messages.Message): text = messages.StringField(1, required=True) class B(messages.Message): c = messages.MessageField(C, 1) class A(messages.Message): b = messages.MessageField(B, 1, repeated=True) parser = message_parser.MessageTypeToJsonSchema() parser.add_message(A) schemas = parser.schemas() self.assertEquals(3, len(schemas)) self.assertTrue(package + 'A' in schemas) self.assertTrue(package + 'B' in schemas) self.assertTrue(package + 'C' in schemas)
def testEmptyMessage(self): """Test the empty edge case.""" class NoFields(messages.Message): pass parser = message_parser.MessageTypeToJsonSchema() parser.add_message(NoFields) schemas = parser.schemas() expected = { package + 'NoFields': { 'type': 'object', 'id': package + 'NoFields', 'properties': {} } } _assertSchemaEqual(expected, schemas, self)
def testMessageFieldDocsAndArrayRef(self): """Descriptions for MessageFields and a reference in an array.""" class B(messages.Message): """A description of B.""" pass class A(messages.Message): b = messages.MessageField(B, 1, repeated=True) parser = message_parser.MessageTypeToJsonSchema() parser.add_message(A) schemas = parser.schemas() expected = { _DESCRIPTOR_PATH_PREFIX + 'MessageParserTestA': { 'type': 'object', 'id': _DESCRIPTOR_PATH_PREFIX + 'MessageParserTestA', 'properties': { 'b': { 'type': 'array', 'description': 'A description of B.', 'items': { '$ref': _DESCRIPTOR_PATH_PREFIX + 'MessageParserTestB' } } } }, _DESCRIPTOR_PATH_PREFIX + 'MessageParserTestB': { 'type': 'object', 'id': _DESCRIPTOR_PATH_PREFIX + 'MessageParserTestB', 'description': 'A description of B.', 'properties': {} } } _assertSchemaEqual(expected, schemas, self)
def testAllFieldTypes(self): """Test all the Field types that ProtoRPC supports.""" class AllTypes(messages.Message): """Contains all field types.""" class SimpleEnum(messages.Enum): """Simple enumeration type.""" VAL1 = 1 VAL2 = 2 bool_value = messages.BooleanField(1, variant=messages.Variant.BOOL) bytes_value = messages.BytesField(2, variant=messages.Variant.BYTES) double_value = messages.FloatField(3, variant=messages.Variant.DOUBLE) enum_value = messages.EnumField(SimpleEnum, 4) float_value = messages.FloatField(5, variant=messages.Variant.FLOAT) int32_value = messages.IntegerField(6, variant=messages.Variant.INT32) int64_value = messages.IntegerField(7, variant=messages.Variant.INT64) string_value = messages.StringField( 8, variant=messages.Variant.STRING) uint32_value = messages.IntegerField( 9, variant=messages.Variant.UINT32) uint64_value = messages.IntegerField( 10, variant=messages.Variant.UINT64) int_value = messages.IntegerField(11) # Default variant is INT64. datetime_value = message_types.DateTimeField(12) repeated_datetime_value = message_types.DateTimeField( 13, repeated=True) parser = message_parser.MessageTypeToJsonSchema() parser.add_message(AllTypes) schemas = parser.schemas() expected = { package + 'AllTypes': { 'type': 'object', 'id': package + 'AllTypes', 'description': 'Contains all field types.', 'properties': { 'bool_value': { 'type': 'boolean' }, 'bytes_value': { 'type': 'string', 'format': 'byte' }, 'double_value': { 'type': 'number', 'format': 'double' }, 'enum_value': { 'type': 'string', 'enum': ['VAL1', 'VAL2'] }, 'float_value': { 'type': 'number', 'format': 'float' }, 'int32_value': { 'type': 'integer', 'format': 'int32' }, 'int64_value': { 'type': 'string', 'format': 'int64' }, 'string_value': { 'type': 'string' }, 'uint32_value': { 'type': 'integer', 'format': 'uint32' }, 'uint64_value': { 'type': 'string', 'format': 'uint64' }, 'int_value': { 'type': 'string', 'format': 'int64' }, 'datetime_value': { 'type': 'string', 'format': 'date-time' }, 'repeated_datetime_value': { 'items': { 'type': 'string', 'format': 'date-time' }, 'type': 'array' } } } } _assertSchemaEqual(expected, schemas, self)