added test for request_hooks, removed null check bug for existing hooks

Author: yujin-wu

dash/dash-renderer/src/actions/api.js

@@ -66,7 +66,6 @@ export default function apiThunk(endpoint, method, store, id, body) {
                 }
 
                 if (res.status === STATUS.UNAUTHORIZED) {
-                    console.log(getState());
                     if (hooks.request_refresh_jwt) {
                         const body = await res.text();
                         if (body.includes(JWT_EXPIRED_MESSAGE)) {

dash/dash-renderer/src/actions/callbacks.ts

@@ -308,7 +308,7 @@ function handleServerside(
     config: any,
     payload: any
 ): Promise<any> {
-    if (hooks.request_pre !== null) {
+    if (hooks.request_pre) {
         hooks.request_pre(payload);
     }
 
@@ -366,7 +366,7 @@ function handleServerside(
             if (status === STATUS.OK) {
                 return res.json().then((data: any) => {
                     const {multi, response} = data;
-                    if (hooks.request_post !== null) {
+                    if (hooks.request_post) {
                         hooks.request_post(payload, response);
                     }
 
@@ -520,9 +520,9 @@ export function executeCallback(
 
                 let newConfig = config;
                 let newHeaders: Record<string, string> | null = null;
-                let retry = 0;
+                let lastError: any;
 
-                while (true) {
+                for (let retry = 0; retry <= MAX_AUTH_RETRIES; retry++) {
                     try {
                         const data = await handleServerside(
                             dispatch,
@@ -537,8 +537,7 @@ export function executeCallback(
 
                         return {data, payload};
                     } catch (res) {
-                        retry++;
-
+                        lastError = res;
                         if (
                             retry <= MAX_AUTH_RETRIES &&
                             res.status === STATUS.UNAUTHORIZED
@@ -548,12 +547,16 @@ export function executeCallback(
                             if (body.includes(JWT_EXPIRED_MESSAGE)) {
                                 // From dash embedded
                                 if (hooks.request_refresh_jwt !== null) {
-                                    const newJwt =
-                                        await hooks.request_refresh_jwt(
+                                    let oldJwt = null;
+                                    if (config.fetch.headers.Authorization) {
+                                        oldJwt =
                                             config.fetch.headers.Authorization.substr(
                                                 'Bearer '.length
-                                            )
-                                        );
+                                            );
+                                    }
+
+                                    const newJwt =
+                                        await hooks.request_refresh_jwt(oldJwt);
                                     if (newJwt) {
                                         newHeaders = {
                                             Authorization: `Bearer ${newJwt}`
@@ -571,10 +574,12 @@ export function executeCallback(
                             }
                         }
 
-                        // here, it is an error we're not supposed to retry.
-                        throw res;
+                        break;
                     }
                 }
+
+                // we reach here when we run out of retries.
+                return {error: lastError, payload: null};
             } catch (error) {
                 return {error, payload: null};
             }

tests/integration/renderer/test_request_hooks.py

@@ -1,6 +1,9 @@
 import json
+import functools
+import flask
 
 from dash import Dash, Output, Input, html, dcc
+from werkzeug.exceptions import HTTPException
 
 
 def test_rdrh001_request_hooks(dash_duo):
@@ -185,3 +188,108 @@ def update_output(value):
     assert dash_duo.find_element("#output-post").text == "request_post!!!"
 
     dash_duo.percy_snapshot(name="request-hooks interpolated")
+
+def test_rdrh003_refresh_jwt(dash_duo):
+
+    app = Dash(__name__)
+
+    app.index_string = """<!DOCTYPE html>
+    <html>
+        <head>
+            {%metas%}
+            <title>{%title%}</title>
+            {%favicon%}
+            {%css%}
+        </head>
+        <body>
+            <div>Testing custom DashRenderer</div>
+            {%app_entry%}
+            <footer>
+                {%config%}
+                {%scripts%}
+                <script id="_dash-renderer" type"application/json">
+                    const renderer = new DashRenderer({
+                        request_refresh_jwt: (old_token) => {
+                            console.log("refreshing token", old_token);
+                            var new_token = "." + (old_token || "");
+                            var output = document.getElementById('output-token')
+                            if(output) {
+                                output.innerHTML = new_token;
+                            }
+                            return new_token;
+                        }
+                    })
+                </script>
+            </footer>
+            <div>With request hooks</div>
+        </body>
+    </html>"""
+
+
+    app.layout = html.Div(
+        [
+            dcc.Input(id="input", value="initial value"),
+            html.Div(
+                html.Div(
+                    [
+                        html.Div(id="output-1"),
+                        html.Div(id="output-token")
+                    ]
+                )
+            ),
+        ]
+    )
+
+    @app.callback(Output("output-1", "children"), [Input("input", "value")])
+    def update_output(value):
+        return value
+
+    required_jwt_len = 0
+
+    # test with an auth layer that requires a JWT with a certain length
+    def protect_route(func):
+        @functools.wraps(func)
+        def wrap(*args, **kwargs):
+            try:
+                if flask.request.method == 'OPTIONS':
+                    return func(*args, **kwargs)
+                token = flask.request.authorization or flask.request.headers.environ.get(
+                    "HTTP_AUTHORIZATION"
+                )
+                if required_jwt_len and (not token or len(token) != required_jwt_len + len('Bearer ')):
+                    flask.abort(401, description="JWT Expired " + str(token))
+            except HTTPException as e:
+                return e
+            return func(*args, **kwargs)
+        return wrap
+
+
+    # wrap all API calls with auth.
+    for name, method in (
+        (x, app.server.view_functions[x])
+        for x in app.routes
+        if x in app.server.view_functions
+    ):
+        app.server.view_functions[name] = protect_route(method)
+
+    dash_duo.start_server(app)
+
+    _in = dash_duo.find_element("#input")
+    dash_duo.clear_input(_in)
+
+    required_jwt_len = 1
+
+    _in.send_keys("fired request")
+
+    dash_duo.wait_for_text_to_equal("#output-1", "fired request")
+    dash_duo.wait_for_text_to_equal("#output-token", ".")
+
+    required_jwt_len = 2
+
+    dash_duo.clear_input(_in)
+    _in.send_keys("fired request again")
+
+    dash_duo.wait_for_text_to_equal("#output-1", "fired request again")
+    dash_duo.wait_for_text_to_equal("#output-token", "..")
+
+    dash_duo.percy_snapshot(name="request-hooks jwt-refresh")