sqlw-backend 0.1.0

#[cfg(feature = "mysql")]
mod mysql_tests {
    use sqlw::*;
    use sqlw_backend::mysql::MySqlExecutor;

    #[derive(FromRow, Debug, PartialEq)]
    struct User {
        pub id: i64,
        pub name: String,
        pub email: String,
    }

    #[tokio::test]
    #[ignore = "requires MySQL server"]
    async fn test_mysql_basic_query() -> Result<(), Box<dyn std::error::Error>> {
        let executor =
            MySqlExecutor::from_url("mysql://root:password@localhost:3307/test_db").await?;

        // Clean up
        executor
            .query_void(query!("DROP TABLE IF EXISTS users"))
            .await?;

        // Create table
        executor
            .query_void(query!(
                "CREATE TABLE users (id INT PRIMARY KEY AUTO_INCREMENT, name TEXT, email TEXT)"
            ))
            .await?;

        // Insert user
        let name = "Alice";
        let email = "alice@example.com";
        executor
            .query_void(query!("INSERT INTO users (name, email) VALUES (?, ?)"))
            .await?;

        // Query user
        let user: Option<User> = executor
            .query_one(query!("SELECT id, name, email FROM users WHERE name = ?"))
            .await?;

        assert!(user.is_some());
        assert_eq!(user.unwrap().name, "Alice");

        Ok(())
    }

    #[tokio::test]
    #[ignore = "requires MySQL server"]
    async fn test_mysql_query_list() -> Result<(), Box<dyn std::error::Error>> {
        let executor =
            MySqlExecutor::from_url("mysql://root:password@localhost:3307/test_db").await?;

        // Clean up
        executor
            .query_void(query!("DROP TABLE IF EXISTS users"))
            .await?;

        // Create table
        executor
            .query_void(query!(
                "CREATE TABLE users (id INT PRIMARY KEY AUTO_INCREMENT, name TEXT, email TEXT)"
            ))
            .await?;

        // Insert multiple users
        for i in 1..=3 {
            let name = format!("User{}", i);
            let email = format!("user{}@example.com", i);
            let insert = Query::new(
                "INSERT INTO users (name, email) VALUES (?, ?)".to_string(),
                vec![name.into(), email.into()],
            );
            executor.query_void(insert).await?;
        }

        // Query all users
        let users: Vec<User> = executor
            .query_list(query!("SELECT id, name, email FROM users"))
            .await?;

        assert_eq!(users.len(), 3);

        Ok(())
    }

    #[tokio::test]
    #[ignore = "requires MySQL server"]
    async fn test_mysql_from_url() -> Result<(), Box<dyn std::error::Error>> {
        // Test the from_url convenience method
        let executor =
            MySqlExecutor::from_url("mysql://root:password@localhost:3307/test_db").await?;

        // Clean up
        executor
            .query_void(query!("DROP TABLE IF EXISTS test_table"))
            .await?;

        // Create a simple table
        executor
            .query_void(query!(
                "CREATE TABLE test_table (id INT PRIMARY KEY, value TEXT)"
            ))
            .await?;

        // Insert and query
        let insert = Query::new(
            "INSERT INTO test_table (id, value) VALUES (?, ?)".to_string(),
            vec![1i64.into(), "test".into()],
        );
        executor.query_void(insert).await?;

        // Verify we can query it back
        let query = Query::new(
            "SELECT value FROM test_table WHERE id = ?".to_string(),
            vec![1i64.into()],
        );

        #[derive(FromRow)]
        struct TestRow {
            value: String,
        }

        let result: Option<TestRow> = executor.query_one(query).await?;
        assert!(result.is_some());
        assert_eq!(result.unwrap().value, "test");

        Ok(())
    }
}