adding tests for async background callbacks

Author: BSd3v

tests/integration/async_tests/__init__.py

@@ -0,0 +1,31 @@
+from dash import Dash, Input, Output, dcc, html
+import time
+
+from tests.integration.background_callback.utils import get_background_callback_manager
+
+background_callback_manager = get_background_callback_manager()
+handle = background_callback_manager.handle
+
+app = Dash(__name__)
+app.layout = html.Div(
+    [
+        dcc.Input(id="input", value="initial value"),
+        html.Div(html.Div([1.5, None, "string", html.Div(id="output-1")])),
+    ]
+)
+
+
+@app.callback(
+    Output("output-1", "children"),
+    [Input("input", "value")],
+    interval=500,
+    manager=background_callback_manager,
+    background=True,
+)
+async def update_output(value):
+    time.sleep(0.1)
+    return value
+
+
+if __name__ == "__main__":
+    app.run(debug=True)

tests/integration/async_tests/app1_async.py

@@ -0,0 +1,50 @@
+from dash import Dash, Input, Output, html, callback, set_props
+import time
+
+from tests.integration.background_callback.utils import get_background_callback_manager
+
+background_callback_manager = get_background_callback_manager()
+handle = background_callback_manager.handle
+
+app = Dash(__name__, background_callback_manager=background_callback_manager)
+app.test_lock = lock = background_callback_manager.test_lock
+
+app.layout = html.Div(
+    [
+        html.Button("start", id="start"),
+        html.Div(id="secondary"),
+        html.Div(id="no-output"),
+        html.Div("initial", id="output"),
+        html.Button("start-no-output", id="start-no-output"),
+    ]
+)
+
+
+@callback(
+    Output("output", "children"),
+    Input("start", "n_clicks"),
+    prevent_initial_call=True,
+    background=True,
+    interval=500,
+)
+async def on_click(_):
+    set_props("secondary", {"children": "first"})
+    set_props("secondary", {"style": {"background": "red"}})
+    time.sleep(2)
+    set_props("secondary", {"children": "second"})
+    return "completed"
+
+
+@callback(
+    Input("start-no-output", "n_clicks"),
+    prevent_initial_call=True,
+    background=True,
+)
+async def on_click(_):
+    set_props("no-output", {"children": "started"})
+    time.sleep(2)
+    set_props("no-output", {"children": "completed"})
+
+
+if __name__ == "__main__":
+    app.run(debug=True)

tests/integration/async_tests/app_arbitrary_async.py

@@ -0,0 +1,15 @@
+import os
+
+import pytest
+
+
+if "REDIS_URL" in os.environ:
+    managers = ["celery", "diskcache"]
+else:
+    print("Skipping celery tests because REDIS_URL is not defined")
+    managers = ["diskcache"]
+
+
+@pytest.fixture(params=managers)
+def manager(request):
+    return request.param

tests/integration/async_tests/conftest.py

@@ -0,0 +1,57 @@
+import sys
+
+import pytest
+from flaky import flaky
+from multiprocessing import Lock
+from tests.integration.async_tests.utils import setup_background_callback_app
+import time
+
+def test_001ab_arbitrary(dash_duo, manager):
+    with setup_background_callback_app(manager, "app_arbitrary_async") as app:
+        dash_duo.start_server(app)
+
+        dash_duo.wait_for_text_to_equal("#output", "initial")
+        # pause for sync
+        time.sleep(.2)
+        dash_duo.find_element("#start").click()
+
+        dash_duo.wait_for_text_to_equal("#secondary", "first")
+        dash_duo.wait_for_style_to_equal(
+            "#secondary", "background-color", "rgba(255, 0, 0, 1)"
+        )
+        dash_duo.wait_for_text_to_equal("#output", "initial")
+        dash_duo.wait_for_text_to_equal("#secondary", "second")
+        dash_duo.wait_for_text_to_equal("#output", "completed")
+
+        dash_duo.find_element("#start-no-output").click()
+
+        dash_duo.wait_for_text_to_equal("#no-output", "started")
+        dash_duo.wait_for_text_to_equal("#no-output", "completed")
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 7), reason="Python 3.6 long callbacks tests hangs up"
+)
+@flaky(max_runs=3)
+def test_002ab_basic(dash_duo, manager):
+    """
+    Make sure that we settle to the correct final value when handling rapid inputs
+    """
+    lock = Lock()
+    with setup_background_callback_app(manager, "app1_async") as app:
+        dash_duo.start_server(app)
+        dash_duo.wait_for_text_to_equal("#output-1", "initial value", 15)
+        input_ = dash_duo.find_element("#input")
+        # pause for sync
+        time.sleep(.2)
+        dash_duo.clear_input(input_)
+
+        for key in "hello world":
+            with lock:
+                input_.send_keys(key)
+
+        dash_duo.wait_for_text_to_equal("#output-1", "hello world", 8)
+
+    assert not dash_duo.redux_state_is_loading
+    assert dash_duo.get_logs() == []
+

tests/integration/async_tests/test_async_background_callbacks.py

@@ -28,7 +28,7 @@
 from tests.utils import test_async
 
 
-def test_async_cbsc001_simple_callback(dash_duo):
+def test_async_cbsc001_simple_callback(dash_duo, *args):
     if not test_async():
         return
     lock = Lock()
@@ -68,7 +68,7 @@ async def update_output(value):
     assert dash_duo.get_logs() == []
 
 
