diff --git a/dpath/__init__.py b/dpath/__init__.py index 2bc9942..fd372f4 100644 --- a/dpath/__init__.py +++ b/dpath/__init__.py @@ -334,6 +334,15 @@ def merger(dst, src, _segments=()): segments.set(dst, current_path, found) continue + # Check nested mappings even when no list strategy is selected. + if ( + flags == MergeType.TYPESAFE + and isinstance(target, MutableMapping) + and isinstance(found, MutableMapping) + ): + merger(dst, found, current_path) + continue + # At this point we know: # # * The target exists. diff --git a/tests/test_merge.py b/tests/test_merge.py index a8b638c..047d717 100644 --- a/tests/test_merge.py +++ b/tests/test_merge.py @@ -1,4 +1,5 @@ import copy +from collections import UserDict from nose2.tools.such import helper @@ -28,6 +29,106 @@ def test_merge_typesafe_and_separator(): raise Exception("MERGE_TYPESAFE failed to raise an exception when merging between str and int!") +def test_merge_typesafe_nested_type_error(): + dst = {"a": {"b": 1}} + src = {"a": {"b": "x"}} + + try: + dpath.merge(dst, src, flags=MergeType.TYPESAFE) + except TypeError as error: + assert str(error).endswith(" at a/b") + return + raise AssertionError("TYPESAFE failed to validate the nested value") + + +def test_merge_typesafe_nested_type_error_with_separator(): + dst = {"a": {"b": 1}} + src = {"a": {"b": "x"}} + + try: + dpath.merge(dst, src, flags=MergeType.TYPESAFE, separator=";") + except TypeError as error: + assert str(error).endswith(" at a;b") + return + raise AssertionError("TYPESAFE failed to validate the nested value") + + +def test_merge_typesafe_nested_dict(): + dst = {"a": {"keep": 1, "same": 2}} + src = {"a": {"same": 3, "new": 4}} + + dpath.merge(dst, src, flags=MergeType.TYPESAFE) + + assert dst == {"a": {"keep": 1, "same": 3, "new": 4}} + + +def test_merge_typesafe_nested_userdict(): + dst = {"a": UserDict({"keep": 1, "same": 2})} + src = {"a": UserDict({"same": 3, "new": 4})} + + dpath.merge(dst, src, flags=MergeType.TYPESAFE) + + assert type(dst["a"]) is UserDict + assert dst == {"a": {"keep": 1, "same": 3, "new": 4}} + + +def test_merge_typesafe_nested_mapping_type_error(): + dst = {"a": {"b": UserDict()}} + src = {"a": {"b": {}}} + + try: + dpath.merge(dst, src, flags=MergeType.TYPESAFE) + except TypeError as error: + assert str(error).endswith(" at a/b") + return + raise AssertionError("TYPESAFE failed to validate the nested mapping type") + + +def test_merge_typesafe_nested_list_without_strategy(): + dst = {"a": {"l": [1]}} + src = {"a": {"l": [2]}} + + dpath.merge(dst, src, flags=MergeType.TYPESAFE) + + assert dst == {"a": {"l": [1]}} + + +def test_merge_zero_flags_nested_containers(): + dst = {"a": {"keep": 1, "same": 2}, "l": [1]} + src = {"a": {"same": 3, "new": 4}, "l": [2]} + + dpath.merge(dst, src, flags=0) + + assert dst == {"a": {"keep": 1, "same": 2}, "l": [1]} + + +def test_merge_unknown_flags_nested_containers(): + for flags in (MergeType(8), MergeType.TYPESAFE | MergeType(8)): + dst = {"a": {"keep": 1, "same": 2}, "l": [1]} + src = {"a": {"same": 3, "new": 4}, "l": [2]} + + dpath.merge(dst, src, flags=flags) + + assert dst == {"a": {"keep": 1, "same": 2}, "l": [1]}, flags + + +def test_merge_nested_containers_with_list_strategies(): + for flags, expected_list in ( + (MergeType.ADDITIVE, [1, 2]), + (MergeType.REPLACE, [2]), + (MergeType.ADDITIVE | MergeType.TYPESAFE, [1, 2]), + (MergeType.REPLACE | MergeType.TYPESAFE, [2]), + (MergeType.ADDITIVE | MergeType.REPLACE, [1, 2]), + (MergeType.ADDITIVE | MergeType.REPLACE | MergeType.TYPESAFE, [1, 2]), + ): + dst = {"a": {"keep": 1, "same": 2, "l": [1]}} + src = {"a": {"same": 3, "new": 4, "l": [2]}} + + dpath.merge(dst, src, flags=flags) + + assert dst == {"a": {"keep": 1, "same": 3, "new": 4, "l": expected_list}}, flags + + def test_merge_simple_int(): src = { "integer": 0,