Clean up ignored tests (#567)

- Remove `#[ignore]` from tests that can now pass
- Update failing tests to use `#[should_panic]` with expected messages
- Fix test implementations to show DuckDB behavior
- Remove useless tests copied from rusqlite

Author: mlafeldt

crates/duckdb/src/appender/mod.rs

@@ -208,10 +208,8 @@ mod test {
         Ok(())
     }
 
-    // Waiting https://github.com/duckdb/duckdb/pull/3405
     #[cfg(feature = "uuid")]
     #[test]
-    #[ignore = "not supported for now"]
     fn test_append_uuid() -> Result<()> {
         use uuid::Uuid;
 

crates/duckdb/src/lib.rs

@@ -980,14 +980,13 @@ mod test {
     }
 
     #[test]
-    #[ignore = "not supported"]
-    fn test_statement_debugging() -> Result<()> {
+    #[should_panic(expected = "not supported")]
+    fn test_statement_debugging() {
         let db = checked_memory_handle();
         let query = "SELECT 12345";
-        let stmt = db.prepare(query)?;
+        let stmt = db.prepare(query).unwrap();
 
         assert!(format!("{stmt:?}").contains(query));
-        Ok(())
     }
 
     #[test]

crates/duckdb/src/pragma.rs

@@ -292,15 +292,13 @@ mod test {
     }
 
     #[test]
-    #[ignore = "not supported"]
     fn pragma_query_with_schema() -> Result<()> {
         let db = Connection::open_in_memory()?;
-        let mut version = "".to_string();
-        db.pragma_query(Some(DatabaseName::Main), "version", |row| {
-            version = row.get(0)?;
-            Ok(())
-        })?;
-        assert!(!version.is_empty());
+        let res = db.pragma_query(Some(DatabaseName::Main), "version", |_| Ok(()));
+        assert_eq!(
+            res.unwrap_err().to_string().lines().next().unwrap(),
+            "Parser Error: syntax error at or near \".\""
+        );
         Ok(())
     }
 
@@ -324,12 +322,10 @@ mod test {
     }
 
     #[test]
-    #[ignore = "don't support query pragma"]
     fn test_pragma_update_and_check() -> Result<()> {
         let db = Connection::open_in_memory()?;
-        let journal_mode: String =
-            db.pragma_update_and_check(None, "explain_output", &"OPTIMIZED_ONLY", |row| row.get(0))?;
-        assert_eq!("OPTIMIZED_ONLY", &journal_mode);
+        let res = db.pragma_update_and_check(None, "explain_output", &"OPTIMIZED_ONLY", |_| Ok(()));
+        assert_eq!(res.unwrap_err(), crate::Error::QueryReturnedNoRows);
         Ok(())
     }
 
@@ -354,11 +350,4 @@ mod test {
         sql.push_string_literal("value'; --");
         assert_eq!("'value''; --'", sql.as_str());
     }
-
-    #[test]
-    #[ignore]
-    fn test_locking_mode() -> Result<()> {
-        let db = Connection::open_in_memory()?;
-        db.pragma_update(None, "locking_mode", &"exclusive")
-    }
 }

crates/duckdb/src/statement.rs

@@ -980,7 +980,6 @@ mod test {
     }
 
     #[test]
-    #[ignore]
     fn test_bind_parameters() -> Result<()> {
         let db = Connection::open_in_memory()?;
         // dynamic slice:
@@ -995,8 +994,8 @@ mod test {
         })?;
         db.query_row("SELECT ?1, ?2, ?3", params_from_iter(data), |row| row.get::<_, u8>(0))?;
 
-        use std::collections::BTreeSet;
-        let data: BTreeSet<String> = ["one", "two", "three"].iter().map(|s| (*s).to_string()).collect();
+        let data: std::collections::BTreeSet<String> =
+            ["one", "two", "three"].iter().map(|s| (*s).to_string()).collect();
         db.query_row("SELECT ?1, ?2, ?3", params_from_iter(&data), |row| {
             row.get::<_, String>(0)
         })?;
@@ -1035,22 +1034,6 @@ mod test {
     }
 
     #[test]
-    #[ignore]
-    fn test_utf16_conversion() -> Result<()> {
-        let db = Connection::open_in_memory()?;
-        db.pragma_update(None, "encoding", &"UTF-16le")?;
-        let encoding: String = db.pragma_query_value(None, "encoding", |row| row.get(0))?;
-        assert_eq!("UTF-16le", encoding);
-        db.execute_batch("CREATE TABLE foo(x TEXT)")?;
-        let expected = "テスト";
-        db.execute("INSERT INTO foo(x) VALUES (?)", [&expected])?;
-        let actual: String = db.query_row("SELECT x FROM foo", [], |row| row.get(0))?;
-        assert_eq!(expected, actual);
-        Ok(())
-    }
-
-    #[test]
-    #[ignore]
     fn test_nul_byte() -> Result<()> {
         let db = Connection::open_in_memory()?;
         let expected = "a\x00b";

crates/duckdb/src/types/chrono.rs

@@ -174,7 +174,7 @@ impl ToSql for Duration {
 #[cfg(test)]
 mod test {
     use crate::{
-        types::{FromSql, ToSql, ToSqlOutput, ValueRef},
+        types::{FromSql, FromSqlError, ToSql, ToSqlOutput, ValueRef},
         Connection, Result,
     };
     use chrono::{DateTime, Duration, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeDelta, TimeZone, Utc};
@@ -349,9 +349,15 @@ mod test {
     }
 
     #[test]
-    #[ignore]
     fn test_lenient_parse_timezone() {
-        assert!(DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00Z")).is_ok());
-        assert!(DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00+00")).is_ok());
+        // Not supported
+        assert!(matches!(
+            DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00Z")),
+            Err(FromSqlError::Other(_))
+        ));
+        assert!(matches!(
+            DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00+00")),
+            Err(FromSqlError::Other(_))
+        ));
     }
 }

crates/duckdb/src/types/mod.rs

@@ -197,8 +197,7 @@ impl fmt::Display for Type {
 #[cfg(test)]
 mod test {
     use super::Value;
-    use crate::{params, Connection, Error, Result, Statement};
-    use std::os::raw::{c_double, c_int};
+    use crate::{Connection, Result};
 
     fn checked_memory_handle() -> Result<Connection> {
         let db = Connection::open_in_memory()?;
@@ -298,69 +297,6 @@ mod test {
         Ok(())
     }
 
-    #[test]
-    #[allow(clippy::cognitive_complexity)]
-    #[ignore = "duckdb doesn't support this"]
-    fn test_mismatched_types() -> Result<()> {
-        fn is_invalid_column_type(err: Error) -> bool {
-            matches!(err, Error::InvalidColumnType(..))
-        }
-
-        let db = checked_memory_handle()?;
-
-        db.execute("INSERT INTO foo(b, t, i, f) VALUES (X'0102', 'text', 1, 1.5)", [])?;
-
-        let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo")?;
-        let mut rows = stmt.query([])?;
-        let row = rows.next()?.unwrap();
-
-        // check the correct types come back as expected
-        assert_eq!(vec![1, 2], row.get::<_, Vec<u8>>(0)?);
-        assert_eq!("text", row.get::<_, String>(1)?);
-        assert_eq!(1, row.get::<_, c_int>(2)?);
-        assert!((1.5 - row.get::<_, c_double>(3)?).abs() < f64::EPSILON);
-        assert_eq!(row.get::<_, Option<c_int>>(4)?, None);
-        assert_eq!(row.get::<_, Option<c_double>>(4)?, None);
-        assert_eq!(row.get::<_, Option<String>>(4)?, None);
-
-        // check some invalid types
-
-        // 0 is actually a blob (Vec<u8>)
-        assert!(is_invalid_column_type(row.get::<_, c_int>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, c_int>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, i64>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, c_double>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, String>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, Option<c_int>>(0).err().unwrap()));
-
-        // 1 is actually a text (String)
-        assert!(is_invalid_column_type(row.get::<_, c_int>(1).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, i64>(1).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, c_double>(1).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, Vec<u8>>(1).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, Option<c_int>>(1).err().unwrap()));
-
-        // 2 is actually an integer
-        assert!(is_invalid_column_type(row.get::<_, String>(2).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, Vec<u8>>(2).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, Option<String>>(2).err().unwrap()));
-
-        // 3 is actually a float (c_double)
-        assert!(is_invalid_column_type(row.get::<_, c_int>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, i64>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, String>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, Vec<u8>>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, Option<c_int>>(3).err().unwrap()));
-
-        // 4 is actually NULL
-        assert!(is_invalid_column_type(row.get::<_, c_int>(4).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, i64>(4).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, c_double>(4).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, String>(4).err().unwrap()));
-        assert!(is_invalid_column_type(row.get::<_, Vec<u8>>(4).err().unwrap()));
-        Ok(())
-    }
-
     #[test]
     fn test_dynamic_type() -> Result<()> {
         use super::Value;
@@ -383,91 +319,4 @@ mod test {
         assert_eq!(Value::Null, row.get::<_, Value>(4)?);
         Ok(())
     }
-
-    macro_rules! test_conversion {
-        ($db_etc:ident, $insert_value:expr, $get_type:ty,expect $expected_value:expr) => {
-            $db_etc.insert_statement.execute(params![$insert_value])?;
-            let res = $db_etc
-                .query_statement
-                .query_row([], |row| row.get::<_, $get_type>(0));
-            assert_eq!(res?, $expected_value);
-            $db_etc.delete_statement.execute([])?;
-        };
-        ($db_etc:ident, $insert_value:expr, $get_type:ty,expect_from_sql_error) => {
-            $db_etc.insert_statement.execute(params![$insert_value])?;
-            let res = $db_etc
-                .query_statement
-                .query_row([], |row| row.get::<_, $get_type>(0));
-            res.unwrap_err();
-            $db_etc.delete_statement.execute([])?;
-        };
-        ($db_etc:ident, $insert_value:expr, $get_type:ty,expect_to_sql_error) => {
-            $db_etc
-                .insert_statement
-                .execute(params![$insert_value])
-                .unwrap_err();
-        };
-    }
-
-    #[test]
-    #[ignore = "duckdb doesn't support this"]
-    fn test_numeric_conversions() -> Result<()> {
-        #![allow(clippy::float_cmp)]
-
-        // Test what happens when we store an f32 and retrieve an i32 etc.
-        let db = Connection::open_in_memory()?;
-        db.execute_batch("CREATE TABLE foo (x)")?;
-
-        // DuckDB actually ignores the column types, so we just need to test
-        // different numeric values.
-
-        struct DbEtc<'conn> {
-            insert_statement: Statement<'conn>,
-            query_statement: Statement<'conn>,
-            delete_statement: Statement<'conn>,
-        }
-
-        let mut db_etc = DbEtc {
-            insert_statement: db.prepare("INSERT INTO foo VALUES (?1)")?,
-            query_statement: db.prepare("SELECT x FROM foo")?,
-            delete_statement: db.prepare("DELETE FROM foo")?,
-        };
-
-        // Basic non-converting test.
-        test_conversion!(db_etc, 0u8, u8, expect 0u8);
-
-        // In-range integral conversions.
-        test_conversion!(db_etc, 100u8, i8, expect 100i8);
-        test_conversion!(db_etc, 200u8, u8, expect 200u8);
-        test_conversion!(db_etc, 100u16, i8, expect 100i8);
-        test_conversion!(db_etc, 200u16, u8, expect 200u8);
-        test_conversion!(db_etc, u32::MAX, u64, expect u32::MAX as u64);
-        test_conversion!(db_etc, i64::MIN, i64, expect i64::MIN);
-        test_conversion!(db_etc, i64::MAX, i64, expect i64::MAX);
-        test_conversion!(db_etc, i64::MAX, u64, expect i64::MAX as u64);
-        test_conversion!(db_etc, 100usize, usize, expect 100usize);
-        test_conversion!(db_etc, 100u64, u64, expect 100u64);
-        test_conversion!(db_etc, i64::MAX as u64, u64, expect i64::MAX as u64);
-
-        // Out-of-range integral conversions.
-        test_conversion!(db_etc, 200u8, i8, expect_from_sql_error);
-        test_conversion!(db_etc, 400u16, i8, expect_from_sql_error);
-        test_conversion!(db_etc, 400u16, u8, expect_from_sql_error);
-        test_conversion!(db_etc, -1i8, u8, expect_from_sql_error);
-        test_conversion!(db_etc, i64::MIN, u64, expect_from_sql_error);
-        test_conversion!(db_etc, u64::MAX, i64, expect_to_sql_error);
-        test_conversion!(db_etc, u64::MAX, u64, expect_to_sql_error);
-        test_conversion!(db_etc, i64::MAX as u64 + 1, u64, expect_to_sql_error);
-
-        // FromSql integer to float, always works.
-        test_conversion!(db_etc, i64::MIN, f32, expect i64::MIN as f32);
-        test_conversion!(db_etc, i64::MAX, f32, expect i64::MAX as f32);
-        test_conversion!(db_etc, i64::MIN, f64, expect i64::MIN as f64);
-        test_conversion!(db_etc, i64::MAX, f64, expect i64::MAX as f64);
-
-        // FromSql float to int conversion, never works even if the actual value
-        // is an integer.
-        test_conversion!(db_etc, 0f64, i64, expect_from_sql_error);
-        Ok(())
-    }
 }