fix(spanner): fix equality symmetry, array tuple normalization, and dict methods in JsonObject

Author: sakthivelmanii

packages/google-cloud-spanner/google/cloud/spanner_v1/data_types.py

@@ -31,14 +31,20 @@ class JsonObject(dict):
     """
 
     def __init__(self, *args, **kwargs):
-        self._is_null = (args, kwargs) == ((), {}) or args == (None,)
-        self._is_array = len(args) and isinstance(args[0], (list, tuple))
-        self._is_scalar_value = len(args) == 1 and not isinstance(args[0], (list, dict))
+        self._is_null = (args, kwargs) == ((), {}) or (
+            len(args) == 1 and args[0] is None
+        )
+        self._is_array = len(args) == 1 and isinstance(args[0], (list, tuple))
+        self._is_scalar_value = (
+            len(args) == 1
+            and args[0] is not None
+            and not isinstance(args[0], (list, dict))
+        )
 
         # if the JSON object is represented with an array,
         # the value is contained separately
         if self._is_array:
-            self._array_value = args[0]
+            self._array_value = list(args[0])
             return
 
         # If it's a scalar value, set _simple_value and return early
@@ -50,7 +56,7 @@ def __init__(self, *args, **kwargs):
             self._is_array = args[0]._is_array
             self._is_scalar_value = args[0]._is_scalar_value
             if self._is_array:
-                self._array_value = args[0]._array_value
+                self._array_value = list(args[0]._array_value)
             elif self._is_scalar_value:
                 self._simple_value = args[0]._simple_value
 
@@ -59,6 +65,62 @@ def __init__(self, *args, **kwargs):
         else:
             super().__init__(*args, **kwargs)
 
+    def get(self, key, default=None):
+        if self._is_array:
+            try:
+                return self._array_value[key]
+            except (IndexError, TypeError):
+                return default
+        if self._is_scalar_value or self._is_null:
+            return default
+        return super().get(key, default)
+
+    def copy(self):
+        if self._is_array:
+            return JsonObject(list(self._array_value))
+        if self._is_scalar_value:
+            return JsonObject(self._simple_value)
+        if self._is_null:
+            return JsonObject()
+        return JsonObject(super().copy())
+
+    def keys(self):
+        if self._is_array or self._is_scalar_value or self._is_null:
+            return {}.keys()
+        return super().keys()
+
+    def values(self):
+        if self._is_array:
+            return dict(enumerate(self._array_value)).values()
+        if self._is_scalar_value:
+            return {0: self._simple_value}.values()
+        if self._is_null:
+            return {}.values()
+        return super().values()
+
+    def items(self):
+        if self._is_array:
+            return dict(enumerate(self._array_value)).items()
+        if self._is_scalar_value:
+            return {0: self._simple_value}.items()
+        if self._is_null:
+            return {}.items()
+        return super().items()
+
+    def pop(self, key, *args):
+        if self._is_array:
+            try:
+                return self._array_value.pop(key)
+            except (IndexError, TypeError):
+                if args:
+                    return args[0]
+                raise KeyError(key) from None
+        if self._is_scalar_value or self._is_null:
+            if args:
+                return args[0]
+            raise KeyError(key)
+        return super().pop(key, *args)
+
     def __len__(self):
         if self._is_null:
             return 0
@@ -78,6 +140,8 @@ def __bool__(self):
         return super().__len__() > 0
 
     def __iter__(self):
+        if self._is_null:
+            return iter([])
         if self._is_array:
             return iter(self._array_value)
         if self._is_scalar_value:
@@ -96,6 +160,8 @@ def __getitem__(self, key):
         return super().__getitem__(key)
 
     def __contains__(self, item):
+        if self._is_null:
+            return False
         if self._is_array:
             return item in self._array_value
         if self._is_scalar_value:

packages/google-cloud-spanner/tests/unit/test_datatypes.py

@@ -1,6 +1,6 @@
-# Copyright 2024 Google LLC
+# Copyright 2024 Google LLC All rights reserved.
 #
-# Licensed under the Apache License, Version 2.0 ( disputes );
+# Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 import json
 import unittest
 
@@ -63,6 +64,65 @@ class Test_JsonObject_dict_protocol(unittest.TestCase):
     """Verify that JsonObject behaves correctly with standard Python
     operations (len, bool, iteration, indexing) for all JSON variants."""
 
+    def test_asymmetric_equality(self):
+        a = JsonObject()
+        b = JsonObject(None)
+        self.assertEqual(a == b, b == a, "Equality symmetry is broken!")
+        self.assertEqual(a, b)
+
+    def test_tuple_vs_list_equality(self):
+        tup = JsonObject((1, 2))
+        lst = JsonObject([1, 2])
+        self.assertEqual(tup, lst)
+        self.assertEqual(tup, [1, 2])
+
+    def test_get_method(self):
+        arr = JsonObject([10, 20])
+        self.assertEqual(arr.get(0), 10)
+        self.assertEqual(arr.get(1), 20)
+        self.assertIsNone(arr.get(2))
+        obj = JsonObject({"a": 1})
+        self.assertEqual(obj.get("a"), 1)
+        self.assertIsNone(obj.get("b"))
+        scalar = JsonObject(42)
+        self.assertIsNone(scalar.get("a"))
+
+    def test_copy_method(self):
+        arr = JsonObject([10, 20])
+        cp_arr = arr.copy()
+        self.assertEqual(cp_arr, arr)
+        self.assertEqual(cp_arr.get(0), 10)
+
+        obj = JsonObject({"a": 1})
+        cp_obj = obj.copy()
+        self.assertEqual(cp_obj, obj)
+
+        scalar = JsonObject(42)
+        cp_scalar = scalar.copy()
+        self.assertEqual(cp_scalar, scalar)
+
+    def test_keys_values_items_pop(self):
+        arr = JsonObject([10, 20])
+        self.assertEqual(list(arr.keys()), [])
+        self.assertEqual(list(arr.values()), [10, 20])
+        self.assertEqual(list(arr.items()), [(0, 10), (1, 20)])
+        val = arr.pop(0)
+        self.assertEqual(val, 10)
+        self.assertEqual(len(arr), 1)
+
+        obj = JsonObject({"a": 1})
+        self.assertEqual(list(obj.keys()), ["a"])
+        self.assertEqual(list(obj.values()), [1])
+        self.assertEqual(list(obj.items()), [("a", 1)])
+
+    def test_null_sentinel_hiding(self):
+        null_obj = JsonObject()
+        self.assertEqual(list(null_obj), [])
+        self.assertNotIn("__json_null__", null_obj)
+        null_obj_none = JsonObject(None)
+        self.assertEqual(list(null_obj_none), [])
+        self.assertNotIn("__json_null__", null_obj_none)
+
     def test_isinstance_dict(self):
         obj = JsonObject({"a": 1})
         self.assertTrue(isinstance(obj, dict))