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_variable_specific_first():
traject = Traject()
traject.add_pattern('a/{x}/b', 'axb')
traject.add_pattern('a/prefix{x}/b', 'aprefixxb')
assert traject.consume(['b', 'lah', 'a']) == ('axb', [], {'x': 'lah'})
assert traject.consume(['b', 'prefixlah', 'a']) == (
'aprefixxb', [], {'x': 'lah'})
def test_traject_no_duplicate_variables():
traject = Traject()
with pytest.raises(TrajectError):
traject.add_pattern('{foo}-{foo}', 'value')
with pytest.raises(TrajectError):
traject.add_pattern('{foo}/{foo}', 'value')
def test_traject_consume_parameter():
class app(morepath.App):
pass
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))
registry = app.registry
registry.register(generic.traject, [App], lambda base: traject)
registry.register(generic.context, [object], lambda obj: {})
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_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_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 register_path(app, model, path, variables, converters, required,
model_factory, arguments=None):
traject = app.traject
if traject is None:
traject = Traject()
app.traject = traject
converters = converters or {}
if arguments is None:
arguments = get_arguments(model_factory, SPECIAL_ARGUMENTS)
converters = get_converters(arguments, converters,
app.converter_for_type, app.converter_for_value)
exclude = Path(path).variables()
exclude.update(app.mount_variables())
parameters = get_url_parameters(arguments, exclude)
if required is None:
required = set()
required = set(required)
parameter_factory = ParameterFactory(parameters, converters, required)
if variables is None:
variables = get_variables_func(arguments, app.mount_variables())
traject.add_pattern(path, (model_factory, parameter_factory),
converters)
traject.inverse(model, path, variables, converters, list(parameters.keys()))
def get_app(model):
return app
app.register(generic.app, [model], get_app)
def test_traject_with_converter_and_fallback3():
traject = Traject()
# XXX should have a conflict
traject.add_pattern('{x:str}', 'found_explicit')
traject.add_pattern('{x}', 'found_implicit')
assert traject(['foo']) == ('found_explicit', [], {'x': 'foo'})
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_with_multiple_variables():
class app(morepath.App):
pass
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))
registry = app.registry
registry.register(generic.traject, [App], lambda base: traject)
registry.register(generic.context, [object], lambda obj: {})
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_nested_with_variable():
class app(morepath.App):
pass
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))
registry = app.registry
registry.register(generic.traject, [App], lambda base: traject)
registry.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_consume_combination():
class app(morepath.App):
pass
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))
registry = app.registry
registry.register(generic.traject, [App], lambda base: traject)
registry.register(generic.context, [object], lambda obj: {})
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_with_converter_and_fallback2():
traject = Traject()
traject.add_pattern('{x}', 'found_str')
traject.add_pattern('{x:int}', 'found_int')
assert traject(['1']) == ('found_int', [], {'x': 1})
assert traject(['foo']) == ('found_str', [], {'x': 'foo'})
def test_traject_greedy_middle_converter():
traject = Traject()
traject.add_pattern('a/{x:int}/y', 'int')
traject.add_pattern('a/{x}/z', 'str')
assert traject(['y', '1', 'a']) == ('int', [], {'x': 1})
assert traject(['z', '1', 'a']) == (None, ['z'], {'x': 1})
assert traject(['z', 'x', 'a']) == ('str', [], {'x': 'x'})
def test_traject_greedy_middle_prefix():
traject = Traject()
traject.add_pattern('a/prefix{x}/y', 'prefix')
traject.add_pattern('a/{x}/z', 'no_prefix')
assert traject(['y', 'prefixX', 'a']) == ('prefix', [], {'x': 'X'})
assert traject(['z', 'prefixX', 'a']) == (None, ['z'], {'x': 'X'})
assert traject(['z', 'blah', 'a']) == ('no_prefix', [], {'x': 'blah'})
def test_traject_greedy_middle_prefix():
traject = Traject()
traject.add_pattern("a/prefix{x}/y", "prefix")
traject.add_pattern("a/{x}/z", "no_prefix")
assert traject.consume(["y", "prefixX", "a"]) == ("prefix", [], {"x": "X"})
assert traject.consume(["z", "prefixX", "a"]) == (None, ["z"], {"x": "X"})
assert traject.consume(["z", "blah", "a"]) == ("no_prefix", [], {"x": "blah"})
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_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_greedy_middle_converter_2():
traject = Traject()
traject.add_pattern('a/{x:int}/y', 'int')
traject.add_pattern('a/{x}', 'str')
assert traject(['y', '1', 'a']) == ('int', [], {'x': 1})
# this greedily goes into the int branch, and then doesn't find it
assert traject(['1', 'a']) == (None, [], {'x': 1})
# this works however for non-int
assert traject(['blah', 'a']) == ('str', [], {'x': 'blah'})
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():
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():
class app(morepath.App):
pass
traject = Traject()
traject.add_pattern('sub', (Model, paramfac))
registry = app.registry
registry.register(generic.traject, [App], lambda base: traject)
registry.register(generic.context, [object], lambda obj: {})
found, request = consume(app(), 'sub')
assert isinstance(found, Model)
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_simple():
traject = Traject()
traject.add_pattern('a/b/c', 'abc')
traject.add_pattern('a/b/d', 'abd')
traject.add_pattern('x/y', 'xy')
traject.add_pattern('x/z', 'xz')
assert traject(['c', 'b', 'a']) == ('abc', [], {})
assert traject(['d', 'b', 'a']) == ('abd', [], {})
assert traject(['y', 'x']) == ('xy', [], {})
assert traject(['z', 'x']) == ('xz', [], {})
assert traject(['d', 'c', 'b', 'a']) == ('abc', ['d'], {})
assert traject(['d', 'd', 'b', 'a']) == ('abd', ['d'], {})
assert traject(['3', '2', '1', 'y', 'x']) == ('xy', ['3', '2', '1'], {})
assert traject(['3', '2', '1']) == (None, ['3', '2', '1'], {})
assert traject(['b', 'a']) == (None, [], {})
def test_traject_simple():
traject = Traject()
traject.add_pattern("a/b/c", "abc")
traject.add_pattern("a/b/d", "abd")
traject.add_pattern("x/y", "xy")
traject.add_pattern("x/z", "xz")
assert traject.consume(["c", "b", "a"]) == ("abc", [], {})
assert traject.consume(["d", "b", "a"]) == ("abd", [], {})
assert traject.consume(["y", "x"]) == ("xy", [], {})
assert traject.consume(["z", "x"]) == ("xz", [], {})
assert traject.consume(["d", "c", "b", "a"]) == ("abc", ["d"], {})
assert traject.consume(["d", "d", "b", "a"]) == ("abd", ["d"], {})
assert traject.consume(["3", "2", "1", "y", "x"]) == ("xy", ["3", "2", "1"], {})
assert traject.consume(["3", "2", "1"]) == (None, ["3", "2", "1"], {})
assert traject.consume(["b", "a"]) == (None, [], {})
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_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)
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']
