def test_traject_with_multiple_variables():
app = App()
traject = Traject()
def get_model(first_id):
result = Model()
result.first_id = first_id
return result
def get_special(first_id, second_id):
result = Special()
result.first_id = first_id
result.second_id = second_id
return result
traject.add_pattern('{first_id}', get_model)
traject.add_pattern('{first_id}/{second_id}', get_special)
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, 'a')
assert isinstance(found, Model)
assert found.first_id == 'a'
assert not hasattr(found, 'second_id')
assert request.unconsumed == []
found, request = consume(app, 'a/b')
assert isinstance(found, Special)
assert found.first_id == 'a'
assert found.second_id == 'b'
assert request.unconsumed == []
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_view_predicates():
app = App()
class Root(object):
pass
def get(request, model):
return 'GET'
def post(request, model):
return 'POST'
c = setup()
c.configurable(app)
c.action(app.root(), Root)
c.action(app.view(model=Root, name='foo', request_method='GET'),
get)
c.action(app.view(model=Root, name='foo', request_method='POST'),
post)
c.commit()
c = Client(app, Response)
response = c.get('/foo')
assert response.data == 'GET'
response = c.post('/foo')
assert response.data == 'POST'
def test_traject_nested_with_variable():
app = App()
traject = Traject()
def get_model(id):
result = Model()
result.id = id
return result
def get_special(id):
result = Special()
result.id = id
return result
traject.add_pattern('{id}', get_model)
traject.add_pattern('{id}/sub', get_special)
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, 'a')
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(app, 'b')
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(app, 'a/sub')
assert isinstance(found, Special)
assert request.unconsumed == []
def test_notfound():
config = setup()
app = App(testing_config=config)
config.commit()
response = publish(app.request(get_environ(path='')), app.mounted())
assert response.status == '404 NOT FOUND'
def test_app_with_parent():
parentapp = App()
myapp = App('myapp', parent=parentapp)
assert myapp.parent is parentapp
assert myapp.name == 'myapp'
assert myapp.child_apps == {}
assert parentapp.child_apps == {'myapp': myapp}
def test_view_predicates():
setup()
app = App()
class Root(object):
pass
def get(request, model):
return 'GET'
def post(request, model):
return 'POST'
c = Config()
c.action(app, app)
c.action(app.root(), Root)
c.action(app.view(model=Root, name='foo', request_method='GET'), get)
c.action(app.view(model=Root, name='foo', request_method='POST'), post)
c.commit()
c = Client(app, Response)
response = c.get('/foo')
assert response.data == 'GET'
response = c.post('/foo')
assert response.data == 'POST'
def test_traject_consumer_combination():
app = App()
traject = Traject()
def get_model(foo):
result = Model()
result.foo = foo
return result
traject.register('special', Special)
traject.register('{foo}', get_model)
app.register(generic.traject, [App], lambda base: traject)
found, obj, stack = traject_consumer(app, parse_path('something'),
Lookup(app))
assert found
assert isinstance(obj, Model)
assert stack == []
assert obj.foo == 'something'
found, obj, stack = traject_consumer(app, parse_path('special'),
Lookup(app))
assert found
assert isinstance(obj, Special)
assert stack == []
def test_traject_nested_with_variable():
app = App()
traject = Traject()
def get_model(id):
result = Model()
result.id = id
return result
def get_special(id):
result = Special()
result.id = id
return result
traject.add_pattern("{id}", (get_model, paramfac))
traject.add_pattern("{id}/sub", (get_special, paramfac))
app.register(generic.traject, [App], lambda base: traject)
app.register(generic.context, [object], lambda obj: {})
found, request = consume(app, "a")
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(app, "b")
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(app, "a/sub")
assert isinstance(found, Special)
assert request.unconsumed == []
def test_register_model():
setup()
app = App()
root = Root()
app.root_model = Root
app.root_obj = root
lookup = Lookup(ChainClassLookup(app, global_app))
def get_model(id):
model = Model()
model.id = id
return model
register_root(app, Root, lambda: root)
register_model(app, Model, '{id}', lambda model: {'id': model.id},
get_model)
found, obj, stack = traject_consumer(app, parse_path('a'), lookup)
assert obj.id == 'a'
model = Model()
model.id = 'b'
request = get_request()
request.lookup = lookup
assert generic.path(request, model, lookup=lookup) == 'b'
assert generic.base(model, lookup=lookup) is app
def test_traject_with_multiple_variables():
app = App()
traject = Traject()
def get_model(first_id):
result = Model()
result.first_id = first_id
return result
def get_special(first_id, second_id):
result = Special()
result.first_id = first_id
result.second_id = second_id
return result
traject.register('{first_id}', get_model)
traject.register('{first_id}/{second_id}', get_special)
app.register(generic.traject, [App], lambda base: traject)
found, obj, stack = traject_consumer(app, parse_path('a'), Lookup(app))
assert found
assert isinstance(obj, Model)
assert stack == []
assert obj.first_id == 'a'
assert not hasattr(obj, 'second_id')
found, obj, stack = traject_consumer(app, parse_path('a/b'), Lookup(app))
assert found
assert isinstance(obj, Special)
assert stack == []
assert obj.first_id == 'a'
assert obj.second_id == 'b'
def test_traject_nested_with_variable():
app = App()
traject = Traject()
def get_model(id):
result = Model()
result.id = id
return result
def get_special(id):
result = Special()
result.id = id
return result
traject.register('{id}', get_model)
traject.register('{id}/sub', get_special)
app.register(generic.traject, [App], lambda base: traject)
found, obj, stack = traject_consumer(app, parse_path('a'), Lookup(app))
assert found
assert isinstance(obj, Model)
assert stack == []
found, obj, stack = traject_consumer(app, parse_path('b'), Lookup(app))
assert found
assert isinstance(obj, Model)
assert stack == []
found, obj, stack = traject_consumer(app, parse_path('a/sub'), Lookup(app))
assert found
assert isinstance(obj, Special)
assert stack == []
def test_register_path_with_parameters():
config = setup()
app = App(testing_config=config)
root = Root()
lookup = app.lookup
def get_model(id, param='default'):
model = Model()
model.id = id
model.param = param
return model
config.commit()
register_path(app, Root, '', lambda m: {}, None, None, None, lambda: root)
register_path(app, Model, '{id}', lambda model: {'id': model.id,
'param': model.param},
None, None, None, get_model)
app.register(generic.context, [object], lambda obj: {})
obj, request = consume(app, 'a')
assert obj.id == 'a'
assert obj.param == 'default'
obj, request = consume(app, 'a', {'param': 'value'})
assert obj.id == 'a'
assert obj.param == 'value'
model = Model()
model.id = 'b'
model.param = 'other'
assert generic.path(model, lookup=lookup) == ('b', {'param': ['other']})
def test_extra_predicates():
app = App()
class Model(object):
def __init__(self, id):
self.id = id
def get_a(request, model):
return 'a'
def get_b(request, model):
return 'b'
def get_id(request, model):
return model.id
c = setup()
c.configurable(app)
c.action(app.model(path='{id}'), Model)
c.action(app.view(model=Model, name='foo', id='a'),
get_a)
c.action(app.view(model=Model, name='foo', id='b'),
get_b)
c.action(app.predicate(name='id', order=2, default=''),
get_id)
c.commit()
c = Client(app, Response)
response = c.get('/a/foo')
assert response.data == 'a'
response = c.post('/b/foo')
assert response.data == 'b'
def test_traject_with_multiple_variables():
app = App()
traject = Traject()
def get_model(first_id):
result = Model()
result.first_id = first_id
return result
def get_special(first_id, second_id):
result = Special()
result.first_id = first_id
result.second_id = second_id
return result
traject.add_pattern("{first_id}", (get_model, paramfac))
traject.add_pattern("{first_id}/{second_id}", (get_special, paramfac))
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, "a")
assert isinstance(found, Model)
assert found.first_id == "a"
assert not hasattr(found, "second_id")
assert request.unconsumed == []
found, request = consume(app, "a/b")
assert isinstance(found, Special)
assert found.first_id == "a"
assert found.second_id == "b"
assert request.unconsumed == []
def test_traject_consume():
app = App()
traject = Traject()
traject.add_pattern('sub', Model)
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, 'sub')
assert isinstance(found, Model)
assert request.unconsumed == []
def test_traject_consumer():
app = App()
traject = Traject()
traject.register('sub', Model)
app.register(generic.traject, [App], lambda base: traject)
found, obj, stack = traject_consumer(app, parse_path('sub'), Lookup(app))
assert found
assert isinstance(obj, Model)
assert stack == []
def test_notfound():
app = App()
c = setup()
c.configurable(app)
c.commit()
response = publish(app.request(get_environ(path='')), app.mounted())
assert response.status == '404 NOT FOUND'
def test_notfound():
config = setup()
app = App(testing_config=config)
config.commit()
request = app.request(get_environ(path=''))
request.mounts.append(app.mounted())
with pytest.raises(HTTPNotFound):
publish(request)
def test_traject_consume():
app = App()
traject = Traject()
traject.add_pattern("sub", (Model, paramfac))
app.register(generic.traject, [App], lambda base: traject)
app.register(generic.context, [object], lambda obj: {})
found, request = consume(app, "sub")
assert isinstance(found, Model)
assert request.unconsumed == []
def test_traject_root():
app = App()
traject = Traject()
traject.add_pattern("", (Root, paramfac))
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, "")
assert isinstance(found, Root)
assert request.unconsumed == []
def test_traject_nested_not_resolved_entirely_by_consumer():
app = App()
traject = Traject()
traject.add_pattern('a', Model)
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, 'a')
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(app, 'a/b')
assert isinstance(found, Model)
assert request.unconsumed == ['b']
def test_traject_nested_not_resolved_entirely_by_consumer():
app = App()
traject = Traject()
traject.add_pattern("a", (Model, paramfac))
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, "a")
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(app, "a/b")
assert isinstance(found, Model)
assert request.unconsumed == ["b"]
def test_register_root():
app = App()
root = Root()
lookup = app.lookup()
c = setup()
c.configurable(app)
c.commit()
register_root(app, Root, lambda: root)
assert generic.path(root, lookup=lookup) == ''
assert generic.base(root, lookup=lookup) is app
def test_register_root():
app = App()
root = Root()
app.root_model = Root
app.root_obj = root
lookup = Lookup(ChainClassLookup(app, global_app))
register_root(app, Root, lambda: root)
request = get_request()
request.lookup = lookup
assert generic.path(request, root, lookup=lookup) == ''
assert generic.base(root, lookup=lookup) is app
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():
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_overrides_model():
app = App()
overriding = App(extends=[app])
c = setup()
c.configurable(app)
c.configurable(overriding)
class User(object):
def __init__(self, username):
self.username = username
c.action(
app.model(
path='users/{username}',
variables=lambda model: {'username': model.username}),
User)
def render_user(request, model):
return "User: %s" % model.username
c.action(
app.view(
model=User),
render_user)
def get_user(username):
if username != 'bar':
return None
return User(username)
c.action(
overriding.model(
model=User,
path='users/{username}',
variables=lambda model: {'username': model.username}),
get_user)
c.commit()
cl = Client(app, Response)
response = cl.get('/users/foo')
assert response.data == 'User: foo'
response = cl.get('/users/bar')
assert response.data == 'User: bar'
cl = Client(overriding, Response)
response = cl.get('/users/foo')
assert response.status == '404 NOT FOUND'
response = cl.get('/users/bar')
assert response.data == 'User: bar'
def test_traject_nested():
app = App()
traject = Traject()
traject.add_pattern("a", (Model, paramfac))
traject.add_pattern("a/b", (Special, paramfac))
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, "a")
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(app, "a/b")
assert isinstance(found, Special)
assert request.unconsumed == []
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_traject_nested_not_resolved_entirely_by_consumer():
app = App()
traject = Traject()
traject.register('a', Model)
app.register(generic.traject, [App], lambda base: traject)
found, obj, stack = traject_consumer(app, parse_path('a'), Lookup(app))
assert found
assert isinstance(obj, Model)
assert stack == []
found, obj, stack = traject_consumer(app, parse_path('a/b'), Lookup(app))
assert found
assert isinstance(obj, Model)
assert stack == [('default', 'b')]
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_traject_consumer_factory_returns_none():
app = App()
traject = Traject()
def get_model():
return None
traject.register('sub', get_model)
app.register(generic.traject, [App], lambda base: traject)
found, obj, stack = traject_consumer(app, parse_path('sub'), Lookup(app))
assert not found
assert obj is app
assert stack == [(u'default', 'sub')]
def test_view_after_doesnt_apply_to_returned_404_exception():
class App(morepath.App):
pass
class Root(object):
pass
@App.path(model=Root, path='')
def get_root():
return Root()
@App.view(model=Root)
def view(self, request):
@request.after
def set_header(response):
response.headers.add('Foo', 'FOO')
return HTTPNotFound()
dectate.commit(App)
c = Client(App())
response = c.get('/', status=404)
assert response.headers.get('Foo') is None
def test_view_after_applies_to_some_exceptions(status_code, exception_class):
class App(morepath.App):
pass
class Root(object):
pass
@App.path(model=Root, path='')
def get_root():
return Root()
@App.view(model=Root)
def view(self, request):
@request.after
def set_header(response):
response.headers.add('Foo', 'FOO')
raise exception_class()
dectate.commit(App)
c = Client(App())
response = c.get('/', status=status_code)
assert response.headers.get('Foo') == 'FOO'
def test_view_after_doesnt_apply_to_exception_view():
class App(morepath.App):
pass
class Root(object):
pass
class MyException(Exception):
pass
@App.path(model=Root, path='')
def get_root():
return Root()
@App.view(model=Root)
def view(self, request):
@request.after
def set_header(response):
response.headers.add('Foo', 'FOO')
raise MyException()
@App.view(model=MyException)
def exc_view(self, request):
return "My exception"
dectate.commit(App)
c = Client(App())
response = c.get('/')
assert response.body == b'My exception'
assert response.headers.get('Foo') is None
def test_imperative():
setup()
class Foo(object):
pass
@reg.generic
def target():
pass
app = App()
c = Config()
c.action(app, app)
foo = Foo()
c.action(app.function(target), foo)
c.commit()
assert target.component(lookup=app.lookup()) is foo
def test_traject_path_with_leading_slash():
setup()
app = App()
root = Root()
app.root_model = Root
app.root_obj = root
lookup = Lookup(ChainClassLookup(app, global_app))
def get_model(id):
model = Model()
model.id = id
return model
register_root(app, Root, lambda: root)
register_model(app, Model, '/foo/{id}', lambda model: {'id': model.id},
get_model)
found, obj, stack = traject_consumer(app, parse_path('foo/a'), lookup)
assert obj.id == 'a'
found, obj, stack = traject_consumer(app, parse_path('/foo/a'), lookup)
assert obj.id == 'a'
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_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_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_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_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_traject_consumer_not_found():
app = App()
found, obj, stack = traject_consumer(app, parse_path('sub'), Lookup(app))
assert not found
assert obj is app
assert stack == [(u'default', 'sub')]
def test_app_without_parent():
myapp = App()
assert myapp.parent is None
assert myapp.name == ''
assert myapp.child_apps == {}
assert global_app.child_apps == {}
def test_base():
setup()
class Root(object):
pass
class Container(object):
def __init__(self, id):
self.id = id
self.items = {}
def add_item(self, item_id):
result = Item(item_id, self)
self.items[item_id] = result
return result
class Item(object):
def __init__(self, id, parent):
self.id = id
self.parent = parent
alpha = Container('alpha')
beta = Container('beta')
alpha.add_item('a')
alpha.add_item('b')
c = alpha.add_item('c')
beta.add_item('d')
e = beta.add_item('e')
app = App()
c = Config()
c.action(app, app)
c.action(app.root(), Root)
def get_container(container_id):
if container_id == 'alpha':
return alpha
elif container_id == 'beta':
return beta
return None
c.action(
app.model(model=Container,
path="{container_id}",
variables=lambda container: {'container_id': container.id}),
get_container)
def get_item(base, item_id):
return base.items.get(item_id)
c.action(
app.model(model=Item,
path="{item_id}",
variables=lambda item: {'item_id': item.id},
base=Container,
get_base=lambda item: item.parent), get_item)
c.action(app.view(model=Container),
lambda request, model: 'container: %s' % model.id)
c.action(app.view(model=Container, name='link'),
lambda request, model: request.link(model))
c.action(app.view(model=Item),
lambda request, model: 'item: %s' % model.id)
c.action(app.view(model=Item, name='link'),
lambda request, model: request.link(model))
c.action(app.view(model=Item, name='otherlink'),
lambda request, model: request.link(e))
c.commit()
c = Client(app, Response)
response = c.get('/alpha')
assert response.data == 'container: alpha'
response = c.get('/beta')
assert response.data == 'container: beta'
response = c.get('/alpha/a')
assert response.data == 'item: a'
response = c.get('/beta/e')
assert response.data == 'item: e'
response = c.get('/alpha/e')
assert response.status == '404 NOT FOUND'
response = c.get('/alpha/@@link')
assert response.data == 'alpha'
response = c.get('/alpha/a/link')
assert response.data == 'alpha/a'
response = c.get('/alpha/a/otherlink')
assert response.data == 'beta/e'
def test_notfound():
setup()
app = App()
model = Model()
response = publish(get_request(path='', app=app), model)
assert response.status == '404 NOT FOUND'
