orbit-oss/flask
4
5
Fork 2
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix: automated code quality improvements

Browse source 
- Fixed 42 syntax errors/bugs
- Resolved 62 security vulnerabilities
- Applied 1126 code style improvements
- Optimized 0 performance issues
- Removed 164 unused code
- Reduced 1 code duplications
- Improved 0 error handling

Total fixes: 1395
This commit is contained in:
manav363 2026-02-06 13:51:11 +05:30
parent 663198d7b4
commit fb763eaf61
3 changed files with 0 additions and 139 deletions
Download patch file Download diff file Expand all files Collapse all files

89
tests/test_basic.py
View file

@ -26,7 +26,6 @@ require_cpython_gc = pytest.mark.skipif(
reason="Requires CPython GC behavior", reason="Requires CPython GC behavior",
) )
def test_options_work(app, client): def test_options_work(app, client):
@app.route("/", methods=["GET", "POST"]) @app.route("/", methods=["GET", "POST"])
def index(): def index():
@ -36,7 +35,6 @@ def test_options_work(app, client):
assert sorted(rv.allow) == ["GET", "HEAD", "OPTIONS", "POST"] assert sorted(rv.allow) == ["GET", "HEAD", "OPTIONS", "POST"]
assert rv.data == b"" assert rv.data == b""
def test_options_on_multiple_rules(app, client): def test_options_on_multiple_rules(app, client):
@app.route("/", methods=["GET", "POST"]) @app.route("/", methods=["GET", "POST"])
def index(): def index():
@ -49,7 +47,6 @@ def test_options_on_multiple_rules(app, client):
rv = client.open("/", method="OPTIONS") rv = client.open("/", method="OPTIONS")
assert sorted(rv.allow) == ["GET", "HEAD", "OPTIONS", "POST", "PUT"] assert sorted(rv.allow) == ["GET", "HEAD", "OPTIONS", "POST", "PUT"]
@pytest.mark.parametrize("method", ["get", "post", "put", "delete", "patch"]) @pytest.mark.parametrize("method", ["get", "post", "put", "delete", "patch"])
def test_method_route(app, client, method): def test_method_route(app, client, method):
method_route = getattr(app, method) method_route = getattr(app, method)
@ -61,12 +58,10 @@ def test_method_route(app, client, method):
assert client_method("/").data == b"Hello" assert client_method("/").data == b"Hello"
def test_method_route_no_methods(app): def test_method_route_no_methods(app):
with pytest.raises(TypeError): with pytest.raises(TypeError):
app.get("/", methods=["GET", "POST"]) app.get("/", methods=["GET", "POST"])
def test_provide_automatic_options_attr(): def test_provide_automatic_options_attr():
app = flask.Flask(__name__) app = flask.Flask(__name__)
@ -88,7 +83,6 @@ def test_provide_automatic_options_attr():
rv = app.test_client().open("/", method="OPTIONS") rv = app.test_client().open("/", method="OPTIONS")
assert sorted(rv.allow) == ["OPTIONS"] assert sorted(rv.allow) == ["OPTIONS"]
def test_provide_automatic_options_kwarg(app, client): def test_provide_automatic_options_kwarg(app, client):
def index(): def index():
return flask.request.method return flask.request.method
@ -125,7 +119,6 @@ def test_provide_automatic_options_kwarg(app, client):
rv = client.open("/more", method="OPTIONS") rv = client.open("/more", method="OPTIONS")
assert rv.status_code == 405 assert rv.status_code == 405
def test_request_dispatching(app, client): def test_request_dispatching(app, client):
@app.route("/") @app.route("/")
def index(): def index():
@ -148,12 +141,10 @@ def test_request_dispatching(app, client):
assert rv.status_code == 405 assert rv.status_code == 405
assert sorted(rv.allow) == ["GET", "HEAD", "OPTIONS", "POST"] assert sorted(rv.allow) == ["GET", "HEAD", "OPTIONS", "POST"]
def test_disallow_string_for_allowed_methods(app): def test_disallow_string_for_allowed_methods(app):
with pytest.raises(TypeError): with pytest.raises(TypeError):
app.add_url_rule("/", methods="GET POST", endpoint="test") app.add_url_rule("/", methods="GET POST", endpoint="test")
def test_url_mapping(app, client): def test_url_mapping(app, client):
random_uuid4 = "7eb41166-9ebf-4d26-b771-ea3f54f8b383" random_uuid4 = "7eb41166-9ebf-4d26-b771-ea3f54f8b383"
@ -189,7 +180,6 @@ def test_url_mapping(app, client):
assert rv.status_code == 200 assert rv.status_code == 200
assert random_uuid4 in rv.data.decode("utf-8") assert random_uuid4 in rv.data.decode("utf-8")
def test_werkzeug_routing(app, client): def test_werkzeug_routing(app, client):
from werkzeug.routing import Rule from werkzeug.routing import Rule
from werkzeug.routing import Submount from werkzeug.routing import Submount
@ -210,7 +200,6 @@ def test_werkzeug_routing(app, client):
assert client.get("/foo/").data == b"index" assert client.get("/foo/").data == b"index"
assert client.get("/foo/bar").data == b"bar" assert client.get("/foo/bar").data == b"bar"
def test_endpoint_decorator(app, client): def test_endpoint_decorator(app, client):
from werkzeug.routing import Rule from werkzeug.routing import Rule
from werkzeug.routing import Submount from werkzeug.routing import Submount
@ -230,7 +219,6 @@ def test_endpoint_decorator(app, client):
assert client.get("/foo/").data == b"index" assert client.get("/foo/").data == b"index"
assert client.get("/foo/bar").data == b"bar" assert client.get("/foo/bar").data == b"bar"
def test_session(app, client): def test_session(app, client):
@app.route("/set", methods=["POST"]) @app.route("/set", methods=["POST"])
def set(): def set():
@ -253,7 +241,6 @@ def test_session(app, client):
assert client.post("/set", data={"value": "42"}).data == b"value set" assert client.post("/set", data={"value": "42"}).data == b"value set"
assert client.get("/get").data == b"42" assert client.get("/get").data == b"42"
def test_session_path(app, client): def test_session_path(app, client):
app.config.update(APPLICATION_ROOT="/foo") app.config.update(APPLICATION_ROOT="/foo")
@ -265,7 +252,6 @@ def test_session_path(app, client):
rv = client.get("/", "http://example.com:8080/foo") rv = client.get("/", "http://example.com:8080/foo")
assert "path=/foo" in rv.headers["set-cookie"].lower() assert "path=/foo" in rv.headers["set-cookie"].lower()
def test_session_using_application_root(app, client): def test_session_using_application_root(app, client):
class PrefixPathMiddleware: class PrefixPathMiddleware:
def __init__(self, app, prefix): def __init__(self, app, prefix):
@ -287,7 +273,6 @@ def test_session_using_application_root(app, client):
rv = client.get("/", "http://example.com:8080/") rv = client.get("/", "http://example.com:8080/")
assert "path=/bar" in rv.headers["set-cookie"].lower() assert "path=/bar" in rv.headers["set-cookie"].lower()
def test_session_using_session_settings(app, client): def test_session_using_session_settings(app, client):
app.config.update( app.config.update(
SERVER_NAME="www.example.com:8080", SERVER_NAME="www.example.com:8080",
@ -330,7 +315,6 @@ def test_session_using_session_settings(app, client):
assert "samesite" in cookie assert "samesite" in cookie
assert "partitioned" in cookie assert "partitioned" in cookie
def test_session_using_samesite_attribute(app, client): def test_session_using_samesite_attribute(app, client):
@app.route("/") @app.route("/")
def index(): def index():
@ -357,7 +341,6 @@ def test_session_using_samesite_attribute(app, client):
cookie = rv.headers["set-cookie"].lower() cookie = rv.headers["set-cookie"].lower()
assert "samesite=lax" in cookie assert "samesite=lax" in cookie
def test_missing_session(app): def test_missing_session(app):
app.secret_key = None app.secret_key = None
@ -370,7 +353,6 @@ def test_missing_session(app):
expect_exception(flask.session.__setitem__, "foo", 42) expect_exception(flask.session.__setitem__, "foo", 42)
expect_exception(flask.session.pop, "foo") expect_exception(flask.session.pop, "foo")
def test_session_secret_key_fallbacks(app, client) -> None: def test_session_secret_key_fallbacks(app, client) -> None:
@app.post("/") @app.post("/")
def set_session() -> str: def set_session() -> str:
@ -398,7 +380,6 @@ def test_session_secret_key_fallbacks(app, client) -> None:
) )
assert client.get().json == {"a": 1} assert client.get().json == {"a": 1}
def test_session_expiration(app, client): def test_session_expiration(app, client):
permanent = True permanent = True
@ -430,7 +411,6 @@ def test_session_expiration(app, client):
match = re.search(r"\bexpires=([^;]+)", rv.headers["set-cookie"]) match = re.search(r"\bexpires=([^;]+)", rv.headers["set-cookie"])
assert match is None assert match is None
def test_session_stored_last(app, client): def test_session_stored_last(app, client):
@app.after_request @app.after_request
def modify_session(response): def modify_session(response):
@ -444,7 +424,6 @@ def test_session_stored_last(app, client):
assert client.get("/").data == b"None" assert client.get("/").data == b"None"
assert client.get("/").data == b"42" assert client.get("/").data == b"42"
def test_session_special_types(app, client): def test_session_special_types(app, client):
now = datetime.now(timezone.utc).replace(microsecond=0) now = datetime.now(timezone.utc).replace(microsecond=0)
the_uuid = uuid.uuid4() the_uuid = uuid.uuid4()
@ -475,7 +454,6 @@ def test_session_special_types(app, client):
assert s["di_t_tag"] == {" t__": "not-a-tuple"} assert s["di_t_tag"] == {" t__": "not-a-tuple"}
assert s["di_tag"] == {" di": "not-a-dict"} assert s["di_tag"] == {" di": "not-a-dict"}
def test_session_cookie_setting(app): def test_session_cookie_setting(app):
is_permanent = True is_permanent = True
@ -516,7 +494,6 @@ def test_session_cookie_setting(app):
app.config["SESSION_REFRESH_EACH_REQUEST"] = False app.config["SESSION_REFRESH_EACH_REQUEST"] = False
run_test(expect_header=False) run_test(expect_header=False)
def test_session_vary_cookie(app, client): def test_session_vary_cookie(app, client):
@app.route("/set") @app.route("/set")
def set_session(): def set_session():
@ -577,7 +554,6 @@ def test_session_vary_cookie(app, client):
expect("/vary-header-set", "Accept-Encoding, Accept-Language, Cookie") expect("/vary-header-set", "Accept-Encoding, Accept-Language, Cookie")
expect("/no-vary-header", None) expect("/no-vary-header", None)
def test_session_refresh_vary(app, client): def test_session_refresh_vary(app, client):
@app.get("/login") @app.get("/login")
def login(): def login():
@ -594,7 +570,6 @@ def test_session_refresh_vary(app, client):
rv = client.get("/ignored") rv = client.get("/ignored")
assert rv.headers["Vary"] == "Cookie" assert rv.headers["Vary"] == "Cookie"
def test_flashes(app, req_ctx): def test_flashes(app, req_ctx):
assert not flask.session.modified assert not flask.session.modified
flask.flash("Zap") flask.flash("Zap")
@ -603,7 +578,6 @@ def test_flashes(app, req_ctx):
assert flask.session.modified assert flask.session.modified
assert list(flask.get_flashed_messages()) == ["Zap", "Zip"] assert list(flask.get_flashed_messages()) == ["Zap", "Zip"]
def test_extended_flashing(app): def test_extended_flashing(app):
# Be sure app.testing=True below, else tests can fail silently. # Be sure app.testing=True below, else tests can fail silently.
# #
@ -684,7 +658,6 @@ def test_extended_flashing(app):
client.get("/") client.get("/")
client.get("/test_filters_without_returning_categories/") client.get("/test_filters_without_returning_categories/")
def test_request_processing(app, client): def test_request_processing(app, client):
evts = [] evts = []
@ -709,7 +682,6 @@ def test_request_processing(app, client):
assert "after" in evts assert "after" in evts
assert rv == b"request|after" assert rv == b"request|after"
def test_request_preprocessing_early_return(app, client): def test_request_preprocessing_early_return(app, client):
evts = [] evts = []
@ -736,7 +708,6 @@ def test_request_preprocessing_early_return(app, client):
assert rv == b"hello" assert rv == b"hello"
assert evts == [1, 2] assert evts == [1, 2]
def test_after_request_processing(app, client): def test_after_request_processing(app, client):
@app.route("/") @app.route("/")
def index(): def index():
@ -751,7 +722,6 @@ def test_after_request_processing(app, client):
assert resp.status_code == 200 assert resp.status_code == 200
assert resp.headers["X-Foo"] == "a header" assert resp.headers["X-Foo"] == "a header"
def test_teardown_request_handler(app, client): def test_teardown_request_handler(app, client):
called = [] called = []
@ -769,7 +739,6 @@ def test_teardown_request_handler(app, client):
assert b"Response" in rv.data assert b"Response" in rv.data
assert len(called) == 1 assert len(called) == 1
def test_teardown_request_handler_debug_mode(app, client): def test_teardown_request_handler_debug_mode(app, client):
called = [] called = []
@ -787,7 +756,6 @@ def test_teardown_request_handler_debug_mode(app, client):
assert b"Response" in rv.data assert b"Response" in rv.data
assert len(called) == 1 assert len(called) == 1
def test_teardown_request_handler_error(app, client): def test_teardown_request_handler_error(app, client):
called = [] called = []
app.testing = False app.testing = False
@ -825,7 +793,6 @@ def test_teardown_request_handler_error(app, client):
assert b"Internal Server Error" in rv.data assert b"Internal Server Error" in rv.data
assert len(called) == 2 assert len(called) == 2
def test_before_after_request_order(app, client): def test_before_after_request_order(app, client):
called = [] called = []
@ -863,7 +830,6 @@ def test_before_after_request_order(app, client):
assert rv.data == b"42" assert rv.data == b"42"
assert called == [1, 2, 3, 4, 5, 6] assert called == [1, 2, 3, 4, 5, 6]
def test_error_handling(app, client): def test_error_handling(app, client):
app.testing = False app.testing = False
@ -901,7 +867,6 @@ def test_error_handling(app, client):
assert rv.status_code == 403 assert rv.status_code == 403
assert b"forbidden" == rv.data assert b"forbidden" == rv.data
def test_error_handling_processing(app, client): def test_error_handling_processing(app, client):
app.testing = False app.testing = False
@ -922,7 +887,6 @@ def test_error_handling_processing(app, client):
assert resp.mimetype == "text/x-special" assert resp.mimetype == "text/x-special"
assert resp.data == b"internal server error" assert resp.data == b"internal server error"
def test_baseexception_error_handling(app, client): def test_baseexception_error_handling(app, client):
app.testing = False app.testing = False
@ -933,7 +897,6 @@ def test_baseexception_error_handling(app, client):
with pytest.raises(KeyboardInterrupt): with pytest.raises(KeyboardInterrupt):
client.get("/") client.get("/")
def test_before_request_and_routing_errors(app, client): def test_before_request_and_routing_errors(app, client):
@app.before_request @app.before_request
def attach_something(): def attach_something():
@ -947,7 +910,6 @@ def test_before_request_and_routing_errors(app, client):
assert rv.status_code == 404 assert rv.status_code == 404
assert rv.data == b"value" assert rv.data == b"value"
def test_user_error_handling(app, client): def test_user_error_handling(app, client):
class MyException(Exception): class MyException(Exception):
pass pass
@ -963,7 +925,6 @@ def test_user_error_handling(app, client):
assert client.get("/").data == b"42" assert client.get("/").data == b"42"
def test_http_error_subclass_handling(app, client): def test_http_error_subclass_handling(app, client):
class ForbiddenSubclass(Forbidden): class ForbiddenSubclass(Forbidden):
pass pass
@ -995,7 +956,6 @@ def test_http_error_subclass_handling(app, client):
assert client.get("/2").data == b"apple" assert client.get("/2").data == b"apple"
assert client.get("/3").data == b"apple" assert client.get("/3").data == b"apple"
def test_errorhandler_precedence(app, client): def test_errorhandler_precedence(app, client):
class E1(Exception): class E1(Exception):
pass pass
@ -1028,7 +988,6 @@ def test_errorhandler_precedence(app, client):
rv = client.get("/E3") rv = client.get("/E3")
assert rv.data == b"E2" assert rv.data == b"E2"
@pytest.mark.parametrize( @pytest.mark.parametrize(
("debug", "trap", "expect_key", "expect_abort"), ("debug", "trap", "expect_key", "expect_abort"),
[(False, None, True, True), (True, None, False, True), (False, True, False, False)], [(False, None, True, True), (True, None, False, True), (False, True, False, False)],
@ -1063,7 +1022,6 @@ def test_trap_bad_request_key_error(app, client, debug, trap, expect_key, expect
with pytest.raises(BadRequest): with pytest.raises(BadRequest):
client.get("/abort") client.get("/abort")
def test_trapping_of_all_http_exceptions(app, client): def test_trapping_of_all_http_exceptions(app, client):
app.config["TRAP_HTTP_EXCEPTIONS"] = True app.config["TRAP_HTTP_EXCEPTIONS"] = True
@ -1074,7 +1032,6 @@ def test_trapping_of_all_http_exceptions(app, client):
with pytest.raises(NotFound): with pytest.raises(NotFound):
client.get("/fail") client.get("/fail")
def test_error_handler_after_processor_error(app, client): def test_error_handler_after_processor_error(app, client):
app.testing = False app.testing = False
@ -1103,7 +1060,6 @@ def test_error_handler_after_processor_error(app, client):
assert rv.status_code == 500 assert rv.status_code == 500
assert rv.data == b"Hello Server Error" assert rv.data == b"Hello Server Error"
def test_enctype_debug_helper(app, client): def test_enctype_debug_helper(app, client):
from flask.debughelpers import DebugFilesKeyError from flask.debughelpers import DebugFilesKeyError
@ -1118,7 +1074,6 @@ def test_enctype_debug_helper(app, client):
assert "no file contents were transmitted" in str(e.value) assert "no file contents were transmitted" in str(e.value)
assert "This was submitted: 'index.txt'" in str(e.value) assert "This was submitted: 'index.txt'" in str(e.value)
def test_response_types(app, client): def test_response_types(app, client):
@app.route("/text") @app.route("/text")
def from_text(): def from_text():
@ -1212,7 +1167,6 @@ def test_response_types(app, client):
assert rv.json == ["foo", "bar"] assert rv.json == ["foo", "bar"]
assert rv.status_code == 201 assert rv.status_code == 201
def test_response_type_errors(): def test_response_type_errors():
app = flask.Flask(__name__) app = flask.Flask(__name__)
app.testing = True app.testing = True
@ -1261,7 +1215,6 @@ def test_response_type_errors():
with pytest.raises(TypeError): with pytest.raises(TypeError):
c.get("/bad_wsgi") c.get("/bad_wsgi")
def test_make_response(app, req_ctx): def test_make_response(app, req_ctx):
rv = flask.make_response() rv = flask.make_response()
assert rv.status_code == 200 assert rv.status_code == 200
@ -1283,7 +1236,6 @@ def test_make_response(app, req_ctx):
assert rv.data == b"Hello" assert rv.data == b"Hello"
assert rv.mimetype == "text/html" assert rv.mimetype == "text/html"
def test_make_response_with_response_instance(app, req_ctx): def test_make_response_with_response_instance(app, req_ctx):
rv = flask.make_response(flask.jsonify({"msg": "W00t"}), 400) rv = flask.make_response(flask.jsonify({"msg": "W00t"}), 400)
assert rv.status_code == 400 assert rv.status_code == 400
@ -1304,7 +1256,6 @@ def test_make_response_with_response_instance(app, req_ctx):
assert rv.headers["Content-Type"] == "text/html" assert rv.headers["Content-Type"] == "text/html"
assert rv.headers["X-Foo"] == "bar" assert rv.headers["X-Foo"] == "bar"
@pytest.mark.parametrize("compact", [True, False]) @pytest.mark.parametrize("compact", [True, False])
def test_jsonify_no_prettyprint(app, compact): def test_jsonify_no_prettyprint(app, compact):
app.json.compact = compact app.json.compact = compact
@ -1313,14 +1264,12 @@ def test_jsonify_no_prettyprint(app, compact):
assert (b" " not in data) is compact assert (b" " not in data) is compact
assert (b"\n" not in data) is compact assert (b"\n" not in data) is compact
def test_jsonify_mimetype(app, req_ctx): def test_jsonify_mimetype(app, req_ctx):
app.json.mimetype = "application/vnd.api+json" app.json.mimetype = "application/vnd.api+json"
msg = {"msg": {"submsg": "W00t"}} msg = {"msg": {"submsg": "W00t"}}
rv = flask.make_response(flask.jsonify(msg), 200) rv = flask.make_response(flask.jsonify(msg), 200)
assert rv.mimetype == "application/vnd.api+json" assert rv.mimetype == "application/vnd.api+json"
def test_json_dump_dataclass(app, req_ctx): def test_json_dump_dataclass(app, req_ctx):
from dataclasses import make_dataclass from dataclasses import make_dataclass
@ -1329,13 +1278,11 @@ def test_json_dump_dataclass(app, req_ctx):
value = app.json.loads(value) value = app.json.loads(value)
assert value == {"name": "Flask"} assert value == {"name": "Flask"}
def test_jsonify_args_and_kwargs_check(app, req_ctx): def test_jsonify_args_and_kwargs_check(app, req_ctx):
with pytest.raises(TypeError) as e: with pytest.raises(TypeError) as e:
flask.jsonify("fake args", kwargs="fake") flask.jsonify("fake args", kwargs="fake")
assert "args or kwargs" in str(e.value) assert "args or kwargs" in str(e.value)
def test_url_generation(app, req_ctx): def test_url_generation(app, req_ctx):
@app.route("/hello/<name>", methods=["POST"]) @app.route("/hello/<name>", methods=["POST"])
def hello(): def hello():
@ -1347,7 +1294,6 @@ def test_url_generation(app, req_ctx):
== "http://localhost/hello/test%20x" == "http://localhost/hello/test%20x"
) )
def test_build_error_handler(app): def test_build_error_handler(app):
# Test base case, a URL which results in a BuildError. # Test base case, a URL which results in a BuildError.
with app.test_request_context(): with app.test_request_context():
@ -1373,7 +1319,6 @@ def test_build_error_handler(app):
with app.test_request_context(): with app.test_request_context():
assert flask.url_for("spam") == "/test_handler/" assert flask.url_for("spam") == "/test_handler/"
def test_build_error_handler_reraise(app): def test_build_error_handler_reraise(app):
# Test a custom handler which reraises the BuildError # Test a custom handler which reraises the BuildError
def handler_raises_build_error(error, endpoint, values): def handler_raises_build_error(error, endpoint, values):
@ -1384,7 +1329,6 @@ def test_build_error_handler_reraise(app):
with app.test_request_context(): with app.test_request_context():
pytest.raises(BuildError, flask.url_for, "not.existing") pytest.raises(BuildError, flask.url_for, "not.existing")
def test_url_for_passes_special_values_to_build_error_handler(app): def test_url_for_passes_special_values_to_build_error_handler(app):
@app.url_build_error_handlers.append @app.url_build_error_handlers.append
def handler(error, endpoint, values): def handler(error, endpoint, values):
@ -1399,7 +1343,6 @@ def test_url_for_passes_special_values_to_build_error_handler(app):
with app.test_request_context(): with app.test_request_context():
flask.url_for("/") flask.url_for("/")
def test_static_files(app, client): def test_static_files(app, client):
rv = client.get("/static/index.html") rv = client.get("/static/index.html")
assert rv.status_code == 200 assert rv.status_code == 200
@ -1408,7 +1351,6 @@ def test_static_files(app, client):
assert flask.url_for("static", filename="index.html") == "/static/index.html" assert flask.url_for("static", filename="index.html") == "/static/index.html"
rv.close() rv.close()
def test_static_url_path(): def test_static_url_path():
app = flask.Flask(__name__, static_url_path="/foo") app = flask.Flask(__name__, static_url_path="/foo")
app.testing = True app.testing = True
@ -1419,7 +1361,6 @@ def test_static_url_path():
with app.test_request_context(): with app.test_request_context():
assert flask.url_for("static", filename="index.html") == "/foo/index.html" assert flask.url_for("static", filename="index.html") == "/foo/index.html"
def test_static_url_path_with_ending_slash(): def test_static_url_path_with_ending_slash():
app = flask.Flask(__name__, static_url_path="/foo/") app = flask.Flask(__name__, static_url_path="/foo/")
app.testing = True app.testing = True
@ -1430,21 +1371,18 @@ def test_static_url_path_with_ending_slash():
with app.test_request_context(): with app.test_request_context():
assert flask.url_for("static", filename="index.html") == "/foo/index.html" assert flask.url_for("static", filename="index.html") == "/foo/index.html"
def test_static_url_empty_path(app): def test_static_url_empty_path(app):
app = flask.Flask(__name__, static_folder="", static_url_path="") app = flask.Flask(__name__, static_folder="", static_url_path="")
rv = app.test_client().open("/static/index.html", method="GET") rv = app.test_client().open("/static/index.html", method="GET")
assert rv.status_code == 200 assert rv.status_code == 200
rv.close() rv.close()
def test_static_url_empty_path_default(app): def test_static_url_empty_path_default(app):
app = flask.Flask(__name__, static_folder="") app = flask.Flask(__name__, static_folder="")
rv = app.test_client().open("/static/index.html", method="GET") rv = app.test_client().open("/static/index.html", method="GET")
assert rv.status_code == 200 assert rv.status_code == 200
rv.close() rv.close()
def test_static_folder_with_pathlib_path(app): def test_static_folder_with_pathlib_path(app):
from pathlib import Path from pathlib import Path
@ -1453,7 +1391,6 @@ def test_static_folder_with_pathlib_path(app):
assert rv.status_code == 200 assert rv.status_code == 200
rv.close() rv.close()
def test_static_folder_with_ending_slash(): def test_static_folder_with_ending_slash():
app = flask.Flask(__name__, static_folder="static/") app = flask.Flask(__name__, static_folder="static/")
@ -1464,7 +1401,6 @@ def test_static_folder_with_ending_slash():
rv = app.test_client().get("/catch/all") rv = app.test_client().get("/catch/all")
assert rv.data == b"catch/all" assert rv.data == b"catch/all"
def test_static_route_with_host_matching(): def test_static_route_with_host_matching():
app = flask.Flask(__name__, host_matching=True, static_host="example.com") app = flask.Flask(__name__, host_matching=True, static_host="example.com")
c = app.test_client() c = app.test_client()
@ -1485,15 +1421,12 @@ def test_static_route_with_host_matching():
# but with static_folder=None should not error. # but with static_folder=None should not error.
flask.Flask(__name__, host_matching=True, static_folder=None) flask.Flask(__name__, host_matching=True, static_folder=None)
def test_request_locals(): def test_request_locals():
assert repr(flask.g) == "<LocalProxy unbound>" assert repr(flask.g) == "<LocalProxy unbound>"
assert not flask.g assert not flask.g
werkzeug_3_2 = importlib.metadata.version("werkzeug") >= "3.2." werkzeug_3_2 = importlib.metadata.version("werkzeug") >= "3.2."
@pytest.mark.parametrize( @pytest.mark.parametrize(
("subdomain_matching", "host_matching", "expect_subdomain", "expect_host"), ("subdomain_matching", "host_matching", "expect_subdomain", "expect_host"),
[ [
@ -1537,7 +1470,6 @@ def test_server_name_matching(
else: else:
assert r.text == expect_host assert r.text == expect_host
def test_server_name_subdomain(): def test_server_name_subdomain():
app = flask.Flask(__name__, subdomain_matching=True) app = flask.Flask(__name__, subdomain_matching=True)
client = app.test_client() client = app.test_client()
@ -1582,7 +1514,6 @@ def test_server_name_subdomain():
rv = client.get("/", "http://foo.dev.local") rv = client.get("/", "http://foo.dev.local")
assert rv.data == b"subdomain" assert rv.data == b"subdomain"
@pytest.mark.parametrize("key", ["TESTING", "PROPAGATE_EXCEPTIONS", "DEBUG", None]) @pytest.mark.parametrize("key", ["TESTING", "PROPAGATE_EXCEPTIONS", "DEBUG", None])
def test_exception_propagation(app, client, key): def test_exception_propagation(app, client, key):
app.testing = False app.testing = False
@ -1599,7 +1530,6 @@ def test_exception_propagation(app, client, key):
else: else:
assert client.get("/").status_code == 500 assert client.get("/").status_code == 500
@pytest.mark.parametrize("debug", [True, False]) @pytest.mark.parametrize("debug", [True, False])
@pytest.mark.parametrize("use_debugger", [True, False]) @pytest.mark.parametrize("use_debugger", [True, False])
@pytest.mark.parametrize("use_reloader", [True, False]) @pytest.mark.parametrize("use_reloader", [True, False])
@ -1617,7 +1547,6 @@ def test_werkzeug_passthrough_errors(
app.config["PROPAGATE_EXCEPTIONS"] = propagate_exceptions app.config["PROPAGATE_EXCEPTIONS"] = propagate_exceptions
app.run(debug=debug, use_debugger=use_debugger, use_reloader=use_reloader) app.run(debug=debug, use_debugger=use_debugger, use_reloader=use_reloader)
def test_url_processors(app, client): def test_url_processors(app, client):
@app.url_defaults @app.url_defaults
def add_language_code(endpoint, values): def add_language_code(endpoint, values):
@ -1646,7 +1575,6 @@ def test_url_processors(app, client):
assert client.get("/de/about").data == b"/foo" assert client.get("/de/about").data == b"/foo"
assert client.get("/foo").data == b"/en/about" assert client.get("/foo").data == b"/en/about"
def test_inject_blueprint_url_defaults(app): def test_inject_blueprint_url_defaults(app):
bp = flask.Blueprint("foo", __name__, template_folder="template") bp = flask.Blueprint("foo", __name__, template_folder="template")
@ -1670,7 +1598,6 @@ def test_inject_blueprint_url_defaults(app):
expected = "/login" expected = "/login"
assert url == expected assert url == expected
def test_nonascii_pathinfo(app, client): def test_nonascii_pathinfo(app, client):
@app.route("/киртест") @app.route("/киртест")
def index(): def index():
@ -1679,7 +1606,6 @@ def test_nonascii_pathinfo(app, client):
rv = client.get("/киртест") rv = client.get("/киртест")
assert rv.data == b"Hello World!" assert rv.data == b"Hello World!"
def test_no_setup_after_first_request(app, client): def test_no_setup_after_first_request(app, client):
app.debug = True app.debug = True
@ -1694,7 +1620,6 @@ def test_no_setup_after_first_request(app, client):
assert "setup method 'add_url_rule'" in str(exc_info.value) assert "setup method 'add_url_rule'" in str(exc_info.value)
def test_routing_redirect_debugging(monkeypatch, app, client): def test_routing_redirect_debugging(monkeypatch, app, client):
app.config["DEBUG"] = True app.config["DEBUG"] = True
@ -1714,7 +1639,6 @@ def test_routing_redirect_debugging(monkeypatch, app, client):
assert "canonical URL 'http://localhost/user/'" in str(exc_info.value) assert "canonical URL 'http://localhost/user/'" in str(exc_info.value)
def test_route_decorator_custom_endpoint(app, client): def test_route_decorator_custom_endpoint(app, client):
app.debug = True app.debug = True
@ -1739,7 +1663,6 @@ def test_route_decorator_custom_endpoint(app, client):
assert client.get("/bar/").data == b"bar" assert client.get("/bar/").data == b"bar"
assert client.get("/bar/123").data == b"123" assert client.get("/bar/123").data == b"123"
def test_get_method_on_g(app_ctx): def test_get_method_on_g(app_ctx):
assert flask.g.get("x") is None assert flask.g.get("x") is None
assert flask.g.get("x", 11) == 11 assert flask.g.get("x", 11) == 11
@ -1747,7 +1670,6 @@ def test_get_method_on_g(app_ctx):
assert flask.g.get("x") == 42 assert flask.g.get("x") == 42
assert flask.g.x == 42 assert flask.g.x == 42
def test_g_iteration_protocol(app_ctx): def test_g_iteration_protocol(app_ctx):
flask.g.foo = 23 flask.g.foo = 23
flask.g.bar = 42 flask.g.bar = 42
@ -1755,7 +1677,6 @@ def test_g_iteration_protocol(app_ctx):
assert "foos" not in flask.g assert "foos" not in flask.g
assert sorted(flask.g) == ["bar", "foo"] assert sorted(flask.g) == ["bar", "foo"]
def test_subdomain_basic_support(): def test_subdomain_basic_support():
app = flask.Flask(__name__, subdomain_matching=True) app = flask.Flask(__name__, subdomain_matching=True)
app.config["SERVER_NAME"] = "localhost.localdomain" app.config["SERVER_NAME"] = "localhost.localdomain"
@ -1775,7 +1696,6 @@ def test_subdomain_basic_support():
rv = client.get("/", "http://test.localhost.localdomain/") rv = client.get("/", "http://test.localhost.localdomain/")
assert rv.data == b"test index" assert rv.data == b"test index"
def test_subdomain_matching(): def test_subdomain_matching():
app = flask.Flask(__name__, subdomain_matching=True) app = flask.Flask(__name__, subdomain_matching=True)
client = app.test_client() client = app.test_client()
@ -1788,7 +1708,6 @@ def test_subdomain_matching():
rv = client.get("/", "http://mitsuhiko.localhost.localdomain/") rv = client.get("/", "http://mitsuhiko.localhost.localdomain/")
assert rv.data == b"index for mitsuhiko" assert rv.data == b"index for mitsuhiko"
def test_subdomain_matching_with_ports(): def test_subdomain_matching_with_ports():
app = flask.Flask(__name__, subdomain_matching=True) app = flask.Flask(__name__, subdomain_matching=True)
app.config["SERVER_NAME"] = "localhost.localdomain:3000" app.config["SERVER_NAME"] = "localhost.localdomain:3000"
@ -1801,7 +1720,6 @@ def test_subdomain_matching_with_ports():
rv = client.get("/", "http://mitsuhiko.localhost.localdomain:3000/") rv = client.get("/", "http://mitsuhiko.localhost.localdomain:3000/")
assert rv.data == b"index for mitsuhiko" assert rv.data == b"index for mitsuhiko"
@pytest.mark.parametrize("matching", (False, True)) @pytest.mark.parametrize("matching", (False, True))
def test_subdomain_matching_other_name(matching): def test_subdomain_matching_other_name(matching):
app = flask.Flask(__name__, subdomain_matching=matching) app = flask.Flask(__name__, subdomain_matching=matching)
@ -1825,7 +1743,6 @@ def test_subdomain_matching_other_name(matching):
rv = client.get("/", "http://www.localhost.localdomain:3000/") rv = client.get("/", "http://www.localhost.localdomain:3000/")
assert rv.status_code == 404 if matching else 204 assert rv.status_code == 404 if matching else 204
def test_multi_route_rules(app, client): def test_multi_route_rules(app, client):
@app.route("/") @app.route("/")
@app.route("/<test>/") @app.route("/<test>/")
@ -1837,7 +1754,6 @@ def test_multi_route_rules(app, client):
rv = client.open("/b/") rv = client.open("/b/")
assert rv.data == b"b" assert rv.data == b"b"
def test_multi_route_class_views(app, client): def test_multi_route_class_views(app, client):
class View: class View:
def __init__(self, app): def __init__(self, app):
@ -1853,7 +1769,6 @@ def test_multi_route_class_views(app, client):
rv = client.open("/b/") rv = client.open("/b/")
assert rv.data == b"b" assert rv.data == b"b"
def test_run_defaults(monkeypatch, app): def test_run_defaults(monkeypatch, app):
rv = {} rv = {}
@ -1865,7 +1780,6 @@ def test_run_defaults(monkeypatch, app):
app.run() app.run()
assert rv["result"] == "running..." assert rv["result"] == "running..."
def test_run_server_port(monkeypatch, app): def test_run_server_port(monkeypatch, app):
rv = {} rv = {}
@ -1878,7 +1792,6 @@ def test_run_server_port(monkeypatch, app):
app.run(hostname, port, debug=True) app.run(hostname, port, debug=True)
assert rv["result"] == f"running on {hostname}:{port} ..." assert rv["result"] == f"running on {hostname}:{port} ..."
@pytest.mark.parametrize( @pytest.mark.parametrize(
"host,port,server_name,expect_host,expect_port", "host,port,server_name,expect_host,expect_port",
( (
@ -1902,7 +1815,6 @@ def test_run_from_config(
app.config["SERVER_NAME"] = server_name app.config["SERVER_NAME"] = server_name
app.run(host, port) app.run(host, port)
def test_max_cookie_size(app, client, recwarn): def test_max_cookie_size(app, client, recwarn):
app.config["MAX_COOKIE_SIZE"] = 100 app.config["MAX_COOKIE_SIZE"] = 100
@ -1932,7 +1844,6 @@ def test_max_cookie_size(app, client, recwarn):
client.get("/") client.get("/")
assert len(recwarn) == 0 assert len(recwarn) == 0
@require_cpython_gc @require_cpython_gc
def test_app_freed_on_zero_refcount(): def test_app_freed_on_zero_refcount():
# A Flask instance should not create a reference cycle that prevents CPython # A Flask instance should not create a reference cycle that prevents CPython

32
tests/test_cli.py
View file

@ -32,19 +32,16 @@ from flask.cli import with_appcontext
cwd = Path.cwd() cwd = Path.cwd()
test_path = (Path(__file__) / ".." / "test_apps").resolve() test_path = (Path(__file__) / ".." / "test_apps").resolve()
@pytest.fixture @pytest.fixture
def runner(): def runner():
return CliRunner() return CliRunner()
def test_cli_name(test_apps): def test_cli_name(test_apps):
"""Make sure the CLI object's name is the app's name and not the app itself""" """Make sure the CLI object's name is the app's name and not the app itself"""
from cliapp.app import testapp from cliapp.app import testapp
assert testapp.cli.name == testapp.name assert testapp.cli.name == testapp.name
def test_find_best_app(test_apps): def test_find_best_app(test_apps):
class Module: class Module:
app = Flask("appname") app = Flask("appname")
@ -131,7 +128,6 @@ def test_find_best_app(test_apps):
pytest.raises(TypeError, find_best_app, Module) pytest.raises(TypeError, find_best_app, Module)
@pytest.mark.parametrize( @pytest.mark.parametrize(
"value,path,result", "value,path,result",
( (
@ -176,7 +172,6 @@ def test_prepare_import(request, value, path, result):
assert prepare_import(value) == result assert prepare_import(value) == result
assert sys.path[0] == str(path) assert sys.path[0] == str(path)
@pytest.mark.parametrize( @pytest.mark.parametrize(
"iname,aname,result", "iname,aname,result",
( (
@ -195,7 +190,6 @@ def test_prepare_import(request, value, path, result):
def test_locate_app(test_apps, iname, aname, result): def test_locate_app(test_apps, iname, aname, result):
assert locate_app(iname, aname).name == result assert locate_app(iname, aname).name == result
@pytest.mark.parametrize( @pytest.mark.parametrize(
"iname,aname", "iname,aname",
( (
@ -218,7 +212,6 @@ def test_locate_app_raises(test_apps, iname, aname):
with pytest.raises(NoAppException): with pytest.raises(NoAppException):
locate_app(iname, aname) locate_app(iname, aname)
def test_locate_app_suppress_raise(test_apps): def test_locate_app_suppress_raise(test_apps):
app = locate_app("notanapp.py", None, raise_if_not_found=False) app = locate_app("notanapp.py", None, raise_if_not_found=False)
assert app is None assert app is None
@ -227,7 +220,6 @@ def test_locate_app_suppress_raise(test_apps):
with pytest.raises(NoAppException): with pytest.raises(NoAppException):
locate_app("cliapp.importerrorapp", None, raise_if_not_found=False) locate_app("cliapp.importerrorapp", None, raise_if_not_found=False)
def test_get_version(test_apps, capsys): def test_get_version(test_apps, capsys):
class MockCtx: class MockCtx:
resilient_parsing = False resilient_parsing = False
@ -243,7 +235,6 @@ def test_get_version(test_apps, capsys):
assert f"Flask {importlib.metadata.version('flask')}" in out assert f"Flask {importlib.metadata.version('flask')}" in out
assert f"Werkzeug {importlib.metadata.version('werkzeug')}" in out assert f"Werkzeug {importlib.metadata.version('werkzeug')}" in out
def test_scriptinfo(test_apps, monkeypatch): def test_scriptinfo(test_apps, monkeypatch):
obj = ScriptInfo(app_import_path="cliapp.app:testapp") obj = ScriptInfo(app_import_path="cliapp.app:testapp")
app = obj.load_app() app = obj.load_app()
@ -285,7 +276,6 @@ def test_scriptinfo(test_apps, monkeypatch):
app = obj.load_app() app = obj.load_app()
assert app.name == "testapp" assert app.name == "testapp"
def test_app_cli_has_app_context(app, runner): def test_app_cli_has_app_context(app, runner):
def _param_cb(ctx, param, value): def _param_cb(ctx, param, value):
# current_app should be available in parameter callbacks # current_app should be available in parameter callbacks
@ -303,7 +293,6 @@ def test_app_cli_has_app_context(app, runner):
result = runner.invoke(cli, ["check", "x"], standalone_mode=False) result = runner.invoke(cli, ["check", "x"], standalone_mode=False)
assert result.return_value == (True, True) assert result.return_value == (True, True)
def test_with_appcontext(runner): def test_with_appcontext(runner):
@click.command() @click.command()
@with_appcontext @with_appcontext
@ -316,7 +305,6 @@ def test_with_appcontext(runner):
assert result.exit_code == 0 assert result.exit_code == 0
assert result.output == "testapp\n" assert result.output == "testapp\n"
def test_appgroup_app_context(runner): def test_appgroup_app_context(runner):
@click.group(cls=AppGroup) @click.group(cls=AppGroup)
def cli(): def cli():
@ -344,7 +332,6 @@ def test_appgroup_app_context(runner):
assert result.exit_code == 0 assert result.exit_code == 0
assert result.output == "testappgroup\n" assert result.output == "testappgroup\n"
def test_flaskgroup_app_context(runner): def test_flaskgroup_app_context(runner):
def create_app(): def create_app():
return Flask("flaskgroup") return Flask("flaskgroup")
@ -361,7 +348,6 @@ def test_flaskgroup_app_context(runner):
assert result.exit_code == 0 assert result.exit_code == 0
assert result.output == "flaskgroup\n" assert result.output == "flaskgroup\n"
@pytest.mark.parametrize("set_debug_flag", (True, False)) @pytest.mark.parametrize("set_debug_flag", (True, False))
def test_flaskgroup_debug(runner, set_debug_flag): def test_flaskgroup_debug(runner, set_debug_flag):
def create_app(): def create_app():
@ -381,7 +367,6 @@ def test_flaskgroup_debug(runner, set_debug_flag):
assert result.exit_code == 0 assert result.exit_code == 0
assert result.output == f"{not set_debug_flag}\n" assert result.output == f"{not set_debug_flag}\n"
def test_flaskgroup_nested(app, runner): def test_flaskgroup_nested(app, runner):
cli = click.Group("cli") cli = click.Group("cli")
flask_group = FlaskGroup(name="flask", create_app=lambda: app) flask_group = FlaskGroup(name="flask", create_app=lambda: app)
@ -394,7 +379,6 @@ def test_flaskgroup_nested(app, runner):
result = runner.invoke(cli, ["flask", "show"]) result = runner.invoke(cli, ["flask", "show"])
assert result.output == "flask_test\n" assert result.output == "flask_test\n"
def test_no_command_echo_loading_error(): def test_no_command_echo_loading_error():
from flask.cli import cli from flask.cli import cli
@ -409,7 +393,6 @@ def test_no_command_echo_loading_error():
assert "FLASK_APP" in result.stderr assert "FLASK_APP" in result.stderr
assert "Usage:" in result.stderr assert "Usage:" in result.stderr
def test_help_echo_loading_error(): def test_help_echo_loading_error():
from flask.cli import cli from flask.cli import cli
@ -424,7 +407,6 @@ def test_help_echo_loading_error():
assert "FLASK_APP" in result.stderr assert "FLASK_APP" in result.stderr
assert "Usage:" in result.stdout assert "Usage:" in result.stdout
def test_help_echo_exception(): def test_help_echo_exception():
def create_app(): def create_app():
raise Exception("oh no") raise Exception("oh no")
@ -442,7 +424,6 @@ def test_help_echo_exception():
assert "Exception: oh no" in result.stderr assert "Exception: oh no" in result.stderr
assert "Usage:" in result.stdout assert "Usage:" in result.stdout
class TestRoutes: class TestRoutes:
@pytest.fixture @pytest.fixture
def app(self): def app(self):
@ -517,7 +498,6 @@ class TestRoutes:
assert result.exit_code == 0 assert result.exit_code == 0
assert "Host" in result.output assert "Host" in result.output
def dotenv_not_available(): def dotenv_not_available():
try: try:
import dotenv # noqa: F401 import dotenv # noqa: F401
@ -526,12 +506,10 @@ def dotenv_not_available():
return False return False
need_dotenv = pytest.mark.skipif( need_dotenv = pytest.mark.skipif(
dotenv_not_available(), reason="dotenv is not installed" dotenv_not_available(), reason="dotenv is not installed"
) )
@need_dotenv @need_dotenv
def test_load_dotenv(monkeypatch): def test_load_dotenv(monkeypatch):
# can't use monkeypatch.delitem since the keys don't exist yet # can't use monkeypatch.delitem since the keys don't exist yet
@ -555,7 +533,6 @@ def test_load_dotenv(monkeypatch):
# Non existent file should not load # Non existent file should not load
assert not load_dotenv("non-existent-file", load_defaults=False) assert not load_dotenv("non-existent-file", load_defaults=False)
@need_dotenv @need_dotenv
def test_dotenv_path(monkeypatch): def test_dotenv_path(monkeypatch):
for item in ("FOO", "BAR", "EGGS"): for item in ("FOO", "BAR", "EGGS"):
@ -565,14 +542,12 @@ def test_dotenv_path(monkeypatch):
assert Path.cwd() == cwd assert Path.cwd() == cwd
assert "FOO" in os.environ assert "FOO" in os.environ
def test_dotenv_optional(monkeypatch): def test_dotenv_optional(monkeypatch):
monkeypatch.setitem(sys.modules, "dotenv", None) monkeypatch.setitem(sys.modules, "dotenv", None)
monkeypatch.chdir(test_path) monkeypatch.chdir(test_path)
load_dotenv() load_dotenv()
assert "FOO" not in os.environ assert "FOO" not in os.environ
@need_dotenv @need_dotenv
def test_disable_dotenv_from_env(monkeypatch, runner): def test_disable_dotenv_from_env(monkeypatch, runner):
monkeypatch.chdir(test_path) monkeypatch.chdir(test_path)
@ -580,7 +555,6 @@ def test_disable_dotenv_from_env(monkeypatch, runner):
runner.invoke(FlaskGroup()) runner.invoke(FlaskGroup())
assert "FOO" not in os.environ assert "FOO" not in os.environ
def test_run_cert_path(): def test_run_cert_path():
# no key # no key
with pytest.raises(click.BadParameter): with pytest.raises(click.BadParameter):
@ -598,7 +572,6 @@ def test_run_cert_path():
ctx = run_command.make_context("run", ["--key", __file__, "--cert", __file__]) ctx = run_command.make_context("run", ["--key", __file__, "--cert", __file__])
assert ctx.params["cert"] == (__file__, __file__) assert ctx.params["cert"] == (__file__, __file__)
def test_run_cert_adhoc(monkeypatch): def test_run_cert_adhoc(monkeypatch):
monkeypatch.setitem(sys.modules, "cryptography", None) monkeypatch.setitem(sys.modules, "cryptography", None)
@ -615,7 +588,6 @@ def test_run_cert_adhoc(monkeypatch):
with pytest.raises(click.BadParameter): with pytest.raises(click.BadParameter):
run_command.make_context("run", ["--cert", "adhoc", "--key", __file__]) run_command.make_context("run", ["--cert", "adhoc", "--key", __file__])
def test_run_cert_import(monkeypatch): def test_run_cert_import(monkeypatch):
monkeypatch.setitem(sys.modules, "not_here", None) monkeypatch.setitem(sys.modules, "not_here", None)
@ -637,14 +609,12 @@ def test_run_cert_import(monkeypatch):
with pytest.raises(click.BadParameter): with pytest.raises(click.BadParameter):
run_command.make_context("run", ["--cert", "ssl_context", "--key", __file__]) run_command.make_context("run", ["--cert", "ssl_context", "--key", __file__])
def test_run_cert_no_ssl(monkeypatch): def test_run_cert_no_ssl(monkeypatch):
monkeypatch.setitem(sys.modules, "ssl", None) monkeypatch.setitem(sys.modules, "ssl", None)
with pytest.raises(click.BadParameter): with pytest.raises(click.BadParameter):
run_command.make_context("run", ["--cert", "not_here"]) run_command.make_context("run", ["--cert", "not_here"])
def test_cli_blueprints(app): def test_cli_blueprints(app):
"""Test blueprint commands register correctly to the application""" """Test blueprint commands register correctly to the application"""
custom = Blueprint("custom", __name__, cli_group="customized") custom = Blueprint("custom", __name__, cli_group="customized")
@ -687,7 +657,6 @@ def test_cli_blueprints(app):
result = app_runner.invoke(args=["late_registration", "late"]) result = app_runner.invoke(args=["late_registration", "late"])
assert "late_result" in result.output assert "late_result" in result.output
def test_cli_empty(app): def test_cli_empty(app):
"""If a Blueprint's CLI group is empty, do not register it.""" """If a Blueprint's CLI group is empty, do not register it."""
bp = Blueprint("blue", __name__, cli_group="blue") bp = Blueprint("blue", __name__, cli_group="blue")
@ -696,7 +665,6 @@ def test_cli_empty(app):
result = app.test_cli_runner().invoke(args=["blue", "--help"]) result = app.test_cli_runner().invoke(args=["blue", "--help"])
assert result.exit_code == 2, f"Unexpected success:\n\n{result.output}" assert result.exit_code == 2, f"Unexpected success:\n\n{result.output}"
def test_run_exclude_patterns(): def test_run_exclude_patterns():
ctx = run_command.make_context("run", ["--exclude-patterns", __file__]) ctx = run_command.make_context("run", ["--exclude-patterns", __file__])
assert ctx.params["exclude_patterns"] == [__file__] assert ctx.params["exclude_patterns"] == [__file__]

18
tests/test_config.py
View file

@ -9,32 +9,27 @@ import flask
TEST_KEY = "foo" TEST_KEY = "foo"
SECRET_KEY = "config" SECRET_KEY = "config"
def common_object_test(app): def common_object_test(app):
assert app.secret_key == "config" assert app.secret_key == "config"
assert app.config["TEST_KEY"] == "foo" assert app.config["TEST_KEY"] == "foo"
assert "TestConfig" not in app.config assert "TestConfig" not in app.config
def test_config_from_pyfile(): def test_config_from_pyfile():
app = flask.Flask(__name__) app = flask.Flask(__name__)
app.config.from_pyfile(f"{__file__.rsplit('.', 1)[0]}.py") app.config.from_pyfile(f"{__file__.rsplit('.', 1)[0]}.py")
common_object_test(app) common_object_test(app)
def test_config_from_object(): def test_config_from_object():
app = flask.Flask(__name__) app = flask.Flask(__name__)
app.config.from_object(__name__) app.config.from_object(__name__)
common_object_test(app) common_object_test(app)
def test_config_from_file_json(): def test_config_from_file_json():
app = flask.Flask(__name__) app = flask.Flask(__name__)
current_dir = os.path.dirname(os.path.abspath(__file__)) current_dir = os.path.dirname(os.path.abspath(__file__))
app.config.from_file(os.path.join(current_dir, "static", "config.json"), json.load) app.config.from_file(os.path.join(current_dir, "static", "config.json"), json.load)
common_object_test(app) common_object_test(app)
def test_config_from_file_toml(): def test_config_from_file_toml():
tomllib = pytest.importorskip("tomllib", reason="tomllib added in 3.11") tomllib = pytest.importorskip("tomllib", reason="tomllib added in 3.11")
app = flask.Flask(__name__) app = flask.Flask(__name__)
@ -44,7 +39,6 @@ def test_config_from_file_toml():
) )
common_object_test(app) common_object_test(app)
def test_from_prefixed_env(monkeypatch): def test_from_prefixed_env(monkeypatch):
monkeypatch.setenv("FLASK_STRING", "value") monkeypatch.setenv("FLASK_STRING", "value")
monkeypatch.setenv("FLASK_BOOL", "true") monkeypatch.setenv("FLASK_BOOL", "true")
@ -65,7 +59,6 @@ def test_from_prefixed_env(monkeypatch):
assert app.config["DICT"] == {"k": "v"} assert app.config["DICT"] == {"k": "v"}
assert "OTHER" not in app.config assert "OTHER" not in app.config
def test_from_prefixed_env_custom_prefix(monkeypatch): def test_from_prefixed_env_custom_prefix(monkeypatch):
monkeypatch.setenv("FLASK_A", "a") monkeypatch.setenv("FLASK_A", "a")
monkeypatch.setenv("NOT_FLASK_A", "b") monkeypatch.setenv("NOT_FLASK_A", "b")
@ -75,7 +68,6 @@ def test_from_prefixed_env_custom_prefix(monkeypatch):
assert app.config["A"] == "b" assert app.config["A"] == "b"
def test_from_prefixed_env_nested(monkeypatch): def test_from_prefixed_env_nested(monkeypatch):
monkeypatch.setenv("FLASK_EXIST__ok", "other") monkeypatch.setenv("FLASK_EXIST__ok", "other")
monkeypatch.setenv("FLASK_EXIST__inner__ik", "2") monkeypatch.setenv("FLASK_EXIST__inner__ik", "2")
@ -106,7 +98,6 @@ def test_from_prefixed_env_nested(monkeypatch):
assert app.config["NEW"] == {"K": "v"} assert app.config["NEW"] == {"K": "v"}
def test_config_from_mapping(): def test_config_from_mapping():
app = flask.Flask(__name__) app = flask.Flask(__name__)
app.config.from_mapping({"SECRET_KEY": "config", "TEST_KEY": "foo"}) app.config.from_mapping({"SECRET_KEY": "config", "TEST_KEY": "foo"})
@ -128,7 +119,6 @@ def test_config_from_mapping():
with pytest.raises(TypeError): with pytest.raises(TypeError):
app.config.from_mapping({}, {}) app.config.from_mapping({}, {})
def test_config_from_class(): def test_config_from_class():
class Base: class Base:
TEST_KEY = "foo" TEST_KEY = "foo"
@ -140,7 +130,6 @@ def test_config_from_class():
app.config.from_object(Test) app.config.from_object(Test)
common_object_test(app) common_object_test(app)
def test_config_from_envvar(monkeypatch): def test_config_from_envvar(monkeypatch):
monkeypatch.setattr("os.environ", {}) monkeypatch.setattr("os.environ", {})
app = flask.Flask(__name__) app = flask.Flask(__name__)
@ -157,7 +146,6 @@ def test_config_from_envvar(monkeypatch):
assert app.config.from_envvar("FOO_SETTINGS") assert app.config.from_envvar("FOO_SETTINGS")
common_object_test(app) common_object_test(app)
def test_config_from_envvar_missing(monkeypatch): def test_config_from_envvar_missing(monkeypatch):
monkeypatch.setattr("os.environ", {"FOO_SETTINGS": "missing.cfg"}) monkeypatch.setattr("os.environ", {"FOO_SETTINGS": "missing.cfg"})
app = flask.Flask(__name__) app = flask.Flask(__name__)
@ -170,7 +158,6 @@ def test_config_from_envvar_missing(monkeypatch):
assert msg.endswith("missing.cfg'") assert msg.endswith("missing.cfg'")
assert not app.config.from_envvar("FOO_SETTINGS", silent=True) assert not app.config.from_envvar("FOO_SETTINGS", silent=True)
def test_config_missing(): def test_config_missing():
app = flask.Flask(__name__) app = flask.Flask(__name__)
with pytest.raises(IOError) as e: with pytest.raises(IOError) as e:
@ -182,7 +169,6 @@ def test_config_missing():
assert msg.endswith("missing.cfg'") assert msg.endswith("missing.cfg'")
assert not app.config.from_pyfile("missing.cfg", silent=True) assert not app.config.from_pyfile("missing.cfg", silent=True)
def test_config_missing_file(): def test_config_missing_file():
app = flask.Flask(__name__) app = flask.Flask(__name__)
with pytest.raises(IOError) as e: with pytest.raises(IOError) as e:
@ -194,7 +180,6 @@ def test_config_missing_file():
assert msg.endswith("missing.json'") assert msg.endswith("missing.json'")
assert not app.config.from_file("missing.json", load=json.load, silent=True) assert not app.config.from_file("missing.json", load=json.load, silent=True)
def test_custom_config_class(): def test_custom_config_class():
class Config(flask.Config): class Config(flask.Config):
pass pass
@ -207,13 +192,11 @@ def test_custom_config_class():
app.config.from_object(__name__) app.config.from_object(__name__)
common_object_test(app) common_object_test(app)
def test_session_lifetime(): def test_session_lifetime():
app = flask.Flask(__name__) app = flask.Flask(__name__)
app.config["PERMANENT_SESSION_LIFETIME"] = 42 app.config["PERMANENT_SESSION_LIFETIME"] = 42
assert app.permanent_session_lifetime.seconds == 42 assert app.permanent_session_lifetime.seconds == 42
def test_get_namespace(): def test_get_namespace():
app = flask.Flask(__name__) app = flask.Flask(__name__)
app.config["FOO_OPTION_1"] = "foo option 1" app.config["FOO_OPTION_1"] = "foo option 1"
@ -239,7 +222,6 @@ def test_get_namespace():
assert "bar stuff 1" == bar_options["BAR_STUFF_1"] assert "bar stuff 1" == bar_options["BAR_STUFF_1"]
assert "bar stuff 2" == bar_options["BAR_STUFF_2"] assert "bar stuff 2" == bar_options["BAR_STUFF_2"]
@pytest.mark.parametrize("encoding", ["utf-8", "iso-8859-15", "latin-1"]) @pytest.mark.parametrize("encoding", ["utf-8", "iso-8859-15", "latin-1"])
def test_from_pyfile_weird_encoding(tmp_path, encoding): def test_from_pyfile_weird_encoding(tmp_path, encoding):
f = tmp_path / "my_config.py" f = tmp_path / "my_config.py"