Use f-strings instead of str.format() (#1793)

tests/conftest.py

@@ -103,7 +103,7 @@ def _setup(route_details: tuple) -> (Router, tuple):
         for method, route in route_details:
             try:
                 router._add(
-                    uri="/{}".format(route),
+                    uri=f"/{route}",
                     methods=frozenset({method}),
                     host="localhost",
                     handler=_handler,

tests/test_app.py

@@ -179,9 +179,7 @@ def handler(request):
     request, response = app.test_client.get("/", debug=True)
     assert response.status == 500
     assert response.text.startswith(
-        "Error while handling error: {}\nStack: Traceback (most recent call last):\n".format(
-            err_msg
-        )
+        f"Error while handling error: {err_msg}\nStack: Traceback (most recent call last):\n"
     )
 
 

tests/test_blueprint_group.py

@@ -40,9 +40,9 @@ def blueprint_1_v2_method_with_put_and_post(request: Request):
     )
     def blueprint_2_named_method(request: Request, param):
         if request.method == "DELETE":
-            return text("DELETE_{}".format(param))
+            return text(f"DELETE_{param}")
         elif request.method == "PATCH":
-            return text("PATCH_{}".format(param))
+            return text(f"PATCH_{param}")
 
     blueprint_group = Blueprint.group(
         blueprint_1, blueprint_2, url_prefix="/api"

tests/test_blueprints.py

@@ -46,19 +46,19 @@ def test_versioned_routes_get(app, method):
     func = getattr(bp, method)
     if callable(func):
 
-        @func("/{}".format(method), version=1)
+        @func(f"/{method}", version=1)
         def handler(request):
             return text("OK")
 
     else:
         print(func)
-        raise Exception("{} is not callable".format(func))
+        raise Exception(f"{func} is not callable")
 
     app.blueprint(bp)
 
     client_method = getattr(app.test_client, method)
 
-    request, response = client_method("/v1/{}".format(method))
+    request, response = client_method(f"/v1/{method}")
     assert response.status == 200
 
 
@@ -554,7 +554,7 @@ def api_v1_info(request):
 
     resource_id = str(uuid4())
     request, response = app.test_client.get(
-        "/api/v1/resources/{0}".format(resource_id)
+        f"/api/v1/resources/{resource_id}"
     )
     assert response.json == {"resource_id": resource_id}
 
@@ -669,9 +669,9 @@ def test_duplicate_blueprint(app):
         app.blueprint(bp1)
 
     assert str(excinfo.value) == (
-        'A blueprint with the name "{}" is already registered.  '
+        f'A blueprint with the name "{bp_name}" is already registered.  '
         "Blueprint names must be unique."
-    ).format(bp_name)
+    )
 
 
 @pytest.mark.parametrize("debug", [True, False, None])

tests/test_cookies.py

@@ -15,7 +15,8 @@
 def test_cookies(app):
     @app.route("/")
     def handler(request):
-        response = text("Cookies are: {}".format(request.cookies["test"]))
+        cookie_value = request.cookies["test"]
+        response = text(f"Cookies are: {cookie_value}")
         response.cookies["right_back"] = "at you"
         return response
 
@@ -31,7 +32,8 @@ def handler(request):
 async def test_cookies_asgi(app):
     @app.route("/")
     def handler(request):
-        response = text("Cookies are: {}".format(request.cookies["test"]))
+        cookie_value = request.cookies["test"]
+        response = text(f"Cookies are: {cookie_value}")
         response.cookies["right_back"] = "at you"
         return response
 
@@ -78,7 +80,8 @@ def handler(request):
 def test_http2_cookies(app):
     @app.route("/")
     async def handler(request):
-        response = text("Cookies are: {}".format(request.cookies["test"]))
+        cookie_value = request.cookies["test"]
+        response = text(f"Cookies are: {cookie_value}")
         return response
 
     headers = {"cookie": "test=working!"}

tests/test_exceptions_handler.py

@@ -43,7 +43,7 @@ def handler_6(request, arg):
     try:
         foo = 1 / arg
     except Exception as e:
-        raise e from ValueError("{}".format(arg))
+        raise e from ValueError(f"{arg}")
     return text(foo)
 
 

tests/test_keep_alive_timeout.py

@@ -97,11 +97,9 @@ def _collect_request(request):
         ):
             url = uri
         else:
