def test_session_expiration():
permanent = True
app = Flak(__name__)
app.secret_key = 'testkey'
@app.route('/')
def index(cx):
cx.session['test'] = 42
cx.session.permanent = permanent
return ''
@app.route('/test')
def test(cx):
return text_type(cx.session.permanent)
client = app.test_client()
rv = client.get('/')
assert 'set-cookie' in rv.headers
match = re.search(r'\bexpires=([^;]+)(?i)', rv.headers['set-cookie'])
expires = parse_date(match.group())
expected = datetime.utcnow() + app.permanent_session_lifetime
assert expires.year == expected.year
assert expires.month == expected.month
assert expires.day == expected.day
rv = client.get('/test')
assert rv.data == b'True'
permanent = False
rv = app.test_client().get('/')
assert 'set-cookie' in rv.headers
match = re.search(r'\bexpires=([^;]+)', rv.headers['set-cookie'])
assert match is None
def test_multi_route_rules():
app = Flak(__name__)
@app.route('/')
@app.route('/<test>/')
def index(cx, test='a'):
return test
rv = app.test_client().open('/')
assert rv.data == b'a'
rv = app.test_client().open('/b/')
assert rv.data == b'b'
def test_none_response():
app = Flak(__name__)
@app.route('/')
def test(cx):
return None
try:
app.test_client().get('/')
except ValueError as e:
assert str(e) == 'View function did not return a response'
pass
else:
assert "Expected ValueError"
def test_preserve_remembers_exception():
app = Flak(__name__)
app.debug = True
errors = []
@app.route('/fail')
def fail_func(cx):
1 // 0
@app.route('/success')
def success_func(cx):
return 'Okay'
@app.teardown
def teardown_handler(cx, exc):
errors.append(exc)
c = app.test_client()
# After this failure we did not yet call the teardown handler
with pytest.raises(ZeroDivisionError):
c.get('/fail')
#assert errors == []
assert len(errors) == 1
# But this request triggers it, and it's an error
c.get('/success')
assert len(errors) == 2
# At this point another request does nothing.
c.get('/success')
assert len(errors) == 3
assert errors[1] is None
def test_route_decorator_custom_endpoint():
app = Flak(__name__)
app.debug = True
@app.route('/foo/')
def foo(cx):
return cx.request.endpoint
@app.route('/bar/', endpoint='bar')
def for_bar(cx):
return cx.request.endpoint
@app.route('/bar/123', endpoint='123')
def for_bar_foo(cx):
return cx.request.endpoint
with app.test_context() as cx:
assert cx.url_for('foo') == '/foo/'
assert cx.url_for('bar') == '/bar/'
assert cx.url_for('123') == '/bar/123'
c = app.test_client()
assert c.get('/foo/').data == b'foo'
assert c.get('/bar/').data == b'bar'
assert c.get('/bar/123').data == b'123'
def test_multi_route_class_views():
class View(object):
def __init__(self, app):
app.add_url_rule('/', self.index)
app.add_url_rule('/<test>/', self.index)
def index(self, cx, test='a'):
return test
app = Flak(__name__)
View(app)
rv = app.test_client().get('/')
assert rv.data == b'a'
rv = app.test_client().get('/b/')
assert rv.data == b'b'
def test_error_handler_no_match():
app = Flak(__name__)
class CustomException(Exception):
pass
@app.errorhandler(CustomException)
def custom_exception_handler(cx, e):
assert isinstance(e, CustomException)
return 'custom'
@app.errorhandler(500)
def handle_500(cx, e):
return type(e).__name__
@app.route('/custom')
def custom_test(cx):
raise CustomException()
@app.route('/keyerror')
def key_error(cx):
raise KeyError()
c = app.test_client()
assert c.get('/custom').data == b'custom'
assert c.get('/keyerror').data == b'KeyError'
def test_session_special_types():
app = Flak(__name__)
app.secret_key = 'development-key'
now = datetime.utcnow().replace(microsecond=0)
the_uuid = uuid.uuid4()
@app.after_request
def modify_session(cx, response):
cx.session['u'] = the_uuid
cx.session['dt'] = now
cx.session['b'] = b'\xff'
cx.session['t'] = (1, 2, 3)
return response
@app.route('/')
def dump_session_contents(cx):
return pickle.dumps(dict(cx.session))
c = app.test_client()
c.get('/')
rv = pickle.loads(c.get('/').data)
assert rv['dt'] == now
assert rv['u'] == the_uuid
assert rv['b'] == b'\xff'
assert type(rv['b']) == bytes
assert rv['t'] == (1, 2, 3)
def test_json_customization(self):
class X(object):
def __init__(self, val):
self.val = val
class MyEncoder(flak.json.JSONEncoder):
def default(self, o):
if isinstance(o, X):
return "<%d>" % o.val
return flak.json.JSONEncoder.default(self, o)
class MyDecoder(flak.json.JSONDecoder):
def __init__(self, *args, **kwargs):
kwargs.setdefault("object_hook", self.object_hook)
flak.json.JSONDecoder.__init__(self, *args, **kwargs)
def object_hook(self, obj):
if len(obj) == 1 and "_foo" in obj:
return X(obj["_foo"])
return obj
app = Flak(__name__)
app.json_encoder = MyEncoder
app.json_decoder = MyDecoder
@app.route("/", methods=["POST"])
def index(cx):
return cx.dumps(cx.get_json()["x"])
c = app.test_client()
rv = c.post("/", data=json.dumps({"x": {"_foo": 42}}), content_type="application/json")
assert rv.data == b'"<42>"'
def test_url_processors():
app = Flak(__name__)
@app.url_defaults
def add_language_code(cx, endpoint, values):
if cx.lang_code is not None and \
app.url_map.is_endpoint_expecting(endpoint, 'lang_code'):
values.setdefault('lang_code', cx.lang_code)
@app.url_value_preprocessor
def pull_lang_code(cx, endpoint, values):
cx.lang_code = values.pop('lang_code', None)
@app.route('/<lang_code>/')
def index(cx):
return cx.url_for('about')
@app.route('/<lang_code>/about')
def about(cx):
return cx.url_for('something_else')
@app.route('/foo')
def something_else(cx):
return cx.url_for('about', lang_code='en')
c = app.test_client()
assert c.get('/de/').data == b'/de/about'
assert c.get('/de/about').data == b'/foo'
assert c.get('/foo').data == b'/en/about'
def test_processor_exceptions(self):
app = Flak(__name__)
app.config["LOGGER_HANDLER_POLICY"] = "never"
@app.before_request
def before_request():
if trigger == "before":
1 // 0
@app.after_request
def after_request(response):
if trigger == "after":
1 // 0
return response
@app.route("/")
def index():
return "Foo"
@app.errorhandler(500)
def internal_server_error(cx, e):
return "Hello Server Error", 500
for trigger in "before", "after":
rv = app.test_client().get("/")
assert rv.status_code == 500
assert rv.data == b"Hello Server Error"
def test_reuse_client():
app = Flak(__name__)
c = app.test_client()
with c:
assert c.get('/').status_code == 404
with c:
assert c.get('/').status_code == 404
def test_test_client_context_binding():
app = Flak(__name__)
app.config['LOGGER_HANDLER_POLICY'] = 'never'
@app.route('/')
def index(cx):
cx.globals.value = 42
return 'Hello World!'
@app.route('/other')
def other(cx):
cx.globals.value = 23
1 // 0
with app.test_client() as c:
resp = c.get('/')
cx = c.captured_context
assert cx.globals.value == 42
assert resp.data == b'Hello World!'
assert resp.status_code == 200
resp = c.get('/other')
assert b'Internal Server Error' in resp.data
assert resp.status_code == 500
assert c.captured_context is not cx
cx = c.captured_context
assert cx.globals.value == 23
def test_redirect_keep_session():
app = Flak(__name__)
app.secret_key = 'testing'
@app.route('/', methods=['GET', 'POST'])
def index(cx):
if cx.request.method == 'POST':
return flak.redirect('/getsession')
cx.session['data'] = 'foo'
return 'index'
@app.route('/getsession')
def get_session(cx):
return cx.session.get('data', '<missing>')
with app.test_client() as c:
rv = c.get('/getsession')
assert rv.data == b'<missing>'
rv = c.get('/')
assert rv.data == b'index'
rv = c.post('/', data={}, follow_redirects=True)
assert rv.data == b'foo'
rv = c.get('/getsession')
assert rv.data == b'foo'
def test_http_error_subclass_handling():
class ForbiddenSubclass(Forbidden):
pass
app = Flak(__name__)
@app.errorhandler(ForbiddenSubclass)
def handle_forbidden_subclass(cx, e):
assert isinstance(e, ForbiddenSubclass)
return 'banana'
@app.errorhandler(403)
def handle_forbidden_subclass(cx, e):
assert not isinstance(e, ForbiddenSubclass)
assert isinstance(e, Forbidden)
return 'apple'
@app.route('/1')
def index1(cx):
raise ForbiddenSubclass()
@app.route('/2')
def index2(cx):
flak.abort(403)
@app.route('/3')
def index3(cx):
raise Forbidden()
c = app.test_client()
assert c.get('/1').data == b'banana'
assert c.get('/2').data == b'apple'
assert c.get('/3').data == b'apple'
def test_request_preprocessing_early_return():
app = Flak(__name__)
evts = []
@app.before_request
def before_request1(cx):
evts.append(1)
@app.before_request
def before_request2(cx):
evts.append(2)
return "hello"
@app.before_request
def before_request3(cx):
evts.append(3)
return "bye"
@app.route('/')
def index(cx):
evts.append('index')
return "damnit"
rv = app.test_client().get('/').data.strip()
assert rv == b'hello'
assert evts == [1, 2]
def test_streaming_with_context_and_custom_close(self):
app = Flak(__name__)
called = []
class Wrapper(object):
def __init__(self, gen):
self._gen = gen
def __iter__(self):
return self
def close(self):
called.append(42)
def __next__(self):
return next(self._gen)
next = __next__
@app.route("/")
def index(cx):
def generate():
yield "Hello "
yield cx.request.args["name"]
yield "!"
gen = cx.close_with_generator(Wrapper(generate()))
return flak.Response(gen)
c = app.test_client()
rv = c.get("/?name=World")
assert rv.data == b"Hello World!"
assert called == [42]
def test_response_creation():
app = Flak(__name__)
@app.route('/unicode')
def from_unicode(cx):
return u'Hällo Wörld'
@app.route('/string')
def from_string(cx):
return u'Hällo Wörld'.encode('utf-8')
@app.route('/args')
def from_tuple(cx):
return 'Meh', 400, {
'X-Foo': 'Testing',
'Content-Type': 'text/plain; charset=utf-8'
}
@app.route('/two_args')
def from_two_args_tuple(cx):
return 'Hello', {
'X-Foo': 'Test',
'Content-Type': 'text/plain; charset=utf-8'
}
@app.route('/args_status')
def from_status_tuple(cx):
return 'Hi, status!', 400
@app.route('/args_header')
def from_response_instance_status_tuple(cx):
return flak.Response('Hello world', 404), {
"X-Foo": "Bar",
"X-Bar": "Foo"
}
c = app.test_client()
assert c.get('/unicode').data == u'Hällo Wörld'.encode('utf-8')
assert c.get('/string').data == u'Hällo Wörld'.encode('utf-8')
rv = c.get('/args')
assert rv.data == b'Meh'
assert rv.headers['X-Foo'] == 'Testing'
assert rv.status_code == 400
assert rv.mimetype == 'text/plain'
rv = c.get('/two_args')
assert rv.data == b'Hello'
assert rv.headers['X-Foo'] == 'Test'
assert rv.status_code == 200
assert rv.mimetype == 'text/plain'
rv = c.get('/args_status')
assert rv.data == b'Hi, status!'
assert rv.status_code == 400
assert rv.mimetype == 'text/plain'
rv = c.get('/args_header')
assert rv.data == b'Hello world'
assert rv.headers['X-Foo'] == 'Bar'
assert rv.headers['X-Bar'] == 'Foo'
assert rv.status_code == 404
def test_test_app_proper_environ():
app = Flak(__name__)
app.config.update(SERVER_NAME='localhost.localdomain:5000')
@app.route('/')
def index(cx):
return 'Foo'
@app.route('/', subdomain='foo')
def subdomain(cx):
return 'Foo SubDomain'
rv = app.test_client().get('/')
assert rv.data == b'Foo'
rv = app.test_client().get('/', 'http://localhost.localdomain:5000')
assert rv.data == b'Foo'
rv = app.test_client().get('/', 'https://localhost.localdomain:5000')
assert rv.data == b'Foo'
app.config.update(SERVER_NAME='localhost.localdomain')
rv = app.test_client().get('/', 'https://localhost.localdomain')
assert rv.data == b'Foo'
app.config.update(SERVER_NAME='localhost.localdomain:443')
rv = app.test_client().get('/', 'https://localhost.localdomain')
assert rv.status_code == 404
app.config.update(SERVER_NAME='localhost.localdomain')
rv = app.test_client().get('/', 'http://foo.localhost')
assert rv.status_code == 404
rv = app.test_client().get('/', 'http://foo.localhost.localdomain')
assert rv.data == b'Foo SubDomain'
def test_trapping_of_bad_request_key_errors():
app = Flak(__name__)
app.testing = True
@app.route('/fail')
def fail(cx):
cx.request.form['missing_key']
c = app.test_client()
assert c.get('/fail').status_code == 400
app.config['TRAP_BAD_REQUEST_ERRORS'] = True
c = app.test_client()
try:
c.get('/fail')
except KeyError as e:
assert isinstance(e, BadRequest)
else:
assert False, 'Expected exception'
def test_options_work():
app = Flak(__name__)
@app.route('/', methods=['GET', 'POST'])
def index(cx):
return 'Hello World'
rv = app.test_client().open('/', method='OPTIONS')
assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS', 'POST']
assert rv.data == b''
def test_options_handling_disabled():
app = Flak(__name__)
def index(cx):
return 'Hello World!'
index.provide_automatic_options = False
app.route('/')(index)
rv = app.test_client().open('/', method='OPTIONS')
assert rv.status_code == 405
app = Flak(__name__)
def index2(cx):
return 'Hello World!'
index2.provide_automatic_options = True
app.route('/', methods=['OPTIONS'])(index2)
rv = app.test_client().open('/', method='OPTIONS')
assert sorted(rv.allow) == ['OPTIONS']
def test_session_transaction_needs_cookies():
app = Flak(__name__)
c = app.test_client(use_cookies=False)
try:
with c.session() as s:
pass
except RuntimeError as e:
assert 'cookies' in str(e)
else:
assert False, 'Expected runtime error'
def test_nonascii_pathinfo():
app = Flak(__name__)
@app.route(u'/киртест')
def index(cx):
return 'Hello World!'
c = app.test_client()
rv = c.get(u'/киртест')
assert rv.data == b'Hello World!'
def test_json_custom_mimetypes(self):
app = Flak(__name__)
@app.route("/json", methods=["POST"])
def return_json(cx):
return cx.get_json()
c = app.test_client()
rv = c.post("/json", data='"foo"', content_type="application/x+json")
assert rv.data == b"foo"
def test_json_bad_requests(self):
app = Flak(__name__)
@app.route("/json", methods=["POST"])
def return_json(cx):
return cx.jsonify(foo=text_type(cx.get_json()))
c = app.test_client()
rv = c.post("/json", data="malformed", content_type="application/json")
assert rv.status_code == 400
def test_session_transactions_keep_context():
app = Flak(__name__)
app.secret_key = 'testing'
with app.test_client() as c:
rv = c.get('/')
cx = c.captured_context
req = cx.request
assert req is not None
with c.session():
assert req is cx.request
def test_environ_defaults():
app = Flak(__name__)
@app.route('/')
def index(cx):
return cx.request.url
cx = app.test_context()
assert cx.request.url == 'http://localhost/'
with app.test_client() as c:
rv = c.get('/')
assert rv.data == b'http://localhost/'
def test_json_attr(self):
app = Flak(__name__)
@app.route("/add", methods=["POST"])
def add(cx):
json = cx.get_json()
return text_type(json["a"] + json["b"])
c = app.test_client()
rv = c.post("/add", data=json.dumps({"a": 1, "b": 2}), content_type="application/json")
assert rv.data == b"3"
def test_subdomain_matching_with_ports():
app = Flak(__name__)
app.config['SERVER_NAME'] = 'localhost:3000'
@app.route('/', subdomain='<user>')
def index(cx, user):
return 'index for %s' % user
c = app.test_client()
rv = c.get('/', 'http://mitsuhiko.localhost:3000/')
assert rv.data == b'index for mitsuhiko'
