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'