def test_body_supports_binding_after_other_binds(self): querystring = colander.MappingSchema(missing={"foo": "bar"}) bound = self.schema.bind(querystring=querystring) body = colander.MappingSchema(missing={"foo": "beer"}) bound = bound.bind(body=body) deserialized = bound.deserialize({}) self.assertEqual(deserialized["querystring"], {"foo": "bar"}) self.assertEqual(deserialized["body"], {"foo": "beer"})
def test_body_supports_binding_after_other_binds(self): querystring = colander.MappingSchema(missing={'foo': 'bar'}) bound = self.schema.bind(querystring=querystring) body = colander.MappingSchema(missing={'foo': 'beer'}) bound = bound.bind(body=body) deserialized = bound.deserialize({}) self.assertEquals(deserialized['querystring'], {'foo': 'bar'}) self.assertEquals(deserialized['body'], {'foo': 'beer'})
def body_schema_transformer(schema, args): validators = args.get('validators', []) if colander_bound_repository_body_validator in validators: body_schema = schema schema = colander.MappingSchema() schema['body'] = body_schema return schema
def get_record_schema(self, resource_cls, method): """Return the Cornice schema for the given method. """ simple_mapping = colander.MappingSchema(unknown='preserve') if method.lower() not in map(str.lower, self.validate_schema_for): # Simply validate that posted body is a mapping. return simple_mapping if method.lower() == 'patch': record_mapping = simple_mapping else: record_mapping = resource_cls.mapping try: record_mapping.deserialize({}) # Empty data accepted. record_mapping.missing = colander.drop record_mapping.default = {} except colander.Invalid: pass class PayloadSchema(colander.MappingSchema): data = record_mapping def schema_type(self, **kw): return colander.Mapping(unknown='raise') return PayloadSchema()
def _get_self_view( self, request=testing.DummyRequest(layout_manager=mock.Mock())): from pyramid_bimt.views import FormView view = FormView(request) view.title = 'Foo Form' view.schema = colander.MappingSchema() return view
class ErrorCallBodySchema(ErrorFallbackBodySchema): detail = colander.SchemaNode( colander.String(), description="Contextual explanation about the cause of error.") content = colander.MappingSchema( default=None, unknown="preserve", description="Additional contextual details that lead to the error. " "Can have any amount of sub-field to describe evaluated values.")
def test_call_with_context_with_sheets(self, context, request, mock_content_registry, mock_sheet): mock_sheet.get.return_value = {} mock_sheet.schema = colander.MappingSchema() isheet = mock_sheet.meta.isheet mock_content_registry.get_sheets_read.return_value = [mock_sheet] assert self.call_fut(context, request) == {isheet.__identifier__: {}} assert mock_content_registry.get_sheets_read.call_args[0] == (context, request)
def claims_membership_form(): return deform.Form(action="/register", title=_(u"Are you a C3S member?"), schema=colander.MappingSchema(), buttons=[ deform.Button('claims_membership', _(u"Yes"), css_class="btn-default btn-lg"), deform.Button('claims_no_membership', _(u"No")) ])
def mock_sheet() -> Mock: """Mock :class:`adhocracy_core.sheets.GenericResourceSheet`.""" from adhocracy_core.sheets import sheet_meta from adhocracy_core.interfaces import ISheet # Better would be spec=GenericResourceSheet for the mock object; # however this fails if the object is deepcopied. sheet = Mock() sheet.meta = sheet_meta._replace(isheet=ISheet, schema_class=colander.MappingSchema) sheet.schema = colander.MappingSchema() sheet.get.return_value = {} return sheet
def wants_membership_form(): return deform.Form(action="/register", title=_(u"Do you want to apply for C3S membership?"), schema=colander.MappingSchema(), buttons=[ deform.Button('wants_membership', _(u"Yes"), css_class="btn-lg"), deform.Button('wants_no_membership', _(u"No")), deform.Button('back', _(u"Back"), css_class="btn-xs") ])
def test_issue_71(self): import deform import colander from bs4 import BeautifulSoup schema = colander.MappingSchema(title='SCHEMA_TITLE') form = deform.Form(schema) html = form.render(colander.null) # check that title occurs exactly once in rendered output soup = BeautifulSoup(html) self.assertEqual( len([string for string in soup.strings if schema.title in string]), 1)
def _extract_transform_colander_schema(self, args): """ Extract schema from view args and transform it using the pipeline of schema transformers :param args: Arguments from the view decorator. :rtype: colander.MappingSchema() :returns: View schema cloned and transformed """ schema = args.get('schema', colander.MappingSchema()) if not isinstance(schema, colander.Schema): schema = schema() schema = schema.clone() for transformer in self.schema_transformers: schema = transformer(schema, args) return schema
def node() -> colander.MappingSchema: """Return dummy node.""" return colander.MappingSchema()
self.kwargs = kwargs def __call__(self, environ, start_response): from webob import Response r = Response() r.body = '<h1>Hello dummy</h1>' return r(environ, start_response) class DummyFilterFactory(object): def __init__(self, app, **kwargs): self.app = app def __call__(self, environ, start_response): return self.app(environ, start_response) class DummyApp(object): pass DummyComponent = WSGIComponent( schema=DummySchema(), factory=DummyFactory, ) DummyFilter = WSGIComponent( schema=colander.MappingSchema(), factory=DummyFilterFactory, )
def _add_other_node(inst: colander.Schema): other_node = colander.MappingSchema(name='other', missing={}) inst.add(other_node)
def test_querystring_supports_binding(self): querystring = colander.MappingSchema(missing={"foo": "bar"}) bound = self.schema.bind(querystring=querystring) deserialized = bound.deserialize({}) self.assertEqual(deserialized["querystring"], {"foo": "bar"})
def test_querystring_supports_binding(self): querystring = colander.MappingSchema(missing={'foo': 'bar'}) bound = self.schema.bind(querystring=querystring) deserialized = bound.deserialize({}) self.assertEquals(deserialized['querystring'], {'foo': 'bar'})
def test_header_supports_binding(self): header = colander.MappingSchema(missing={'foo': 'bar'}) bound = self.schema.bind(header=header) deserialized = bound.deserialize({}) self.assertEquals(deserialized['header'], {'foo': 'bar'})
def back_reference_sheet(self, mock_sheet): schema = colander.MappingSchema() _add_post_pool_node(schema, iresource_or_service_name='right') mock_sheet.schema = schema return mock_sheet
def body(node, kwargs): resource = kwargs.get('record')['data'] collection = colander.MappingSchema() collection['data'] = colander.SequenceSchema(resource, missing=[]) return collection
def test_header_supports_binding(self): header = colander.MappingSchema(missing={"foo": "bar"}) bound = self.schema.bind(header=header) deserialized = bound.deserialize({}) self.assertEqual(deserialized["header"], {"foo": "bar"})
def test_body_supports_binding(self): body = colander.MappingSchema(missing={'foo': 'bar'}) bound = self.schema.bind(body=body) deserialized = bound.deserialize({}) self.assertEquals(deserialized['body'], {'foo': 'bar'})
def test_body_supports_binding(self): body = colander.MappingSchema(missing={"foo": "bar"}) bound = self.schema.bind(body=body) deserialized = bound.deserialize({}) self.assertEqual(deserialized["body"], {"foo": "bar"})
def body(node, kwargs): resource = kwargs.get("record")["data"] collection = colander.MappingSchema() collection["data"] = colander.SequenceSchema(resource, missing=[]) return collection
def setUp(self): self.handler = schema.ResourceReponses() self.resource = colander.MappingSchema(title="fake") self.obj = schema.ObjectSchema().bind(data=self.resource)
def body(node, kwargs): resource = kwargs.get("object")["data"] datalist = colander.MappingSchema() datalist["data"] = colander.SequenceSchema(resource, missing=[]) return datalist
def setUp(self): self.handler = schema.ShareableResourseResponses() self.resource = colander.MappingSchema(title='fake') self.permissions = colander.MappingSchema(title='bla') self.record = schema.RecordSchema().bind(data=self.resource, permissions=self.permissions)
def test_sanity(self): node = colander.MappingSchema() params = self.handler.from_schema(node) self.assertEquals(params, [])
class RequestSchema(colander.MappingSchema): body = colander.MappingSchema()
def setUp(self): self.handler = schema.ResourceReponses() self.resource = colander.MappingSchema(title='fake') self.record = schema.RecordSchema().bind(data=self.resource)