-            uri = uri if uri.startswith("/") else "/{uri}".format(uri=uri)
+            uri = uri if uri.startswith("/") else f"/{uri}"
             scheme = "http"
-            url = "{scheme}://{host}:{port}{uri}".format(
-                scheme=scheme, host=HOST, port=PORT, uri=uri
-            )
+            url = f"{scheme}://{HOST}:{PORT}{uri}"
 
         @self.app.listener("after_server_start")
         async def _collect_response(loop):
@@ -134,7 +132,7 @@ async def _collect_response(loop):
         self.app.listeners["after_server_start"].pop()
 
         if exceptions:
-            raise ValueError("Exception during request: {}".format(exceptions))
+            raise ValueError(f"Exception during request: {exceptions}")
 
         if gather_request:
             self.app.request_middleware.pop()
@@ -143,16 +141,14 @@ async def _collect_response(loop):
                 return request, response
             except Exception:
                 raise ValueError(
-                    "Request and response object expected, got ({})".format(
-                        results
-                    )
+                    f"Request and response object expected, got ({results})"
                 )
         else:
             try:
                 return results[-1]
             except Exception:
                 raise ValueError(
-                    "Request object expected, got ({})".format(results)
+                    f"Request object expected, got ({results})"
                 )
 
     def kill_server(self):

tests/test_logo.py

@@ -52,7 +52,7 @@ def test_logo_false(app, caplog):
     assert caplog.record_tuples[ROW][1] == logging.INFO
     assert caplog.record_tuples[ROW][
         2
-    ] == "Goin' Fast @ http://127.0.0.1:{}".format(PORT)
+    ] == f"Goin' Fast @ http://127.0.0.1:{PORT}"
 
 
 def test_logo_true(app, caplog):

tests/test_named_routes.py

@@ -21,13 +21,13 @@ def test_versioned_named_routes_get(app, method):
     bp = Blueprint("test_bp", url_prefix="/bp")
 
     method = method.lower()
-    route_name = "route_{}".format(method)
-    route_name2 = "route2_{}".format(method)
+    route_name = f"route_{method}"
+    route_name2 = f"route2_{method}"
 
     func = getattr(app, method)
     if callable(func):
 
-        @func("/{}".format(method), version=1, name=route_name)
+        @func(f"/{method}", version=1, name=route_name)
         def handler(request):
             return text("OK")
 
@@ -38,7 +38,7 @@ def handler(request):
     func = getattr(bp, method)
     if callable(func):
 
-        @func("/{}".format(method), version=1, name=route_name2)
+        @func(f"/{method}", version=1, name=route_name2)
         def handler2(request):
             return text("OK")
 
@@ -48,14 +48,14 @@ def handler2(request):
 
     app.blueprint(bp)
 
-    assert app.router.routes_all["/v1/{}".format(method)].name == route_name
+    assert app.router.routes_all[f"/v1/{method}"].name == route_name
 
-    route = app.router.routes_all["/v1/bp/{}".format(method)]
-    assert route.name == "test_bp.{}".format(route_name2)
+    route = app.router.routes_all[f"/v1/bp/{method}"]
+    assert route.name == f"test_bp.{route_name2}"
 
-    assert app.url_for(route_name) == "/v1/{}".format(method)
-    url = app.url_for("test_bp.{}".format(route_name2))
-    assert url == "/v1/bp/{}".format(method)
+    assert app.url_for(route_name) == f"/v1/{method}"
+    url = app.url_for(f"test_bp.{route_name2}")
+    assert url == f"/v1/bp/{method}"
     with pytest.raises(URLBuildError):
         app.url_for("handler")
 

tests/test_redirect.py

@@ -115,14 +115,14 @@ def test_redirect_with_params(app, test_str):
 
     @app.route("/api/v1/test/<test>/")
     async def init_handler(request, test):
-        return redirect("/api/v2/test/{}/".format(use_in_uri))
+        return redirect(f"/api/v2/test/{use_in_uri}/")
 
     @app.route("/api/v2/test/<test>/")
     async def target_handler(request, test):
         assert test == test_str
         return text("OK")
 
-    _, response = app.test_client.get("/api/v1/test/{}/".format(use_in_uri))
+    _, response = app.test_client.get(f"/api/v1/test/{use_in_uri}/")
     assert response.status == 200
 
     assert response.content == b"OK"

