def test_request_view_with_predicates():
app = App()
c = setup()
c.configurable(app)
c.commit()
def view(request, model):
return {'hey': 'hey'}
register_view(app, Model, view, render=render_json,
predicates=dict(name='foo'))
request = app.request(get_environ(path=''))
request.mounts = [app] # XXX should do this centrally
model = Model()
# since the name is set to foo, we get nothing here
assert request.view(model) is None
# we have to pass the name predicate ourselves
assert request.view(model, name='foo') == {'hey': 'hey'}
# the predicate information in the request is ignored when we do a
# manual view lookup using request.view
request = app.request(get_environ(path='foo'))
request.mounts = [app] # XXX should do this centrally
assert request.view(model) is None
def test_predicates():
config = setup()
class app(App):
testing_config = config
config.commit()
def view(self, request):
return "all"
def post_view(self, request):
return "post"
registry = app.registry
register_view(registry, dict(model=Model), view)
register_view(registry, dict(model=Model, request_method='POST'),
post_view)
model = Model()
assert resolve_response(
app().request(get_environ(path='')), model).body == b'all'
assert (resolve_response(app().
request(get_environ(path='', method='POST')),
model).body == b'post')
def test_request_view_with_predicates():
config = setup()
class app(morepath.App):
testing_config = config
config.commit()
def view(self, request):
return {'hey': 'hey'}
register_view(app.registry, dict(model=Model, name='foo'), view,
render=render_json)
request = app().request(get_environ(path=''))
model = Model()
# since the name is set to foo, we get nothing here
assert request.view(model) is None
# we have to pass the name predicate ourselves
assert request.view(model, name='foo') == {'hey': 'hey'}
# the predicate information in the request is ignored when we do a
# manual view lookup using request.view
request = app().request(get_environ(path='foo'))
assert request.view(model) is None
def test_notfound_with_predicates():
setup()
app = App()
def view(request, model):
return "view"
register_view(app, Model, view, predicates=dict(name=''))
model = Model()
response = publish(get_request(path='foo', app=app), model)
assert response.status == '404 NOT FOUND'
def test_response_returned():
setup()
app = App()
def view(request, model):
return Response('Hello world!')
register_view(app, Model, view)
model = Model()
response = publish(get_request(path='', app=app), model)
assert response.data == 'Hello world!'
def test_notfound_with_predicates():
setup()
app = App()
def view(request, model):
return "view"
register_view(app, Model, view, predicates=dict(name=''))
model = Model()
response = publish(get_request(path='foo', app=app), model)
assert response.status == '404 NOT FOUND'
def test_response_returned():
setup()
app = App()
def view(request, model):
return Response('Hello world!')
register_view(app, Model, view)
model = Model()
response = publish(get_request(path='', app=app), model)
assert response.data == 'Hello world!'
def test_response_returned():
config = setup()
app = App(testing_config=config)
config.commit()
def view(self, request):
return Response('Hello world!')
register_view(app, Model, view)
model = Model()
response = resolve_response(app.request(get_environ(path='')), model)
assert response.data == 'Hello world!'
def test_view():
setup()
app = App()
def view(request, model):
return "View!"
register_view(app, Model, view, predicates=dict(name=''))
model = Model()
result = publish(get_request(path='', app=app), model)
assert result.data == 'View!'
def test_view():
setup()
app = App()
def view(request, model):
return "View!"
register_view(app, Model, view, predicates=dict(name=''))
model = Model()
result = publish(get_request(path='', app=app), model)
assert result.data == 'View!'
def test_view():
config = setup()
app = App(testing_config=config)
config.commit()
def view(self, request):
return "View!"
register_view(app, Model, view, predicates=dict(name=''))
model = Model()
result = resolve_response(app.request(get_environ(path='')), model)
assert result.data == 'View!'
def test_response_returned():
app = App()
c = setup()
c.configurable(app)
c.commit()
def view(request, model):
return Response('Hello world!')
register_view(app, Model, view)
model = Model()
response = resolve_response(app.request(get_environ(path='')), model)
assert response.data == 'Hello world!'
def test_render_html():
setup()
app = App()
def view(request, model):
return '<p>Hello world!</p>'
register_view(app, Model, view, render=render_html)
request = get_request(path='', app=app)
model = Model()
response = publish(request, model)
assert response.data == '<p>Hello world!</p>'
assert response.content_type == 'text/html'
def test_render_html():
setup()
app = App()
def view(request, model):
return '<p>Hello world!</p>'
register_view(app, Model, view, render=render_html)
request = get_request(path='', app=app)
model = Model()
response = publish(request, model)
assert response.data == '<p>Hello world!</p>'
assert response.content_type == 'text/html'
def test_notfound_with_predicates():
config = setup()
app = App(testing_config=config)
config.commit()
def view(self, request):
return "view"
register_view(app, Model, view, predicates=dict(name=''))
model = Model()
request = app.request(get_environ())
request.unconsumed = ['foo']
with pytest.raises(NotFound):
resolve_response(request, model)
def test_response_returned():
config = setup()
class app(morepath.App):
testing_config = config
config.commit()
def view(self, request):
return Response('Hello world!')
register_view(app.registry, dict(model=Model), view)
model = Model()
response = resolve_response(app().request(get_environ(path='')), model)
assert response.body == b'Hello world!'
def test_render_html():
config = setup()
app = App(testing_config=config)
config.commit()
def view(self, request):
return '<p>Hello world!</p>'
register_view(app, Model, view, render=render_html)
request = app.request(get_environ(path=''))
model = Model()
response = resolve_response(request, model)
assert response.data == '<p>Hello world!</p>'
assert response.content_type == 'text/html'
def test_view():
app = App()
c = setup()
c.configurable(app)
c.commit()
def view(request, model):
return "View!"
register_view(app, Model, view, predicates=dict(name=''))
model = Model()
result = resolve_response(app.request(get_environ(path='')), model)
assert result.data == 'View!'
def test_view_raises_http_error():
config = setup()
app = App(testing_config=config)
config.commit()
from werkzeug.exceptions import BadRequest
def view(self, request):
raise BadRequest()
register_path(app, Model, 'foo', None, None, None, Model)
register_view(app, Model, view)
response = publish(app.request(get_environ(path='foo')), app.mounted())
assert response.status == '400 BAD REQUEST'
def test_view_raises_http_error():
config = setup()
app = App(testing_config=config)
config.commit()
def view(self, request):
raise HTTPBadRequest()
register_path(app, Model, 'foo', None, None, None, None, Model)
register_view(app, Model, view)
request = app.request(get_environ(path='foo'))
request.mounts.append(app.mounted())
with pytest.raises(HTTPBadRequest):
publish(request)
def test_view():
config = setup()
class app(App):
testing_config = config
config.commit()
def view(self, request):
return "View!"
register_view(app.registry, dict(model=Model), view)
model = Model()
result = resolve_response(app().request(get_environ(path='')), model)
assert result.body == b'View!'
def test_view_raises_http_error():
app = App()
c = setup()
c.configurable(app)
c.commit()
from werkzeug.exceptions import BadRequest
def view(request, model):
raise BadRequest()
register_model(app, Model, 'foo', None, Model)
register_view(app, Model, view)
response = publish(app.request(get_environ(path='foo')), app.mounted())
assert response.status == '400 BAD REQUEST'
def test_request_view():
setup()
app = App()
def view(request, model):
return {'hey': 'hey'}
register_view(app, Model, view, render=render_json)
request = get_request(path='', app=app)
model = Model()
response = publish(request, model)
# when we get the response, the json will be rendered
assert response.data == '{"hey": "hey"}'
assert response.content_type == 'application/json'
# but we get the original json out when we access the view
assert request.view(model) == {'hey': 'hey'}
def test_view_after():
config = setup()
app = App(testing_config=config)
config.commit()
def view(self, request):
@request.after
def set_header(response):
response.headers.add('Foo', 'FOO')
return "View!"
register_view(app, Model, view, predicates=dict(name=''))
model = Model()
result = resolve_response(app.request(get_environ(path='')), model)
assert result.data == 'View!'
assert result.headers.get('Foo') == 'FOO'
def test_request_view():
setup()
app = App()
def view(request, model):
return {'hey': 'hey'}
register_view(app, Model, view, render=render_json)
request = get_request(path='', app=app)
model = Model()
response = publish(request, model)
# when we get the response, the json will be rendered
assert response.data == '{"hey": "hey"}'
assert response.content_type == 'application/json'
# but we get the original json out when we access the view
assert request.view(model) == {'hey': 'hey'}
def test_notfound_with_predicates():
config = setup()
class app(morepath.App):
testing_config = config
config.commit()
def view(self, request):
return "view"
register_view(app.registry, dict(model=Model), view)
model = Model()
request = app().request(get_environ(''))
request.unconsumed = ['foo']
with pytest.raises(HTTPNotFound):
resolve_response(request, model)
def test_predicates():
setup()
app = App()
def view(request, model):
return "all"
def post_view(request, model):
return "post"
register_view(app, Model, view, predicates=dict(name=''))
register_view(app, Model, post_view,
predicates=dict(name='', request_method='POST'))
model = Model()
assert publish(get_request(path='', app=app), model).data == 'all'
assert (publish(get_request(path='', method='POST', app=app),
model).data == 'post')
def test_render_html():
config = setup()
class app(App):
testing_config = config
config.commit()
def view(self, request):
return '<p>Hello world!</p>'
register_view(app.registry, dict(model=Model), view, render=render_html)
request = app().request(get_environ(path=''))
model = Model()
response = resolve_response(request, model)
assert response.body == b'<p>Hello world!</p>'
assert response.content_type == 'text/html'
def test_view_raises_http_error():
config = setup()
class app(morepath.App):
testing_config = config
config.commit()
def view(self, request):
raise HTTPBadRequest()
registry = app.registry
register_path(registry, Model, 'foo', None, None, None, None, False, Model)
register_view(registry, dict(model=Model), view)
request = app().request(get_environ(path='foo'))
with pytest.raises(HTTPBadRequest):
publish(request)
def test_request_view():
app = App()
c = setup()
c.configurable(app)
c.commit()
def view(request, model):
return {'hey': 'hey'}
register_view(app, Model, view, render=render_json)
request = app.request(get_environ(path=''))
model = Model()
response = resolve_response(request, model)
# when we get the response, the json will be rendered
assert response.data == '{"hey": "hey"}'
assert response.content_type == 'application/json'
# but we get the original json out when we access the view
assert request.view(model) == {'hey': 'hey'}
def test_predicates():
config = setup()
app = App(testing_config=config)
config.commit()
def view(self, request):
return "all"
def post_view(self, request):
return "post"
register_view(app, Model, view, predicates=dict(name=''))
register_view(app, Model, post_view,
predicates=dict(name='', request_method='POST'))
model = Model()
assert resolve_response(
app.request(get_environ(path='')), model).data == 'all'
assert (resolve_response(app.request(get_environ(path='', method='POST')),
model).data == 'post')
def test_request_view():
config = setup()
app = App(testing_config=config)
config.commit()
def view(self, request):
return {'hey': 'hey'}
register_view(app, Model, view, render=render_json)
request = app.request(get_environ(path=''))
request.mounts = [app] # XXX should do this centrally
model = Model()
response = resolve_response(request, model)
# when we get the response, the json will be rendered
assert response.data == '{"hey": "hey"}'
assert response.content_type == 'application/json'
# but we get the original json out when we access the view
assert request.view(model) == {'hey': 'hey'}
def test_predicates():
setup()
app = App()
def view(request, model):
return "all"
def post_view(request, model):
return "post"
register_view(app, Model, view, predicates=dict(name=''))
register_view(app,
Model,
post_view,
predicates=dict(name='', request_method='POST'))
model = Model()
assert publish(get_request(path='', app=app), model).data == 'all'
assert (publish(get_request(path='', method='POST', app=app),
model).data == 'post')
def test_view_after_non_decorator():
app = App()
c = setup()
c.configurable(app)
c.commit()
def set_header(response):
response.headers.add('Foo', 'FOO')
def view(request, model):
request.after(set_header)
return "View!"
register_view(app, Model, view, predicates=dict(name=''))
model = Model()
result = resolve_response(app.request(get_environ(path='')), model)
assert result.data == 'View!'
assert result.headers.get('Foo') == 'FOO'
def test_conditional_view_after():
config = setup()
class app(morepath.App):
testing_config = config
config.commit()
def view(self, request):
if False:
@request.after
def set_header(response):
response.headers.add('Foo', 'FOO')
return "View!"
register_view(app.registry, Model, view, predicates=dict(name=''))
model = Model()
result = resolve_response(app().request(get_environ(path='')), model)
assert result.body == b'View!'
assert result.headers.get('Foo') is None
def test_view_after_non_decorator():
config = setup()
class app(morepath.App):
testing_config = config
config.commit()
def set_header(response):
response.headers.add('Foo', 'FOO')
def view(self, request):
request.after(set_header)
return "View!"
register_view(app.registry, dict(model=Model), view)
model = Model()
result = resolve_response(app().request(get_environ(path='')), model)
assert result.body == b'View!'
assert result.headers.get('Foo') == 'FOO'
