def test_sanity(self):
node = colander.SchemaNode(colander.DateTime())
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
'format': 'date-time',
})
def mapping_sequence_test(self):
class BaseMapping(colander.MappingSchema):
name = colander.SchemaNode(colander.String())
number = colander.SchemaNode(colander.Integer())
class BaseMappings(colander.SequenceSchema):
base_mapping = BaseMapping()
schema = BaseMappings()
ret = convert(schema)
self.assertDictEqual(ret, {
'type': 'array',
'items': {
'type': 'object',
'properties': {
'name': {
'type': 'string',
'title': 'Name',
},
'number': {
'type': 'integer',
'title': 'Number',
}
},
'required': ['name', 'number'],
'title': 'Base Mapping',
},
})
def test_nested_schema(self):
class BaseMapping(colander.MappingSchema):
foo = colander.SchemaNode(colander.String(),
missing=colander.drop)
class TopMapping(colander.MappingSchema):
bar = BaseMapping(missing=colander.drop)
node = TopMapping()
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'object',
'properties': {
'bar': {
'title': 'Bar',
'type': 'object',
'properties': {
'foo': {
'title': 'Foo',
'type': 'string'
}
}
}
},
})
def test_single_level(self):
handler = DefinitionHandler(ref=1)
ref = handler.from_schema(FeelingsSchema(title='Feelings'))
self.assertEquals(ref, {'$ref': '#/definitions/Feelings'})
self.assertDictEqual(handler.definition_registry['Feelings'],
convert(FeelingsSchema(title='Feelings')))
def test_default(self):
node = colander.SchemaNode(colander.Integer(), default=1)
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'integer',
'default': 1,
})
def test_title(self):
node = colander.SchemaNode(colander.String(), title='foo')
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
'title': 'foo',
})
def test_validate_regex_url(self):
node = colander.SchemaNode(colander.String(), validator=colander.url)
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
'format': 'url',
})
def test_validate_default(self):
node = colander.SchemaNode(colander.String(), default='foo')
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
'default': 'foo',
})
def test_description(self):
node = colander.SchemaNode(colander.String(), description='bar')
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
'description': 'bar',
})
def test_validate_regex(self):
node = colander.SchemaNode(colander.String(),
validator=colander.Regex(r'foo*bar'))
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
'pattern': 'foo*bar',
})
def test_validate_oneof(self):
node = colander.SchemaNode(colander.String(),
validator=colander.OneOf(["one", "two"]))
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
'enum': ['one', 'two'],
})
def test_enum(self):
node = colander.SchemaNode(colander.Integer(),
validator=colander.OneOf([1, 2, 3, 4]))
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'integer',
'enum': [1, 2, 3, 4],
})
def test_validate_length(self):
node = colander.SchemaNode(colander.String(),
validator=colander.Length(12, 42))
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
'maxLength': 42,
'minLength': 12,
})
def test_range(self):
node = colander.SchemaNode(colander.Integer(),
validator=colander.Range(111, 555))
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'integer',
'minimum': 111,
'maximum': 555,
})
def primitive_sequence_test(self):
class Integers(colander.SequenceSchema):
num = colander.SchemaNode(colander.Integer())
ret = convert(Integers)
self.assertDictEqual(ret, {
'type': 'array',
'items': {
'type': 'integer',
},
})
def test_validate_all(self):
node = colander.SchemaNode(colander.String(),
validator=colander.All(
colander.Length(12, 42),
colander.Regex(r'foo*bar')
))
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
'pattern': 'foo*bar',
'maxLength': 42,
'minLength': 12,
})
def test_not_required(self):
class Mapping(colander.MappingSchema):
foo = colander.SchemaNode(colander.String(),
missing=colander.drop)
node = Mapping()
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'object',
'properties': {
'foo': {
'title': 'Foo',
'type': 'string'
}
},
})
def test_multi_level(self):
handler = DefinitionHandler(ref=-1)
ref1 = handler.from_schema(FeelingsSchema(title='Feelings'))
self.assertEquals(ref1, {'$ref': '#/definitions/Feelings'})
feelings_schema = {
'properties': {
'aaaa': {
'$ref': '#/definitions/Aaaa'
},
'bleh': {
'$ref': '#/definitions/Bleh'
}
}
}
self.assertDictContainsSubset(feelings_schema,
handler.definition_registry['Feelings'])
self.assertDictContainsSubset(convert(AnxietySchema()),
handler.definition_registry['Aaaa'])
def test_open_schema(self):
class Mapping(colander.MappingSchema):
foo = colander.SchemaNode(colander.String(),
missing=colander.drop)
@staticmethod
def schema_type():
return colander.Mapping(unknown='preserve')
node = Mapping()
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'object',
'properties': {
'foo': {
'title': 'Foo',
'type': 'string'
}
},
'additionalProperties': {}
})
def test_sanity(self):
node = colander.SchemaNode(colander.Integer())
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'integer',
})
def test_from_schema(self):
self.assertDictEqual(self.handler.from_schema(FeelingsSchema()),
convert(FeelingsSchema()))
def test_sanity(self):
node = colander.MappingSchema()
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'object',
})
def test_sanity(self):
node = colander.SchemaNode(colander.String())
ret = convert(node)
self.assertDictEqual(ret, {
'type': 'string',
})
