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)
