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', })