-def test_async_cbsc002_callbacks_generating_children(dash_duo):
+def test_async_cbsc002_callbacks_generating_children(dash_duo, *args):
     """Modify the DOM tree by adding new components in the callbacks."""
     if not test_async():
         return
@@ -154,7 +154,7 @@ async def update_input(value):
     assert dash_duo.get_logs() == [], "console is clean"
 
 
-def test_async_cbsc003_callback_with_unloaded_async_component(dash_duo):
+def test_async_cbsc003_callback_with_unloaded_async_component(dash_duo, *args):
     if not test_async():
         return
     app = Dash()
@@ -189,7 +189,7 @@ async def update_out(n_clicks):
     assert dash_duo.get_logs() == []
 
 
-def test_async_cbsc004_callback_using_unloaded_async_component(dash_duo):
+def test_async_cbsc004_callback_using_unloaded_async_component(dash_duo, *args):
     if not test_async():
         return
     app = Dash()
@@ -322,7 +322,7 @@ async def set_out(opts):
     strict=False,
 )
 @pytest.mark.parametrize("refresh", [False, True])
-def test_async_cbsc007_parallel_updates(refresh, dash_duo):
+def test_async_cbsc007_parallel_updates(refresh, dash_duo, *args):
     # This is a funny case, that seems to mostly happen with dcc.Location
     # but in principle could happen in other cases too:
     # A callback chain (in this case the initial hydration) is set to update a
@@ -377,7 +377,7 @@ async def set_path(n):
         dash_duo.wait_for_text_to_equal("#out", '[{"a": "/2:a"}] - /2')
 
 
-def test_async_cbsc008_wildcard_prop_callbacks(dash_duo):
+def test_async_cbsc008_wildcard_prop_callbacks(dash_duo, *args):
     if not test_async():
         return
     lock = Lock()
@@ -444,7 +444,7 @@ async def update_text(data):
     assert dash_duo.get_logs() == []
 
 
-def test_async_cbsc009_callback_using_unloaded_async_component_and_graph(dash_duo):
+def test_async_cbsc009_callback_using_unloaded_async_component_and_graph(dash_duo, *args):
     if not test_async():
         return
     app = Dash(__name__)
@@ -489,7 +489,7 @@ async def content(n, d, v):
     assert dash_duo.get_logs() == []
 
 
-def test_async_cbsc010_event_properties(dash_duo):
+def test_async_cbsc010_event_properties(dash_duo, *args):
     if not test_async():
         return
     app = Dash(__name__)
@@ -513,7 +513,7 @@ async def update_output(n_clicks):
     assert call_count.value == 1
 
 
-def test_async_cbsc011_one_call_for_multiple_outputs_initial(dash_duo):
+def test_async_cbsc011_one_call_for_multiple_outputs_initial(dash_duo, *args):
     if not test_async():
         return
     app = Dash(__name__)
@@ -551,7 +551,7 @@ async def dynamic_output(*args):
     assert dash_duo.get_logs() == []
 
 
-def test_async_cbsc012_one_call_for_multiple_outputs_update(dash_duo):
+def test_async_cbsc012_one_call_for_multiple_outputs_update(dash_duo, *args):
     if not test_async():
         return
     app = Dash(__name__, suppress_callback_exceptions=True)
@@ -603,7 +603,7 @@ async def dynamic_output(*args):
     assert dash_duo.get_logs() == []
 
 
-def test_async_cbsc013_multi_output_out_of_order(dash_duo):
+def test_async_cbsc013_multi_output_out_of_order(dash_duo, *args):
     if not test_async():
         return
     app = Dash(__name__)
@@ -704,7 +704,7 @@ async def update_output(n1, t1, n2, t2):
     assert call_count.value == 4
 
 
-def test_async_cbsc015_input_output_callback(dash_duo):
+def test_async_cbsc015_input_output_callback(dash_duo, *args):
     if not test_async():
         return
     return
@@ -757,7 +757,7 @@ def test_async_cbsc015_input_output_callback(dash_duo):
     # assert dash_duo.get_logs() == []
 
 
-def test_async_cbsc016_extra_components_callback(dash_duo):
+def test_async_cbsc016_extra_components_callback(dash_duo, *args):
     if not test_async():
         return
     lock = Lock()
@@ -818,7 +818,7 @@ def test_async_cbsc017_callback_directly_callable():
     # assert update_output("my-value") == "returning my-value"
 
 
-def test_async_cbsc018_callback_ndarray_output(dash_duo):
+def test_async_cbsc018_callback_ndarray_output(dash_duo, *args):
     if not test_async():
         return
     app = Dash(__name__)
@@ -836,7 +836,7 @@ async def on_click(_):
     assert dash_duo.get_logs() == []
 
 
-def test_async_cbsc019_callback_running(dash_duo):
+def test_async_cbsc019_callback_running(dash_duo, *args):
     if not test_async():
         return
     lock = Lock()
@@ -870,7 +870,7 @@ async def on_click(_):
     dash_duo.wait_for_text_to_equal("#running", "off")
 
 
-def test_async_cbsc020_callback_running_non_existing_component(dash_duo):
+def test_async_cbsc020_callback_running_non_existing_component(dash_duo, *args):
     if not test_async():
         return
     lock = Lock()
@@ -907,7 +907,7 @@ async def on_click(_):
     dash_duo.wait_for_text_to_equal("#output", "done")
 
 
-def test_async_cbsc021_callback_running_non_existing_component(dash_duo):
+def test_async_cbsc021_callback_running_non_existing_component(dash_duo, *args):
     if not test_async():
         return
     lock = Lock()