test: TurnStateEntry test case

python/packages/ai/teams/state/turn_state.py

@@ -24,7 +24,7 @@ class _GetScopeAndNameResult:
     name: str
 
 class TurnState(Memory):
-    _scopes: Dict[str, TurnStateEntry] = Dict[str, TurnStateEntry]()
+    _scopes: Dict[str, TurnStateEntry] = dict()
     _is_loaded: bool = False
     _loading_callable: Optional[Callable[[],Awaitable[bool]]] = None
 

python/packages/ai/teams/state/turn_state_entry.py

@@ -11,9 +11,9 @@ class TurnStateEntry:
     _hash: str
 
     def __init__(self, value: Optional[Dict[str, Any]] = None, storage_key: Optional[str] = None):
-        self._value = value or Dict[str, Any]()
+        self._value = value or dict()
         self._storage_key = storage_key
-        self._hash = str(value)
+        self._hash = str(self._value)
 
     @property
     def has_changed(self) -> bool:
@@ -27,7 +27,7 @@ def is_deleted(self) -> bool:
     def value(self) -> Dict[str, Any]:
         if self._deleted:
             # Switch to a replace scenario
-            self._value = Dict[str, Any]()
+            self._value = dict()
             self._deleted = False
 
         return self._value
@@ -39,7 +39,7 @@ def storage_key(self) -> Optional[str]:
     def delete(self) -> None:
         self._deleted = True
 
-    def replace(self, value: Optional[Dict[str, Any]]) -> None:
-        self._value = value or Dict[str, Any]()
+    def replace(self, value: Optional[Dict[str, Any]] = None) -> None:
+        self._value = value or dict()
 
 

python/packages/ai/tests/state/test_turn_state_entry.py

@@ -0,0 +1,93 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+from unittest import TestCase
+from copy import deepcopy
+
+from teams.state import TurnStateEntry
+
+class TestTurnStateEntry(TestCase):
+    _value = {"key": "value"}
+    _storage_key = "storage_key"
+
+    def setUp(self):
+        self.entry = TurnStateEntry(deepcopy(self._value), deepcopy(self._storage_key))
+        print(self.entry.value)
+
+    def test_has_changed_replace_entry(self):
+        self.assertFalse(self.entry.has_changed)
+        new_value = {"new_key": "new_value"}
+        self.entry.replace(new_value)
+        self.assertTrue(self.entry.has_changed)
+
+    def test_init(self):
+        self.assertEqual(self.entry.value, self._value)
+        self.assertEqual(self.entry.storage_key, self._storage_key)
+        self.assertFalse(self.entry.is_deleted)
+        self.assertFalse(self.entry.has_changed)
+
+    def test_init_no_params(self):
+        entry = TurnStateEntry()
+        self.assertEqual(entry.value, {})
+        self.assertIsNone(entry.storage_key)
+        self.assertFalse(entry.is_deleted)
+        self.assertFalse(entry.has_changed)
+
+    def test_has_changed_update_existing_key(self):
+        self.assertFalse(self.entry.has_changed)
+        self.entry.value["key"] = "new_value"
+        self.assertTrue(self.entry.has_changed)
+
+    def test_has_changed_add_new_key(self):
+        self.assertFalse(self.entry.has_changed)
+        self.entry.value["new_key"] = "new_value"
+        self.assertTrue(self.entry.has_changed)
+
+    def test_has_changed_remove_existing_key(self):
+        self.assertFalse(self.entry.has_changed)
+        del self.entry.value["key"]
+        self.assertTrue(self.entry.has_changed)
+
+    def test_is_deleted(self):
+        self.entry.delete()
+        self.assertTrue(self.entry.is_deleted)
+
+    def test_is_deleted_when_access_again(self):
+        self.entry.delete()
+        self.assertTrue(self.entry.is_deleted)
+        self.assertEqual(self.entry.value, {})
+        self.assertFalse(self.entry.is_deleted)
+
+    def test_is_deleted_after_replace(self):
+        self.entry.delete()
+        self.assertTrue(self.entry.is_deleted)
+        self.entry.replace({"new_key": "new_value"})
+        self.assertFalse(self.entry.is_deleted)
+
+    def test_replace(self):
+        new_value = {"new_key": "new_value"}
+        self.entry.replace(new_value)
+        self.assertEqual(self.entry.value, new_value)
+
+    def test_replace_no_value(self):
+        self.entry.replace()
+        self.assertEqual(self.entry.value, {})
+
+    def test_value(self):
+        self.assertEqual(self.entry.value, self._value)
+        self.entry.delete()
+        self.assertEqual(self.entry.value, {})
+        self.assertFalse(self.entry.is_deleted)
+
+    def test_storage_key(self):
+        self.assertEqual(self.entry.storage_key, self._storage_key)
+
+    def test_storage_key_no_provided(self):
+        entry = TurnStateEntry()
+        self.assertIsNone(entry.storage_key)
+
+    def test_delete(self):
+        self.assertFalse(self.entry.is_deleted)
+        self.entry.delete()
+        self.assertTrue(self.entry.is_deleted)