test that fail_callback_output always throws the right kind of error

rather than a built-in error because it had its own problem!

Author: alexcjohnson

dash/_validate.py

@@ -1,11 +1,11 @@
-import collections
+from collections.abc import MutableSequence
 import re
 from textwrap import dedent
 
 from ._grouping import grouping_len, map_grouping
 from .development.base_component import Component
 from . import exceptions
-from ._utils import patch_collections_abc, stringify_id
+from ._utils import patch_collections_abc, stringify_id, to_json
 
 
 def validate_callback(outputs, inputs, state, extra_args, types):
@@ -198,7 +198,8 @@ def validate_multi_return(outputs_list, output_value, callback_id):
 
 
 def fail_callback_output(output_value, output):
-    valid = (str, dict, int, float, type(None), Component)
+    valid_children = (str, int, float, type(None), Component)
+    valid_props = (str, int, float, type(None), tuple, MutableSequence)
 
     def _raise_invalid(bad_val, outer_val, path, index=None, toplevel=False):
         bad_type = type(bad_val).__name__
@@ -247,43 +248,74 @@ def _raise_invalid(bad_val, outer_val, path, index=None, toplevel=False):
             )
         )
 
-    def _value_is_valid(val):
-        return isinstance(val, valid)
+    def _valid_child(val):
+        return isinstance(val, valid_children)
+
+    def _valid_prop(val):
+        return isinstance(val, valid_props)
+
+    def _can_serialize(val):
+        if not (_valid_child(val) or _valid_prop(val)):
+            return False
+        try:
+            to_json(val)
+        except TypeError:
+            return False
+        return True
 
     def _validate_value(val, index=None):
         # val is a Component
         if isinstance(val, Component):
+            unserializable_items = []
             # pylint: disable=protected-access
             for p, j in val._traverse_with_paths():
                 # check each component value in the tree
-                if not _value_is_valid(j):
+                if not _valid_child(j):
                     _raise_invalid(bad_val=j, outer_val=val, path=p, index=index)
 
+                if not _can_serialize(j):
+                    # collect unserializable items separately, so we can report
+                    # only the deepest level, not all the parent components that
+                    # are just unserializable because of their children.
+                    unserializable_items = [
+                        i for i in unserializable_items if not p.startswith(i[0])
+                    ]
+                    if unserializable_items:
+                        # we already have something unserializable in a different
+                        # branch - time to stop and fail
+                        break
+                    if all(not i[0].startswith(p) for i in unserializable_items):
+                        unserializable_items.append((p, j))
+
                 # Children that are not of type Component or
                 # list/tuple not returned by traverse
                 child = getattr(j, "children", None)
-                if not isinstance(child, (tuple, collections.MutableSequence)):
-                    if child and not _value_is_valid(child):
+                if not isinstance(child, (tuple, MutableSequence)):
+                    if child and not _can_serialize(child):
                         _raise_invalid(
                             bad_val=child,
                             outer_val=val,
                             path=p + "\n" + "[*] " + type(child).__name__,
                             index=index,
                         )
+            if unserializable_items:
+                p, j = unserializable_items[0]
+                # just report the first one, even if there are multiple,
+                # as that's how all the other errors work
+                _raise_invalid(bad_val=j, outer_val=val, path=p, index=index)
 
             # Also check the child of val, as it will not be returned
             child = getattr(val, "children", None)
-            if not isinstance(child, (tuple, collections.MutableSequence)):
-                if child and not _value_is_valid(child):
+            if not isinstance(child, (tuple, MutableSequence)):
+                if child and not _can_serialize(val):
                     _raise_invalid(
                         bad_val=child,
                         outer_val=val,
                         path=type(child).__name__,
                         index=index,
                     )
 
-        # val is not a Component, but is at the top level of tree
-        elif not _value_is_valid(val):
+        if not _can_serialize(val):
             _raise_invalid(
                 bad_val=val,
                 outer_val=type(val).__name__,
@@ -301,13 +333,13 @@ def _validate_value(val, index=None):
     # if we got this far, raise a generic JSON error
     raise exceptions.InvalidCallbackReturnValue(
         """
-        The callback for property `{property:s}` of component `{id:s}`
+        The callback for output `{output}`
         returned a value which is not JSON serializable.
 
         In general, Dash properties can only be dash components, strings,
         dictionaries, numbers, None, or lists of those.
         """.format(
-            property=output.component_property, id=output.component_id
+            output=repr(output)
         )
     )
 

tests/unit/dash/test_validate.py

@@ -0,0 +1,38 @@
+import pytest
+
+from dash import Output
+from dash.html import Div
+from dash.exceptions import InvalidCallbackReturnValue
+from dash._validate import fail_callback_output
+
+
+@pytest.mark.parametrize(
+    "val",
+    [
+        {0},
+        [{1}, 1],
+        [1, {2}],
+        Div({3}),
+        Div([{4}]),
+        Div(style={5}),
+        Div([1, {6}]),
+        Div([1, Div({7})]),
+        [Div({8}), 1],
+        [1, Div({9})],
+        [Div(Div({10}))],
+        [Div(Div({11})), 1],
+        [1, Div(Div({12}))],
+        {"a": {13}},
+        Div(style={"a": {14}}),
+        Div(style=[{15}]),
+        [1, Div(style=[{16}])],
+    ],
+)
+def test_ddvl001_fail_handler_fails_correctly(val):
+    if isinstance(val, list):
+        outputs = [Output(f"id{i}", "children") for i in range(len(val))]
+    else:
+        outputs = Output("id", "children")
+
+    with pytest.raises(InvalidCallbackReturnValue):
+        fail_callback_output(val, outputs)