add extensive tests for data types

Author: shivam2680

tests/e2e/test_variant_types.py

@@ -94,4 +94,81 @@ def test_variant_data_retrieval(self, variant_table_fixture):
             # Parsing to verify it's valid JSON array
             parsed_array = json.loads(json_array)
             assert isinstance(parsed_array, list)
-            assert parsed_array == [1, 2, 3, 4]
+            assert parsed_array == [1, 2, 3, 4]
+
+    @pytest.mark.parametrize(
+        "test_id, json_value, expected_result, description",
+        [
+            # Primitive types
+            (1, '"string value"', "string value", "String value"),
+            (2, '42', 42, "Integer value"),
+            (3, '3.14159', 3.14159, "Float value"),
+            (4, 'true', True, "Boolean true"),
+            (5, 'false', False, "Boolean false"),
+            (6, 'null', None, "Null value"),
+            
+            # Complex types
+            (7, '["a", "b", "c"]', ["a", "b", "c"], "String array"),
+            (8, '[1, 2, 3]', [1, 2, 3], "Integer array"),
+            (9, '{"key1": "value1", "key2": "value2"}', {"key1": "value1", "key2": "value2"}, "Simple object"),
+            
+            # Nested structures
+            (10, '{"nested": {"a": 1, "b": 2}}', {"nested": {"a": 1, "b": 2}}, "Nested object"),
+            (11, '[["nested"], ["arrays"]]', [["nested"], ["arrays"]], "Nested arrays"),
+            (12, '{"array": [1, 2, 3], "object": {"a": "b"}}', {"array": [1, 2, 3], "object": {"a": "b"}}, "Mixed nested structures"),
+            
+            # Mixed types
+            (13, '[1, "string", true, null, {"key": "value"}]', [1, "string", True, None, {"key": "value"}], "Array with mixed types"),
+            
+            # Special cases
+            (14, '{}', {}, "Empty object"),
+            (15, '[]', [], "Empty array"),
+            (16, '{"unicode": "✓ öäü 😀"}', {"unicode": "✓ öäü 😀"}, "Unicode characters"),
+            (17, '{"large_number": 9223372036854775807}', {"large_number": 9223372036854775807}, "Large integer"),
+            
+            # Deeply nested structure
+            (18, '{"level1": {"level2": {"level3": {"level4": {"level5": "deep value"}}}}}',
+             {"level1": {"level2": {"level3": {"level4": {"level5": "deep value"}}}}}, "Deeply nested structure"),
+             
+            # Date and time types
+            (19, '"2023-01-01"', "2023-01-01", "Date as string (ISO format)"),
+            (20, '"12:34:56"', "12:34:56", "Time as string (ISO format)"),
+            (21, '"2023-01-01T12:34:56"', "2023-01-01T12:34:56", "Datetime as string (ISO format)"),
+            (22, '"2023-01-01T12:34:56Z"', "2023-01-01T12:34:56Z", "Datetime with Z timezone (UTC)"),
+            (23, '"2023-01-01T12:34:56+02:00"', "2023-01-01T12:34:56+02:00", "Datetime with timezone offset"),
+            (24, '{"date": "2023-01-01", "time": "12:34:56"}', {"date": "2023-01-01", "time": "12:34:56"}, "Object with date and time fields"),
+            (25, '["2023-01-01", "2023-02-02", "2023-03-03"]', ["2023-01-01", "2023-02-02", "2023-03-03"], "Array of dates"),
+            (26, '{"events": [{"timestamp": "2023-01-01T12:34:56Z", "name": "event1"}, {"timestamp": "2023-02-02T12:34:56Z", "name": "event2"}]}',
+                 {"events": [{"timestamp": "2023-01-01T12:34:56Z", "name": "event1"}, {"timestamp": "2023-02-02T12:34:56Z", "name": "event2"}]},
+                 "Complex object with timestamps"),
+        ]
+    )
+    def test_variant_data_types(self, test_id, json_value, expected_result, description):
+        """Test that different data types can be stored and retrieved from VARIANT columns"""
+        # Use a unique table name for each test case to avoid conflicts in parallel execution
+        table_name = f"pysql_test_variant_type_{test_id}"
+        
+        with self.cursor() as cursor:
+            try:
+                # Drop the table if it exists
+                cursor.execute(f"DROP TABLE IF EXISTS {table_name}")
+                
+                # Create a new table with a variant column
+                cursor.execute(f"CREATE TABLE {table_name} (id INTEGER, variant_col VARIANT)")
+                
+                # Insert the test value
+                cursor.execute(f"INSERT INTO {table_name} VALUES (1, PARSE_JSON('{json_value}'))")
+                
+                # Query the data
+                cursor.execute(f"SELECT variant_col FROM {table_name}")
+                result = cursor.fetchone()
+                
+                # Parse the JSON result
+                parsed_json = json.loads(result[0])
+                
+                # Verify the result matches the expected value
+                assert parsed_json == expected_result, f"Failed for test case {description}"
+                
+            finally:
+                # Clean up
+                cursor.execute(f"DROP TABLE IF EXISTS {table_name}")