chore: import upstream snapshot with attribution

python/tests/unit/contents/test_hashing_utils.py

@@ -0,0 +1,196 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from semantic_kernel.contents.function_call_content import FunctionCallContent
+from semantic_kernel.contents.function_result_content import FunctionResultContent
+
+
+class SimpleModel(BaseModel):
+    field1: str
+    field2: int
+
+
+class NestedModel(BaseModel):
+    name: str
+    values: list[int]
+
+
+class ModelContainer(BaseModel):
+    container_name: str
+    nested_model: NestedModel
+
+
+def test_hash_with_nested_structures():
+    """
+    Deeply nested dictionaries and lists, but with no cyclical references.
+    Ensures multiple levels of nested transformations work.
+    """
+    data = {
+        "level1": {
+            "list1": [1, 2, 3],
+            "dict1": {"keyA": "valA", "keyB": "valB"},
+        },
+        "level2": [
+            {"sub_dict1": {"x": 99}},
+            {"sub_dict2": {"y": 100}},
+        ],
+    }
+    content = FunctionResultContent(
+        id="test_nested_structures",
+        result=data,
+        function_name="TestNestedStructures",
+    )
+    _ = hash(content)
+    assert True, "Hashing deeply nested structures succeeded."
+
+
+def test_hash_with_repeated_references():
+    """
+    Multiple references to the same object, but no cycle.
+    Ensures repeated objects are handled consistently and do not cause duplication.
+    """
+    shared_dict = {"common_key": "common_value"}
+    data = {
+        "ref1": shared_dict,
+        "ref2": shared_dict,  # same object, repeated reference
+    }
+    content = FunctionResultContent(
+        id="test_repeated_references",
+        result=data,
+        function_name="TestRepeatedRefs",
+    )
+    _ = hash(content)
+    assert True, "Hashing repeated references (no cycles) succeeded."
+
+
+def test_hash_with_simple_pydantic_model():
+    """
+    Hash a Pydantic model that doesn't reference itself or another model.
+    """
+    model_instance = SimpleModel(field1="hello", field2=42)
+    content = FunctionResultContent(
+        id="test_simple_model",
+        result=model_instance,
+        function_name="TestSimpleModel",
+    )
+    _ = hash(content)
+    assert True, "Hashing a simple Pydantic model succeeded."
+
+
+def test_hash_with_nested_pydantic_models():
+    """
+    Hash a Pydantic model containing another Pydantic model, no cycles.
+    """
+    nested = NestedModel(name="MyNestedModel", values=[1, 2, 3])
+    container = ModelContainer(container_name="TopLevel", nested_model=nested)
+    content = FunctionResultContent(
+        id="test_nested_models",
+        result=container,
+        function_name="TestNestedModels",
+    )
+    _ = hash(content)
+    assert True, "Hashing nested Pydantic models succeeded."
+
+
+def test_hash_with_triple_cycle():
+    """
+    Three dictionaries referencing each other to form a cycle.
+    This ensures that multi-node cycles are also handled.
+    """
+    dict_a: dict[str, Any] = {"a_key": 1}
+    dict_b: dict[str, Any] = {"b_key": 2}
+    dict_c: dict[str, Any] = {"c_key": 3}
+
+    dict_a["ref_to_b"] = dict_b
+    dict_b["ref_to_c"] = dict_c
+    dict_c["ref_to_a"] = dict_a
+
+    content = FunctionResultContent(
+        id="test_triple_cycle",
+        result=dict_a,
+        function_name="TestTripleCycle",
+    )
+
+    _ = hash(content)
+    assert True, "Hashing triple cyclical references succeeded."
+
+
+def test_hash_with_cyclical_references():
+    """
+    The original cyclical references test for thorough coverage.
+    """
+
+    class CyclicalModel(BaseModel):
+        name: str
+        partner: "CyclicalModel" = None  # type: ignore
+
+    CyclicalModel.model_rebuild()
+
+    model_a = CyclicalModel(name="ModelA")
+    model_b = CyclicalModel(name="ModelB")
+    model_a.partner = model_b
+    model_b.partner = model_a
+
+    dict_x = {"x_key": 42}
+    dict_y = {"y_key": 99, "ref_to_x": dict_x}
+    dict_x["ref_to_y"] = dict_y  # type: ignore
+
+    giant_data_structure = {
+        "models": [model_a, model_b],
+        "nested": {"cyclical_dict_x": dict_x, "cyclical_dict_y": dict_y},
+    }
+
+    content = FunctionResultContent(
+        id="test_id_cyclical",
+        result=giant_data_structure,
+        function_name="TestFunctionCyclical",
+    )
+
+    _ = hash(content)
+
+
+def test_hash_with_large_structure():
+    """
+    Tests performance or at least correctness when dealing with
+    a large structure, ensuring we don't crash or exceed recursion.
+    """
+    large_list = list(range(1000))
+    large_dict = {f"key_{i}": i for i in range(1000)}
+    combined = {
+        "big_list": large_list,
+        "big_dict": large_dict,
+        "nested": [
+            {"inner_list": large_list},
+            {"inner_dict": large_dict},
+        ],
+    }
+    content = FunctionResultContent(
+        id="test_large_structure",
+        result=combined,
+        function_name="TestLargeStructure",
+    )
+
+    _ = hash(content)
+
+
+def test_hash_function_call_content():
+    call_content = FunctionCallContent(
+        inner_content=None,
+        ai_model_id=None,
+        metadata={},
+        id="call_LAbz",
+        index=None,
+        name="menu-get_specials",
+        function_name="get_specials",
+        plugin_name="menu",
+        arguments="{}",
+    )
+
+    content = FunctionResultContent(
+        id="test_function_call_content", result=call_content, function_name="TestFunctionCallContent"
+    )
+
+    _ = hash(content)