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'