def test_callback_inspection(self):
def x(a, b):
pass
def d(f):
def w():
return f()
return w
route = bottle.Route(bottle.Bottle(), None, None, d(x))
self.assertEqual(route.get_undecorated_callback(), x)
self.assertEqual(set(route.get_callback_args()), set(['a', 'b']))
def d2(foo):
def d(f):
def w():
return f()
return w
return d
route = bottle.Route(bottle.Bottle(), None, None, d2('foo')(x))
self.assertEqual(route.get_undecorated_callback(), x)
self.assertEqual(set(route.get_callback_args()), set(['a', 'b']))
def test_expired_session(self):
"""Test that the session is invalid when it's expired."""
self.mock_database.sessions.find_one.return_value = dict(
session_expiration_datetime=datetime.min.replace(
tzinfo=timezone.utc))
route = bottle.Route(bottle.app(), "/", "POST", self.route)
self.assertRaises(bottle.HTTPError, route.call)
def test_valid_session(self):
"""Test that session ids are authenticated."""
self.mock_database.sessions.find_one.return_value = dict(
session_expiration_datetime=datetime.max.replace(
tzinfo=timezone.utc))
route = bottle.Route(bottle.app(), "/", "POST", self.route)
self.assertEqual(self.success, route.call())
def test_callback_inspection_multiple_args(self):
# decorator with argument, modifying kwargs
def d2(f="1"):
def d(fn):
def w(*args, **kwargs):
# modification of kwargs WITH the decorator argument
# is necessary requirement for the error
kwargs["a"] = f
return fn(*args, **kwargs)
return w
return d
@d2(f='foo')
def x(a, b):
return
route = bottle.Route(bottle.Bottle(), None, None, x)
# triggers the "TypeError: 'foo' is not a Python function"
self.assertEqual(set(route.get_callback_args()), set(['a', 'b']))
def test_callback_inspection_newsig(self):
env = {}
eval(compile('def foo(a, *, b=5): pass', '<foo>', 'exec'), env,
env)
route = bottle.Route(bottle.Bottle(), None, None, env['foo'])
self.assertEqual(set(route.get_callback_args()), set(['a', 'b']))
def test_apply_plugin_to_route_that_does_not_take_keyword(self):
"""Test that the plugin can be applied to a route."""
def route():
return "route"
bottle.install(InjectionPlugin("value", "keyword"))
route = bottle.Route(bottle.app(), "/", "GET", route)
self.assertEqual("route", route.call())
def test_apply_plugin(self):
"""Test that the plugin can be applied to a route."""
def route(keyword):
return keyword
bottle.install(InjectionPlugin("value", "keyword"))
route = bottle.Route(bottle.app(), "/", "GET", route)
self.assertEqual("value", route.call())
def test_apply_to_get_route(self):
"""Test that session ids are not authenticated with non-post routes."""
database_mock = Mock()
database_mock.sessions.find_one.return_value = None
bottle.install(InjectionPlugin(database_mock, "database"))
bottle.install(AuthenticationPlugin())
route = bottle.Route(bottle.app(), "/", "GET", self.route)
self.assertEqual("route called", route.call())
def test_apply_invalid_session(self):
"""Test that session ids are authenticated."""
database_mock = Mock()
database_mock.sessions.find_one.return_value = None
bottle.install(InjectionPlugin(database_mock, "database"))
bottle.install(AuthenticationPlugin())
route = bottle.Route(bottle.app(), "/", "POST", self.route)
with patch("logging.warning", Mock()): # Suppress logging
self.assertEqual(dict(ok=False), route.call())
def __register(self, app, method):
rule = method.__route__
elle.log.debug('%s: register route %s' % (app, rule))
# Introspect method.
if hasattr(method.__underlying_method__, '__fullargspec__'):
spec = method.__underlying_method__.__fullargspec__
else:
spec = inspect.getfullargspec(method.__underlying_method__)
del spec.args[0] # remove self
import itertools
defaults = spec.defaults or []
spec_args = dict(
(name, default) for name, default in itertools.zip_longest(
reversed(spec.args), reversed([True] * len(defaults))))
for arg in re.findall('<(\\w*)(?::\\w*(?::[^>]*)?)?>', rule):
if arg in spec_args:
del spec_args[arg]
elif spec.varkw is None:
raise AssertionError(
'Rule %r yields %r but %r does not accept it' %
(rule, arg, method))
# Callback.
def callback(*args, **kwargs):
arguments = dict(spec_args)
def explode(d):
if d is None:
return
for key in dict(arguments):
if key in d:
kwargs[key] = d[key]
del d[key]
del arguments[key]
if len(d) > 0:
if spec.varkw is not None:
kwargs.update(d)
else:
key = iter(d.keys()).__next__()
app.bad_request('unexpected JSON keys: %r' % key)
try:
explode(bottle.request.json)
except ValueError:
app.bad_request('invalid JSON')
explode(bottle.request.query)
for argument, default in arguments.items():
if not default:
app.bad_request('missing argument: %r' % argument)
return method(app, *args, **kwargs)
# Add route.
route = bottle.Route(app=app,
rule=rule,
method=method.__method__,
callback=callback)
app.add_route(route)
def test_unauthorized_sessions(self):
"""Test that an unauthorized session is invalid."""
self.mock_database.reports_overviews.find_one.return_value = dict(
_id="id", editors=["jodoe"])
self.mock_database.sessions.find_one.return_value = dict(
user="******",
email="*****@*****.**",
session_expiration_datetime=datetime.max)
route = bottle.Route(bottle.app(), "/", "POST", self.route)
self.assertRaises(bottle.HTTPError, route.call)
def test_callback_inspection_multiple_args(self):
# decorator with argument, modifying kwargs
def d2(f="1"):
def d(fn):
def w(*args, **kwargs):
# modification of kwargs WITH the decorator argument
# is necessary requirement for the error
kwargs["a"] = f
return fn(*args, **kwargs)
return w
return d
@d2(f='foo')
def x(a, b):
return
route = bottle.Route(None, None, None, x)
# triggers the "TypeError: 'foo' is not a Python function"
self.assertEqual(set(route.get_callback_args()), set(['a', 'b']))
def test_callback_inspection_newsig(self):
env = {}
eval(compile('def foo(a, *, b=5): pass', '<foo>', 'exec'), env, env)
route = bottle.Route(None, None, None, env['foo'])
self.assertEqual(set(route.get_callback_args()), set(['a', 'b']))
def test_http_get_routes(self):
"""Test that session ids are not authenticated with non-post routes."""
self.mock_database.sessions.find_one.return_value = None
route = bottle.Route(bottle.app(), "/", "GET", self.route)
self.assertEqual(self.success, route.call())
def test_missing_session(self):
"""Test that the session is invalid when it's missing."""
self.mock_database.sessions.find_one.return_value = None
route = bottle.Route(bottle.app(), "/", "POST", self.route)
self.assertRaises(bottle.HTTPError, route.call)
def test_apply_valid_session(self):
"""Test that session ids are authenticated."""
bottle.install(InjectionPlugin(Mock(), "database"))
bottle.install(AuthenticationPlugin())
route = bottle.Route(bottle.app(), "/", "POST", self.route)
self.assertEqual("route called", route.call())