tests/test_requests.py

@@ -44,7 +44,7 @@ def handler(request):
 def test_ip(app):
     @app.route("/")
     def handler(request):
-        return text("{}".format(request.ip))
+        return text(f"{request.ip}")
 
     request, response = app.test_client.get("/")
 
@@ -55,7 +55,7 @@ def handler(request):
 async def test_ip_asgi(app):
     @app.route("/")
     def handler(request):
-        return text("{}".format(request.url))
+        return text(f"{request.url}")
 
     request, response = await app.asgi_client.get("/")
 
@@ -325,7 +325,7 @@ async def handler(request):
     token = "a1d895e0-553a-421a-8e22-5ff8ecb48cbf"
     headers = {
         "content-type": "application/json",
-        "Authorization": "{}".format(token),
+        "Authorization": f"{token}",
     }
 
     request, response = app.test_client.get("/", headers=headers)
@@ -335,7 +335,7 @@ async def handler(request):
     token = "a1d895e0-553a-421a-8e22-5ff8ecb48cbf"
     headers = {
         "content-type": "application/json",
-        "Authorization": "Token {}".format(token),
+        "Authorization": f"Token {token}",
     }
 
     request, response = app.test_client.get("/", headers=headers)
@@ -345,7 +345,7 @@ async def handler(request):
     token = "a1d895e0-553a-421a-8e22-5ff8ecb48cbf"
     headers = {
         "content-type": "application/json",
-        "Authorization": "Bearer {}".format(token),
+        "Authorization": f"Bearer {token}",
     }
 
     request, response = app.test_client.get("/", headers=headers)
@@ -370,7 +370,7 @@ async def handler(request):
     token = "a1d895e0-553a-421a-8e22-5ff8ecb48cbf"
     headers = {
         "content-type": "application/json",
-        "Authorization": "{}".format(token),
+        "Authorization": f"{token}",
     }
 
     request, response = await app.asgi_client.get("/", headers=headers)
@@ -380,7 +380,7 @@ async def handler(request):
     token = "a1d895e0-553a-421a-8e22-5ff8ecb48cbf"
     headers = {
         "content-type": "application/json",
-        "Authorization": "Token {}".format(token),
+        "Authorization": f"Token {token}",
     }
 
     request, response = await app.asgi_client.get("/", headers=headers)
@@ -390,7 +390,7 @@ async def handler(request):
     token = "a1d895e0-553a-421a-8e22-5ff8ecb48cbf"
     headers = {
         "content-type": "application/json",
-        "Authorization": "Bearer {}".format(token),
+        "Authorization": f"Bearer {token}",
     }
 
     request, response = await app.asgi_client.get("/", headers=headers)
@@ -1028,7 +1028,7 @@ async def handler(request):
 
     app.add_route(handler, path)
 
-    request, response = app.test_client.get(path + "?{}".format(query))
+    request, response = app.test_client.get(path + f"?{query}")
     assert request.url == expected_url.format(HOST, PORT)
 
     parsed = urlparse(request.url)
@@ -1054,7 +1054,7 @@ async def handler(request):
 
     app.add_route(handler, path)
 
-    request, response = await app.asgi_client.get(path + "?{}".format(query))
+    request, response = await app.asgi_client.get(path + f"?{query}")
     assert request.url == expected_url.format(ASGI_HOST)
 
     parsed = urlparse(request.url)
@@ -1087,7 +1087,7 @@ async def handler(request):
     app.add_route(handler, path)
 
     request, response = app.test_client.get(
-        "https://{}:{}".format(HOST, PORT) + path + "?{}".format(query),
+        f"https://{HOST}:{PORT}" + path + f"?{query}",
         server_kwargs={"ssl": context},
     )
     assert request.url == expected_url.format(HOST, PORT)
@@ -1122,7 +1122,7 @@ async def handler(request):
     app.add_route(handler, path)
 
     request, response = app.test_client.get(
-        "https://{}:{}".format(HOST, PORT) + path + "?{}".format(query),
+        f"https://{HOST}:{PORT}" + path + f"?{query}",
         server_kwargs={"ssl": ssl_dict},
     )
     assert request.url == expected_url.format(HOST, PORT)