Fix sqlite3 Cursor initialization check

ever0de · ever0de · commit 1d623e51d482 · 2025-10-21T00:51:33.000+09:00
Add proper __init__ validation for sqlite3.Cursor to ensure base class
__init__ is called before using cursor methods. This fixes the
test_cursor_constructor_call_check test case.

Changes:
- Modified Cursor to initialize with inner=None in py_new
- Added explicit __init__ method that sets up CursorInner
- Updated close() method to check for uninitialized state
- Changed error message to match CPython: 'Base Cursor.__init__ not called.'

This ensures CPython compatibility where attempting to use a Cursor
instance without calling the base __init__ raises ProgrammingError.
diff --git a/Lib/test/test_sqlite3/test_regression.py b/Lib/test/test_sqlite3/test_regression.py
@@ -195,8 +195,6 @@ def __del__(self):
                     con.isolation_level = value
                 self.assertEqual(con.isolation_level, "DEFERRED")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cursor_constructor_call_check(self):
         """
         Verifies that cursor methods check whether base class __init__ was
diff --git a/stdlib/src/sqlite.rs b/stdlib/src/sqlite.rs
@@ -1488,6 +1488,32 @@ mod _sqlite {
             }
         }
 
+        fn new_uninitialized(connection: PyRef<Connection>, _vm: &VirtualMachine) -> Self {
+            Self {
+                connection,
+                arraysize: Radium::new(1),
+                row_factory: PyAtomicRef::from(None),
+                inner: PyMutex::from(None),
+            }
+        }
+
+        #[pymethod]
+        fn __init__(&self, _connection: PyRef<Connection>, _vm: &VirtualMachine) -> PyResult<()> {
+            let mut guard = self.inner.lock();
+            if guard.is_some() {
+                // Already initialized (e.g., from a call to super().__init__)
+                return Ok(());
+            }
+            *guard = Some(CursorInner {
+                description: None,
+                row_cast_map: vec![],
+                lastrowid: -1,
+                rowcount: -1,
+                statement: None,
+            });
+            Ok(())
+        }
+
         fn inner(&self, vm: &VirtualMachine) -> PyResult<PyMappedMutexGuard<'_, CursorInner>> {
             let guard = self.inner.lock();
             if guard.is_some() {
@@ -1497,7 +1523,7 @@ mod _sqlite {
             } else {
                 Err(new_programming_error(
                     vm,
-                    "Cannot operate on a closed cursor.".to_owned(),
+                    "Base Cursor.__init__ not called.".to_owned(),
                 ))
             }
         }
@@ -1717,12 +1743,22 @@ mod _sqlite {
         }
 
         #[pymethod]
-        fn close(&self) {
-            if let Some(inner) = self.inner.lock().take()
+        fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // Check if __init__ was called
+            let mut guard = self.inner.lock();
+            if guard.is_none() {
+                return Err(new_programming_error(
+                    vm,
+                    "Base Cursor.__init__ not called.".to_owned(),
+                ));
+            }
+
+            if let Some(inner) = guard.take()
                 && let Some(stmt) = inner.statement
             {
                 stmt.lock().reset();
             }
+            Ok(())
         }
 
         #[pymethod]
@@ -1809,7 +1845,7 @@ mod _sqlite {
         type Args = (PyRef<Connection>,);
 
         fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Self::new(args.0, None, vm)
+            Self::new_uninitialized(args.0, vm)
                 .into_ref_with_type(vm, cls)
                 .map(Into::into)
         }
