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_dump_json():
class App(morepath.App):
pass
@App.dump_json(model=Foo)
def dump_foo():
pass
@App.dump_json(model=Bar)
def dump_bar():
pass
dectate.commit(App)
r = objects(dectate.query_app(
App, 'dump_json'))
assert r == [dump_foo, dump_bar]
r = objects(dectate.query_app(
App, 'dump_json',
model='morepath.tests.test_querytool.Foo'))
assert r == [dump_foo]
r = objects(dectate.query_app(
App, 'dump_json',
model='morepath.tests.test_querytool.SubFoo'))
assert r == [dump_foo]
def test_predicate_fallback():
class App(morepath.App):
pass
dectate.commit(App)
r = objects(dectate.query_app(App, 'predicate_fallback'))
assert r == [
core.model_not_found,
core.name_not_found,
core.method_not_allowed,
core.body_model_unprocessable
]
r = objects(dectate.query_app(App, 'predicate_fallback',
dispatch='morepath.generic.view'))
assert r == [
core.model_not_found,
core.name_not_found,
core.method_not_allowed,
core.body_model_unprocessable
]
# there aren't any predicates for path
r = objects(dectate.query_app(App, 'predicate_fallback',
dispatch='morepath.generic.path'))
assert r == []
r = objects(dectate.query_app(App, 'predicate_fallback',
func='morepath.core.model_predicate'))
assert r == [
core.model_not_found,
]
def test_view_body_model():
class App(morepath.App):
pass
@App.view(model=Foo, request_method='POST', body_model=Base)
def foo_base(self, request):
pass
@App.view(model=Foo, request_method='POST', body_model=Foo)
def foo_foo(self, request):
pass
dectate.commit(App)
r = objects(dectate.query_app(
App, 'view',
model='morepath.tests.test_querytool.Foo',
body_model='morepath.tests.test_querytool.Base'))
assert r == [foo_base]
r = objects(dectate.query_app(
App, 'view',
model='morepath.tests.test_querytool.Foo',
body_model='morepath.tests.test_querytool.Foo'))
assert r == [foo_base, foo_foo]
def test_template_directory():
class App(morepath.App):
pass
# non-decorator so we can import template_directory_a
App.template_directory()(template_directory_a)
@App.template_directory(after=template_directory_a, name='blah')
def b():
return '/'
dectate.commit(App)
r = objects(dectate.query_app(App, 'template_directory'))
assert r == [template_directory_a, b]
r = objects(dectate.query_app(App, 'template_directory',
name='blah'))
assert r == [b]
r = objects(dectate.query_app(
App, 'template_directory',
after='morepath.tests.test_querytool.template_directory_a'))
assert r == [b]
def test_mount():
class App(morepath.App):
pass
@App.path(path='foo', model=Foo)
def get_foo():
pass
@App.mount(path='mounted', app=Mounted)
def mount_app():
return Mounted()
dectate.commit(App, Mounted)
r = objects(dectate.query_app(
App, 'mount'))
assert r == [get_foo, mount_app]
r = objects(dectate.query_app(
App, 'mount', app='morepath.tests.test_querytool.Mounted'))
assert r == [mount_app]
r = objects(dectate.query_app(
App, 'mount', model='morepath.tests.test_querytool.Foo'))
assert r == [get_foo]
def test_defer_link_to_parent_from_root():
class root(morepath.App):
pass
class sub(morepath.App):
pass
@root.path(path='')
class Model(object):
pass
class OtherModel(object):
pass
@root.view(model=Model)
def model_default(self, request):
return request.link(OtherModel())
@root.defer_links(model=OtherModel)
def get_parent(app, obj):
return app.parent
dectate.commit(root, sub)
c = Client(root())
with pytest.raises(LinkError):
c.get('/')
def test_excview_named_view():
class app(morepath.App):
pass
@app.path(path='')
class Root(object):
pass
class MyException(Exception):
pass
@app.view(model=Root, name='view')
def view(self, request):
raise MyException()
# the view name should have no infleunce on myexception lookup
@app.view(model=MyException)
def myexception_default(self, request):
return "My exception"
dectate.commit(app)
c = Client(app())
response = c.get('/view')
assert response.body == b'My exception'
def test_function():
class App(morepath.App):
pass
@App.predicate(generic, name='v', default='', index=reg.KeyIndex)
def get(v):
return v
@App.function(generic, v='A')
def a(v):
return v
@App.function(generic, v='B')
def b(v):
return v
dectate.commit(App)
app = App()
assert generic('A', lookup=app.lookup) == 'A'
assert generic('B', lookup=app.lookup) == 'B'
r = objects(dectate.query_app(App, 'function'))
assert r == [a, b]
r = objects(
dectate.query_app(App, 'function',
func='morepath.tests.test_querytool.generic'))
assert r == [a, b]
r = objects(dectate.query_app(App, 'function', v='A'))
assert r == [a]
def test_permission_directive_no_identity():
class app(morepath.App):
pass
class Model(object):
def __init__(self, id):
self.id = id
class Permission(object):
pass
@app.path(model=Model, path='{id}',
variables=lambda model: {'id': model.id})
def get_model(id):
return Model(id)
@app.permission_rule(model=Model, permission=Permission, identity=None)
def get_permission(identity, model, permission):
if model.id == 'foo':
return True
else:
return False
@app.view(model=Model, permission=Permission)
def default(self, request):
return "Model: %s" % self.id
dectate.commit(app)
c = Client(app())
response = c.get('/foo')
assert response.body == b'Model: foo'
response = c.get('/bar', status=403)
def test_predicates():
class app(App):
pass
dectate.commit(app)
def view(self, request):
return "all"
def post_view(self, request):
return "post"
view_registry = app.config.view_registry
view_registry.register_view(dict(model=Model), view)
view_registry.register_view(
dict(model=Model, request_method='POST'),
post_view)
model = Model()
assert resolve_response(
model, app().request(get_environ(path=''))).body == b'all'
assert (
resolve_response(
model, app().request(get_environ(path='', method='POST'))).body ==
b'post')
def test_no_permission():
class app(morepath.App):
pass
class Model(object):
def __init__(self, id):
self.id = id
class Permission(object):
pass
@app.path(model=Model, path='{id}',
variables=lambda model: {'id': model.id})
def get_model(id):
return Model(id)
@app.view(model=Model, permission=Permission)
def default(self, request):
return "Model: %s" % self.id
dectate.commit(app)
c = Client(app())
c.get('/foo', status=403)
def test_method():
@App.predicate(App.generic, name='v', default='', index=reg.KeyIndex)
def get(self, v):
return v
@App.method(App.generic, v='A')
def a(app, v):
return v
@App.method(App.generic, v='B')
def b(app, v):
return v
dectate.commit(App)
app = App()
assert app.generic('A') == 'A'
assert app.generic('B') == 'B'
r = objects(dectate.query_app(App, 'method'))
assert r == [a, b]
r = objects(
dectate.query_app(
App, 'method',
dispatch_method='morepath.tests.test_querytool.App.generic'))
assert r == [a, b]
r = objects(dectate.query_app(App, 'method', v='A'))
assert r == [a]
def test_other_exception_excview():
class app(morepath.App):
pass
class MyException(Exception):
pass
@app.path(path='')
class Root(object):
pass
@app.view(model=Root)
def root_default(self, request):
raise MyException()
@app.view(model=MyException)
def myexception_default(self, request):
return "My exception"
dectate.commit(app)
c = Client(app())
response = c.get('/')
assert response.body == b'My exception'
def test_app_extends_settings():
class alpha(morepath.App):
pass
class beta(alpha):
pass
@alpha.setting('one', 'foo')
def get_foo_setting():
return 'FOO'
@beta.setting('one', 'bar')
def get_bar_setting():
return 'BAR'
dectate.commit(alpha, beta)
alpha_inst = alpha()
settings = alpha_inst.config.setting_registry
assert settings.one.foo == 'FOO'
with pytest.raises(AttributeError):
settings.one.bar
beta_inst = beta()
settings = beta_inst.config.setting_registry
assert settings.one.foo == 'FOO'
assert settings.one.bar == 'BAR'
def test_traject_consume_combination():
class app(morepath.App):
pass
dectate.commit(app)
traject = app.config.path_registry
def get_model(foo):
result = Model()
result.foo = foo
return result
traject.add_pattern('special', (Special, paramfac))
traject.add_pattern('{foo}', (get_model, paramfac))
mount = app()
found, request = consume(mount, 'something')
assert isinstance(found, Model)
assert request.unconsumed == []
assert found.foo == 'something'
found, request = consume(mount, 'special')
assert isinstance(found, Special)
assert request.unconsumed == []
def test_traject_consume_parameter():
class app(morepath.App):
pass
dectate.commit(app)
traject = app.config.path_registry
class Model(object):
def __init__(self, a):
self.a = a
get_param = ParameterFactory({'a': 0}, {'a': Converter(int)}, [])
traject.add_pattern('sub', (Model, get_param))
mount = app()
found, request = consume(mount, 'sub?a=1')
assert isinstance(found, Model)
assert found.a == 1
assert request.unconsumed == []
found, request = consume(mount, 'sub')
assert isinstance(found, Model)
assert found.a == 0
assert request.unconsumed == []
def test_filter_class():
class MyApp(App):
pass
@MyApp.directive('view')
class ViewAction(Action):
config = {
'registry': list
}
filter_compare = {
'model': issubclass
}
def __init__(self, model):
self.model = model
def identifier(self, registry):
return self.model
def perform(self, obj, registry):
registry.append((self.model, obj))
class Alpha(object):
pass
class Beta(object):
pass
class Gamma(Beta):
pass
class Delta(Gamma):
pass
@MyApp.view(model=Alpha)
def f():
pass
@MyApp.view(model=Beta)
def g():
pass
@MyApp.view(model=Gamma)
def h():
pass
@MyApp.view(model=Delta)
def i():
pass
commit(MyApp)
assert list(Query(ViewAction).filter(model=Alpha).obj()(MyApp)) == [f]
assert list(Query(ViewAction).filter(model=Beta).obj()(MyApp)) == [g, h, i]
assert list(Query(ViewAction).filter(model=Gamma).obj()(MyApp)) == [h, i]
assert list(Query(ViewAction).filter(model=Delta).obj()(MyApp)) == [i]
def test_filter_not_found():
class MyApp(App):
pass
@MyApp.directive('foo')
class FooAction(Action):
config = {
'registry': list
}
def __init__(self, name):
self.name = name
def identifier(self, registry):
return self.name
def perform(self, obj, registry):
registry.append((self.name, obj))
@MyApp.foo('a')
def f():
pass
@MyApp.foo('b')
def g():
pass
commit(MyApp)
q = Query(FooAction).filter(unknown='a').attrs('name')
assert list(q(MyApp)) == []
def test_traject_nested_with_variable():
class app(morepath.App):
pass
dectate.commit(app)
traject = app.config.path_registry
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))
mount = app()
found, request = consume(mount, 'a')
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(mount, 'b')
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(mount, 'a/sub')
assert isinstance(found, Special)
assert request.unconsumed == []
def test_traject_with_multiple_variables():
class app(morepath.App):
pass
dectate.commit(app)
traject = app.config.path_registry
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))
mount = app()
found, request = consume(mount, 'a')
assert isinstance(found, Model)
assert found.first_id == 'a'
assert not hasattr(found, 'second_id')
assert request.unconsumed == []
found, request = consume(mount, 'a/b')
assert isinstance(found, Special)
assert found.first_id == 'a'
assert found.second_id == 'b'
assert request.unconsumed == []
def test_converter():
class App(morepath.App):
pass
dectate.commit(App)
r = objects(dectate.query_app(App, 'converter'))
expected = [
core.int_converter,
core.unicode_converter
]
if not compat.PY3:
expected.append(core.str_converter)
expected.extend([
core.date_converter,
core.datetime_converter
])
assert r == expected
r = objects(dectate.query_app(App, 'converter', type=builtin_ref('int')))
assert r == [
core.int_converter
]
def test_predicate_fallback():
class App(morepath.App):
pass
dectate.commit(App)
r = objects(dectate.query_app(App, 'predicate_fallback'))
assert r == [
core.model_not_found,
core.name_not_found,
core.method_not_allowed
]
r = objects(dectate.query_app(App, 'predicate_fallback',
dispatch='morepath.App.get_view'))
assert r == [
core.model_not_found,
core.name_not_found,
core.method_not_allowed
]
# there aren't any predicates for class_path
r = objects(dectate.query_app(
App, 'predicate_fallback',
dispatch='morepath.App._class_path'))
assert r == []
r = objects(dectate.query_app(App, 'predicate_fallback',
func='morepath.core.model_predicate'))
assert r == [
core.model_not_found,
]
def test_settings_function():
morepath.enable_implicit()
class app(morepath.App):
pass
@app.setting('section', 'name')
def setting():
return 'LAH'
@app.path(path='')
class Model(object):
def __init__(self):
pass
@app.view(model=Model)
def default(self, request):
return request.app.settings.section.name
@app.view(model=Model, name='generic')
def generic(self, request):
with pytest.deprecated_call():
return morepath.settings().section.name
dectate.commit(app)
c = Client(app())
response = c.get('/')
assert response.body == b'LAH'
response = c.get('/generic')
assert response.body == b'LAH'
def test_query():
class FooAction(Action):
config = {
'registry': list
}
def __init__(self, name):
self.name = name
def identifier(self, registry):
return self.name
def perform(self, obj, registry):
registry.append((self.name, obj))
class MyApp(App):
foo = directive(FooAction)
@MyApp.foo('a')
def f():
pass
@MyApp.foo('b')
def g():
pass
commit(MyApp)
q = Query(FooAction).attrs('name')
assert list(q(MyApp)) == [
{'name': 'a'},
{'name': 'b'}
]
def test_internal():
class app(morepath.App):
pass
@app.path(path='')
class Root(object):
pass
@app.json(model=Root)
def root_default(self, request):
return {'internal': request.view(self, name='internal')}
@app.json(model=Root, name='internal', internal=True)
def root_internal(self, request):
return 'Internal!'
dectate.commit(app)
c = Client(app())
response = c.get('/')
assert response.body == b'{"internal": "Internal!"}'
c.get('/internal', status=404)
def test_filter_get_value_and_default():
class FooAction(Action):
def filter_get_value(self, name):
return self.kw.get(name, NOT_FOUND)
def __init__(self, name, **kw):
self.name = name
self.kw = kw
def identifier(self):
return tuple(sorted(self.kw.items()))
def perform(self, obj):
pass
class MyApp(App):
foo = directive(FooAction)
@MyApp.foo(name='hello', x='a', y='b')
def f():
pass
@MyApp.foo(name='bye', x='a', y='c')
def g():
pass
commit(MyApp)
q = Query(FooAction).filter(name='hello').attrs('name', 'x', 'y')
assert list(q(MyApp)) == [{'x': 'a', 'y': 'b', 'name': 'hello'}]
def test_traject_path_with_leading_slash():
class App(morepath.App):
pass
root = Root()
def get_model(id):
model = Model()
model.id = id
return model
dectate.commit(App)
path_registry = App.config.path_registry
path_registry.register_path(
Root, '', lambda m: {}, None, None, None, False,
lambda: root)
path_registry.register_path(
Model, '/foo/{id}', lambda model: {'id': model.id},
None, None, None, False, get_model)
mount = App()
obj, request = consume(mount, 'foo/a')
assert obj.id == 'a'
obj, request = consume(mount, '/foo/a')
assert obj.id == 'a'
def test_register_path():
class App(morepath.App):
pass
root = Root()
def get_model(id):
model = Model()
model.id = id
return model
dectate.commit(App)
path_registry = App.config.path_registry
path_registry.register_path(
Root, '', lambda m: {},
None, None, None, False,
lambda: root)
path_registry.register_path(
Model, '{id}', lambda model: {'id': model.id},
None, None, None, False, get_model)
app = App()
obj, request = consume(app, 'a')
assert obj.id == 'a'
model = Model()
model.id = 'b'
info = app._get_path(model)
assert info.path == 'b'
assert info.parameters == {}
def test_simple_config_logging():
log = logging.getLogger('morepath.directive.path')
test_handler = Handler()
log.addHandler(test_handler)
log.setLevel(logging.DEBUG)
class App(morepath.App):
pass
@App.path(path='')
class Model(object):
pass
dectate.commit(App)
messages = [r.getMessage() for r in test_handler.records]
assert len(messages) == 1
if PY3:
expected = (
"@morepath.tests.test_config_logging.App.path(path='') on "
"<class 'morepath.tests.test_config_logging."
"test_simple_config_logging.<locals>.Model'>")
else:
expected = (
"@morepath.tests.test_config_logging.App.path(path='') on "
"<class 'morepath.tests.test_config_logging.Model'>")
assert messages[0] == expected
def test_app_section_settings_conflict():
class app(morepath.App):
pass
@app.setting_section('one')
def settings():
return {'foo': "FOO", 'bar': "BAR"}
@app.setting('one', 'foo')
def get_foo():
return 'another'
with pytest.raises(ConflictError):
dectate.commit(app)
def test_view():
class app(App):
pass
dectate.commit(app)
def view(self, request):
return "View!"
app.config.view_registry.register_view(dict(model=Model), view)
model = Model()
result = resolve_response(model, app().request(get_environ(path='')))
assert result.body == b'View!'
def test_app_section_settings_conflict():
class app(morepath.App):
pass
@app.setting_section("one")
def settings():
return {"foo": "FOO", "bar": "BAR"}
@app.setting("one", "foo")
def get_foo():
return "another"
with pytest.raises(ConflictError):
dectate.commit(app)
def test_response_returned():
class app(morepath.App):
pass
dectate.commit(app)
def view(self, request):
return Response('Hello world!')
app.config.view_registry.register_view(dict(model=Model), view)
model = Model()
response = resolve_response(model, app().request(get_environ(path='')))
assert response.body == b'Hello world!'
def test_traject_consume():
class app(morepath.App):
pass
dectate.commit(app)
traject = app.config.path_registry
traject.add_pattern('sub', (Model, paramfac))
mount = app()
found, request = consume(mount, 'sub')
assert isinstance(found, Model)
assert request.unconsumed == []
def test_root_conflict2():
class app(morepath.App):
pass
@app.path(path='')
class Root(object):
pass
@app.path(path='/')
class Something(object):
pass
with pytest.raises(ConflictError):
dectate.commit(app)
def test_filter_multiple_fields():
class FooAction(Action):
config = {'registry': list}
filter_compare = {'model': issubclass}
def __init__(self, model, name):
self.model = model
self.name = name
def identifier(self, registry):
return (self.model, self.name)
def perform(self, obj, registry):
registry.append((self.model, self.name, obj))
class MyApp(App):
foo = directive(FooAction)
class Alpha(object):
pass
class Beta(object):
pass
@MyApp.foo(model=Alpha, name='a')
def f():
pass
@MyApp.foo(model=Alpha, name='b')
def g():
pass
@MyApp.foo(model=Beta, name='a')
def h():
pass
@MyApp.foo(model=Beta, name='b')
def i():
pass
commit(MyApp)
q = Query(FooAction)
assert list(q.filter(model=Alpha, name='a').obj()(MyApp)) == [f]
assert list(q.filter(model=Alpha, name='b').obj()(MyApp)) == [g]
assert list(q.filter(model=Beta, name='a').obj()(MyApp)) == [h]
assert list(q.filter(model=Beta, name='b').obj()(MyApp)) == [i]
def test_permission_directive_identity():
class app(morepath.App):
pass
class Model(object):
def __init__(self, id):
self.id = id
class Permission(object):
pass
@app.verify_identity()
def verify_identity(identity):
return True
@app.path(model=Model, path='{id}',
variables=lambda model: {'id': model.id})
def get_model(id):
return Model(id)
@app.permission_rule(model=Model, permission=Permission)
def get_permission(identity, model, permission):
if model.id == 'foo':
return True
else:
return False
@app.view(model=Model, permission=Permission)
def default(self, request):
return "Model: %s" % self.id
@app.identity_policy()
class IdentityPolicy(object):
def identify(self, request):
return Identity('testidentity')
def remember(self, response, request, identity):
pass
def forget(self, response, request):
pass
dectate.commit(app)
c = Client(app())
response = c.get('/foo')
assert response.body == b'Model: foo'
response = c.get('/bar', status=403)
def test_json_body_model():
class app(morepath.App):
pass
class Collection(object):
def __init__(self):
self.items = []
def add(self, item):
self.items.append(item)
class Item1(object):
def __init__(self, value):
self.value = value
class Item2(object):
def __init__(self, value):
self.value = value
collection = Collection()
@app.path(path='/', model=Collection)
def get_collection():
return collection
@app.json(model=Collection, request_method='POST', body_model=Item1)
def default(self, request):
self.add(request.body_obj)
return 'done'
@app.load_json()
def load_json(json, request):
if json['@type'] == 'Item1':
return Item1(json['x'])
elif json['@type'] == 'Item2':
return Item2(json['x'])
dectate.commit(app)
c = Client(app())
c.post_json('/', {'@type': 'Item1', 'x': 'foo'})
assert len(collection.items) == 1
assert isinstance(collection.items[0], Item1)
assert collection.items[0].value == 'foo'
c.post_json('/', {'@type': 'Item2', 'x': 'foo'}, status=422)
def test_view_no_conflict_different_predicates():
class app(morepath.App):
pass
class Model(object):
pass
@app.view(model=Model, name='a', request_method='GET')
def a_view(self, request):
pass
@app.view(model=Model, name='a', request_method='POST')
def b_view(self, request):
pass
dectate.commit(app)
def first_default_registrations(articles_kb_app):
# Omit the "order" to disambiguate
@articles_kb_app.toctree()
def toctree1(*args):
return
@articles_kb_app.toctree(system_order=50)
def toctree2(*args):
return
@articles_kb_app.toctree(system_order=40)
def toctree3(*args):
return
dectate.commit(articles_kb_app)
yield (toctree1, toctree2, toctree3)
def test_view_no_conflict_different_names():
class app(morepath.App):
pass
class Model(object):
pass
@app.view(model=Model, name='a')
def a_view(self, request):
pass
@app.view(model=Model, name='b')
def b_view(self, request):
pass
dectate.commit(app)
def test_app_section_settings():
class app(morepath.App):
pass
@app.setting_section('one')
def settings():
return {'foo': "FOO", 'bar': "BAR"}
dectate.commit(app)
app_inst = app()
s = app_inst.config.setting_registry
assert s.one.foo == 'FOO'
assert s.one.bar == 'BAR'
def test_notfound_with_predicates():
class app(morepath.App):
pass
dectate.commit(app)
def view(self, request):
return "view"
app.get_view.register(View(view), model=Model)
model = Model()
request = app().request(get_environ(''))
request.unconsumed = ['foo']
with pytest.raises(HTTPNotFound):
resolve_response(model, request)
def test_render_html():
class app(App):
pass
dectate.commit(app)
def view(self, request):
return '<p>Hello world!</p>'
app.get_view.register(View(view, render=render_html), model=Model)
request = app().request(get_environ(path=''))
model = Model()
response = resolve_response(model, request)
assert response.body == b'<p>Hello world!</p>'
assert response.content_type == 'text/html'
def test_app_section_settings():
class app(morepath.App):
pass
@app.setting_section("one")
def settings():
return {"foo": "FOO", "bar": "BAR"}
dectate.commit(app)
app_inst = app()
s = app_inst.config.setting_registry
assert s.one.foo == "FOO"
assert s.one.bar == "BAR"
def test_root_no_conflict_different_apps():
class app_a(morepath.App):
pass
class app_b(morepath.App):
pass
@app_a.path(path='')
class Root(object):
pass
@app_b.path(path='')
class Something(object):
pass
dectate.commit(app_a, app_b)
def test_predicate():
class App(morepath.App):
pass
dectate.commit(App)
r = objects(dectate.query_app(App, 'predicate'))
assert r == [
core.model_predicate,
core.name_predicate,
core.request_method_predicate,
core.body_model_predicate
]
r = objects(dectate.query_app(App, 'predicate',
dispatch='morepath.App.get_view'))
assert r == [
core.model_predicate,
core.name_predicate,
core.request_method_predicate,
core.body_model_predicate
]
# there aren't any predicates for class_path
r = objects(dectate.query_app(
App, 'predicate',
dispatch='morepath.App._class_path'))
assert r == []
r = objects(dectate.query_app(App, 'predicate',
name='name'))
assert r == [
core.name_predicate,
]
r = objects(dectate.query_app(App, 'predicate',
index='reg.ClassIndex'))
assert r == [
core.model_predicate,
core.body_model_predicate
]
r = objects(dectate.query_app(App, 'predicate',
after='morepath.core.model_predicate'))
assert r == [
core.name_predicate
]
def test_converter():
class App(morepath.App):
pass
dectate.commit(App)
r = objects(dectate.query_app(App, "converter"))
expected = [core.int_converter, core.unicode_converter]
expected.extend([core.date_converter, core.datetime_converter])
assert r == expected
r = objects(dectate.query_app(App, "converter", type="builtins.int"))
assert r == [core.int_converter]
def test_view_conflict_with_html():
class app(morepath.App):
pass
class Model(object):
pass
@app.view(model=Model, name='a')
def a_view(self, request):
pass
@app.html(model=Model, name='a')
def a1_view(self, request):
pass
with pytest.raises(ConflictError):
dectate.commit(app)
def test_url_parameter_list_unknown_explicit_converter():
class app(morepath.App):
pass
class Model(object):
def __init__(self, item):
self.item = item
class Unknown(object):
pass
@app.path(model=Model, path='/', converters={'item': [Unknown]})
def get_model(item):
return Model(item)
with pytest.raises(DirectiveReportError):
dectate.commit(app)
def test_http_exception_excview():
class app(morepath.App):
pass
@app.path(path='')
class Root(object):
pass
@app.view(model=HTTPNotFound)
def notfound_default(self, request):
return "Not found!"
dectate.commit(app)
c = Client(app())
response = c.get('/')
assert response.body == b'Not found!'
def test_model_conflict():
class app(morepath.App):
pass
class A(object):
pass
@app.path(model=A, path='a')
def get_a():
return A()
@app.path(model=A, path='a')
def get_a_again():
return A()
with pytest.raises(ConflictError):
dectate.commit(app)
def test_traject_consume_factory_returns_none():
class app(morepath.App):
pass
dectate.commit(app)
traject = app.config.path_registry
def get_model():
return None
traject.add_pattern('sub', (get_model, paramfac))
found, request = consume(app(), 'sub')
assert found is None
assert request.unconsumed == ['sub']
def test_multi_action_query():
class FooAction(Action):
config = {'registry': list}
def __init__(self, name):
self.name = name
def identifier(self, registry):
return self.name
def perform(self, obj, registry):
registry.append((self.name, obj))
class BarAction(Action):
config = {'registry': list}
def __init__(self, name):
self.name = name
def identifier(self, registry):
return self.name
def perform(self, obj, registry):
registry.append((self.name, obj))
class MyApp(App):
foo = directive(FooAction)
bar = directive(BarAction)
@MyApp.foo('a')
def f():
pass
@MyApp.bar('b')
def g():
pass
commit(MyApp)
q = Query(FooAction, BarAction).attrs('name')
assert sorted(list(q(MyApp)), key=lambda d: d['name']) == [{
'name': 'a'
}, {
'name': 'b'
}]
def test_traject_nested_not_resolved_entirely_by_consumer():
class app(morepath.App):
pass
dectate.commit(app)
traject = app.config.path_registry
traject.add_pattern('a', (Model, paramfac))
mount = app()
found, request = consume(mount, 'a')
assert isinstance(found, Model)
assert request.unconsumed == []
found, request = consume(mount, 'a/b')
assert isinstance(found, Model)
assert request.unconsumed == ['b']
def test_defer_link_should_not_cause_web_views_to_exist():
class root(morepath.App):
pass
class sub(morepath.App):
pass
@root.path(path='')
class Model(object):
pass
@root.view(model=Model)
def model_default(self, request):
return "Hello"
@root.view(model=Model, name='extra')
def model_extra(self, request):
return "Extra"
# note inheritance from model. we still don't
# want the extra view to show up on the web
@sub.path(path='')
class SubModel(Model):
pass
@sub.view(model=SubModel)
def sub_model_default(self, request):
return request.link(Model())
@root.mount(app=sub, path='sub')
def mount_sub():
return sub()
@sub.defer_links(model=Model)
def get_parent(app, obj):
return app.parent
dectate.commit(root, sub)
c = Client(root())
response = c.get('/sub')
assert response.body == b'http://localhost/'
c.get('/sub/+extra', status=404)
def test_view_permission():
class App(morepath.App):
pass
@App.view(model=Foo, name='n')
def foo_n(self, request):
pass
@App.view(model=Foo, name='b', permission=BasePermission)
def foo_b(self, request):
pass
@App.view(model=Foo, name='p', permission=Permission)
def foo_p(self, request):
pass
@App.view(model=Foo, name='s', permission=SubPermission)
def foo_s(self, request):
pass
dectate.commit(App)
r = objects(dectate.query_app(
App, 'view',
permission='morepath.tests.test_querytool.BasePermission'))
assert r == [foo_b, foo_p, foo_s]
r = objects(dectate.query_app(
App, 'view',
permission='morepath.tests.test_querytool.Permission'))
assert r == [foo_p, foo_s]
r = objects(dectate.query_app(
App, 'view',
permission='morepath.tests.test_querytool.SubPermission'))
assert r == [foo_s]
r = objects(dectate.query_app(App, 'view',
model='morepath.tests.test_querytool.Foo',
permission=builtin_ref('None')))
assert r == [foo_n]
def test_request_view_in_mount():
class app(morepath.App):
pass
class mounted(morepath.App):
def __init__(self, mount_id):
self.mount_id = mount_id
@app.path(path='')
class Root(object):
pass
@mounted.path(path='models/{id}')
class Model(object):
def __init__(self, id):
self.id = id
@mounted.view(model=Model)
def model_default(self, request):
return {'hey': 'Hey'}
@app.view(model=Root)
def root_default(self, request):
child = request.app.child(mounted, id='foo')
return request.view(Model('x'), app=child)['hey']
@app.view(model=Root, name='inst')
def root_inst(self, request):
child = request.app.child(mounted(mount_id='foo'))
return request.view(Model('x'), app=child)['hey']
@app.mount(path='{id}', app=mounted,
variables=lambda a: dict(id=a.mount_id))
def get_context(id):
return mounted(mount_id=id)
dectate.commit(app, mounted)
c = Client(app())
response = c.get('/')
assert response.body == b'Hey'
response = c.get('/+inst')
assert response.body == b'Hey'
def test_named_mount_with_parameters():
class app(morepath.App):
pass
class mounted(morepath.App):
def __init__(self, mount_id):
self.mount_id = mount_id
@app.path(path='')
class Root(object):
pass
@mounted.path(path='')
class MountedRoot(object):
def __init__(self, mount_id):
assert isinstance(mount_id, int)
self.mount_id = mount_id
@mounted.view(model=MountedRoot)
def root_default(self, request):
return "The root for mount id: %s" % self.mount_id
@app.mount(path='mounts/{mount_id}', app=mounted)
def get_context(mount_id=0):
return mounted(mount_id=mount_id)
class Item(object):
def __init__(self, id):
self.id = id
@mounted.path(path='items/{id}', model=Item)
def get_item(id):
return Item(id)
@app.view(model=Root)
def root_default2(self, request):
child = request.app.child('mounts/{mount_id}', mount_id=3)
return request.link(Item(4), app=child)
dectate.commit(app, mounted)
c = Client(app())
response = c.get('/')
assert response.body == b'http://localhost/mounts/3/items/4'
