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_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_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_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_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_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_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_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_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_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, 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_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.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_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_traject_consume_factory_returns_none():
app = App()
traject = Traject()
def get_model():
return None
traject.add_pattern('sub', get_model)
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, 'sub')
assert found is None
assert request.unconsumed == ['sub']
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_traject_consume_factory_returns_none():
app = App()
traject = Traject()
def get_model():
return None
traject.add_pattern("sub", (get_model, paramfac))
app.register(generic.traject, [App], lambda base: traject)
app.register(generic.context, [object], lambda obj: {})
found, request = consume(app, "sub")
assert found is None
assert request.unconsumed == ["sub"]
def test_traject_consume_view():
app = App()
traject = Traject()
def get_model(foo):
result = Model()
result.foo = foo
return result
traject.add_pattern('', Root)
traject.add_pattern('{foo}', get_model)
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, '+something')
assert isinstance(found, Root)
assert request.unconsumed == ['+something']
def test_traject_consume_model_factory_gets_request():
app = App()
traject = Traject()
class Model(object):
def __init__(self, info):
self.info = info
def get_model(request):
return Model(request.method)
traject.add_pattern('sub', get_model)
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, 'sub')
assert isinstance(found, Model)
assert request.unconsumed == []
assert found.info == 'GET'
def test_traject_consume_view():
app = App()
traject = Traject()
def get_model(foo):
result = Model()
result.foo = foo
return result
traject.add_pattern("", (Root, paramfac))
traject.add_pattern("{foo}", (get_model, paramfac))
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, "+something")
assert isinstance(found, Root)
assert request.unconsumed == ["+something"]
def test_traject_consume_parameter():
app = App()
traject = Traject()
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))
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, 'sub?a=1')
assert isinstance(found, Model)
assert found.a == 1
assert request.unconsumed == []
found, request = consume(app, 'sub')
assert isinstance(found, Model)
assert found.a == 0
assert request.unconsumed == []
def test_traject_consume_variable():
app = App()
traject = Traject()
def get_model(foo):
result = Model()
result.foo = foo
return result
traject.add_pattern('{foo}', (get_model, paramfac))
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, 'something')
assert isinstance(found, Model)
assert found.foo == 'something'
assert request.unconsumed == []
def test_traject_consume_model_factory_gets_request():
app = App()
traject = Traject()
class Model(object):
def __init__(self, info):
self.info = info
def get_model(request):
return Model(request.method)
traject.add_pattern("sub", (get_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 == []
assert found.info == "GET"
def test_traject_consume_combination():
app = App()
traject = Traject()
def get_model(foo):
result = Model()
result.foo = foo
return result
traject.add_pattern('special', Special)
traject.add_pattern('{foo}', get_model)
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, 'something')
assert isinstance(found, Model)
assert request.unconsumed == []
assert found.foo == 'something'
found, request = consume(app, 'special')
assert isinstance(found, Special)
assert request.unconsumed == []
def test_traject_consume_combination():
app = App()
traject = Traject()
def get_model(foo):
result = Model()
result.foo = foo
return result
traject.add_pattern("special", (Special, paramfac))
traject.add_pattern("{foo}", (get_model, paramfac))
app.register(generic.traject, [App], lambda base: traject)
found, request = consume(app, "something")
assert isinstance(found, Model)
assert request.unconsumed == []
assert found.foo == "something"
found, request = consume(app, "special")
assert isinstance(found, Special)
assert request.unconsumed == []
def test_traject_path_with_leading_slash():
config = setup()
app = App(testing_config=config)
root = Root()
def get_model(id):
model = Model()
model.id = id
return model
config.commit()
register_path(app, Root, '', lambda m: {}, None, None, None,
lambda: root)
register_path(app, Model, '/foo/{id}', lambda model: {'id': model.id},
None, None, None, get_model)
app.register(generic.context, [object], lambda obj: {})
obj, request = consume(app, 'foo/a')
assert obj.id == 'a'
obj, request = consume(app, '/foo/a')
assert obj.id == 'a'
def test_register_path():
config = setup()
app = App(testing_config=config)
root = Root()
lookup = app.lookup
def get_model(id):
model = Model()
model.id = id
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},
None, None, None, get_model)
app.register(generic.context, [object], lambda obj: {})
obj, request = consume(app, 'a')
assert obj.id == 'a'
model = Model()
model.id = 'b'
assert generic.path(model, lookup=lookup) == ('b', {})
