refactor(WIP): Querybuilder public interface

Author: TheRustifyer

canyon_core/src/connection/clients/mssql.rs

@@ -2,15 +2,18 @@ use crate::connection::clients::mssql::sqlserver_query_launcher::execute_query;
 use crate::connection::contracts::DbConnection;
 use crate::connection::database_type::DatabaseType;
 use crate::connection::datasources::DatasourceConfig;
-use crate::connection::{MsManager, SqlServerConnectionPool};
 use crate::mapper::RowMapper;
 use crate::query::parameters::QueryParameter;
 use crate::rows::{CanyonRows, FromSqlOwnedValue};
 use bb8::PooledConnection;
 use std::error::Error;
+use std::sync::Arc;
 use tiberius::Query;
+use bb8_tiberius::ConnectionManager as TiberiusConnectionManager;
 
-/// A connection with a `SqlServer` database
+type SqlServerConnectionPool = Arc<bb8::Pool<TiberiusConnectionManager>>;
+
+/// A connector for a `SqlServer` database
 pub struct SqlServerConnector(SqlServerConnectionPool);
 
 impl SqlServerConnector {
@@ -19,7 +22,7 @@ impl SqlServerConnector {
     }
     pub async fn get_pooled(
         &self,
-    ) -> Result<PooledConnection<'_, MsManager>, Box<dyn Error + Send + Sync>> {
+    ) -> Result<PooledConnection<'_, TiberiusConnectionManager>, Box<dyn Error + Send + Sync>> {
         Ok(self.0.get().await?)
     }
 }
@@ -190,18 +193,16 @@ pub(crate) mod __impl {
 
     pub(crate) async fn create_sqlserver_connector(
         datasource: &DatasourceConfig,
-    ) -> Result<Arc<Pool<MsManager>>, Box<dyn Error + Send + Sync>> {
+    ) -> Result<Arc<Pool<TiberiusConnectionManager>>, Box<dyn Error + Send + Sync>> {
         let sqlserver_config = sqlserver_config_from_datasource(datasource)?;
-        // let tcp = TcpStream::connect(tiberius_config.get_addr()).await?;
-        // tcp.set_nodelay(true)?;
 
-        let manager = MsManager::new(sqlserver_config);
+        let manager = TiberiusConnectionManager::new(sqlserver_config);
         let pool = bb8::Pool::builder().max_size(10u32).build(manager).await?;
 
         Ok(SqlServerConnectionPool::from(pool))
     }
 
-    fn sqlserver_config_from_datasource(
+    pub(crate) fn sqlserver_config_from_datasource(
         datasource: &DatasourceConfig,
     ) -> Result<Config, Box<dyn Error + Send + Sync>> {
         let mut tiberius_config = tiberius::Config::new();
@@ -220,7 +221,7 @@ pub(crate) mod __impl {
         Ok(tiberius_config)
     }
 
-    pub fn extract_mssql_auth(
+    pub(crate) fn extract_mssql_auth(
         auth: &Auth,
     ) -> Result<tiberius::AuthMethod, Box<dyn std::error::Error + Send + Sync>> {
         match auth {
@@ -235,3 +236,52 @@ pub(crate) mod __impl {
         }
     }
 }
+#[cfg(test)]
+mod tests {
+    use super::__impl;
+    use crate::connection::datasources::{Auth, DatasourceConfig, DatasourceProperties, SqlServerAuth};
+    use tiberius::AuthMethod;
+
+    #[test]
+    fn test_extract_mssql_auth_basic() {
+        let auth = Auth::SqlServer(SqlServerAuth::Basic {
+            username: "sa".to_string(),
+            password: "password123".to_string(),
+        });
+
+        let result = __impl::extract_mssql_auth(&auth).unwrap();
+
+        match result {
+            // We can only check the variant, not its internals (private fields)
+            AuthMethod::SqlServer(_) => {} // success
+            _ => panic!("Expected AuthMethod::SqlServer variant"),
+        }
+    }
+
+    #[test]
+    fn test_extract_mssql_auth_integrated() {
+        let auth = Auth::SqlServer(SqlServerAuth::Integrated);
+        let result = __impl::extract_mssql_auth(&auth).unwrap();
+        assert!(matches!(result, AuthMethod::Integrated));
+    }
+
+    #[test]
+    fn test_sqlserver_config_from_datasource_basic() {
+        let datasource = DatasourceConfig {
+            name: "test_source".into(),
+            properties: DatasourceProperties {
+                host: "localhost".into(),
+                db_name: "test_db".into(),
+                port: None, // default
+                migrations: None,
+            },
+            auth: Auth::SqlServer(SqlServerAuth::Basic {
+                username: "sa".into(),
+                password: "pass123".into(),
+            }),
+        };
+
+        let config = __impl::sqlserver_config_from_datasource(&datasource).unwrap();
+        assert_eq!(config.get_addr(), "localhost:1433");
+    }
+}

canyon_core/src/connection/clients/postgresql.rs

@@ -1,21 +1,21 @@
 use crate::connection::contracts::DbConnection;
 use crate::connection::database_type::DatabaseType;
 use crate::connection::datasources::{Auth, DatasourceConfig, PostgresAuth};
-use crate::connection::{PgManager, PostgresConnectionPool};
 use crate::mapper::RowMapper;
 use crate::rows::FromSqlOwnedValue;
 use crate::{query::parameters::QueryParameter, rows::CanyonRows};
 use bb8::{Pool, PooledConnection};
 use std::error::Error;
 use std::sync::Arc;
+use bb8_postgres::PostgresConnectionManager;
 use tokio_postgres::types::ToSql;
 use tokio_postgres::{Config, NoTls};
 
+type PgManager = PostgresConnectionManager<NoTls>;
+type PostgresConnectionPool = Arc<bb8::Pool<PgManager>>;
+
 /// A connector with a `PostgreSQL` database
-#[cfg(feature = "postgres")]
 pub struct PostgresConnector(PostgresConnectionPool);
-
-#[cfg(feature = "postgres")]
 impl PostgresConnector {
     pub async fn new(datasource: &DatasourceConfig) -> Result<Self, Box<dyn Error + Send + Sync>> {
         Ok(Self(create_postgres_connector(datasource).await?))
@@ -168,11 +168,84 @@ mod __impl {
             _ => Err("Invalid auth configuration for a Postgres datasource.".into()),
         }
     }
+
     pub(crate) async fn create_postgres_connection_pool(
         config: Config,
     ) -> Result<Pool<PgManager>, Box<dyn Error + Send + Sync>> {
         let manager = PgManager::new(config, NoTls);
-        let pool = bb8::Pool::builder().max_size(10u32).build(manager).await?;
+        let pool = bb8::Pool::builder()
+            .max_size(10u32)
+            .build(manager).await?;
         Ok(pool)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::__impl;
+    use crate::connection::datasources::{Auth, DatasourceConfig, DatasourceProperties, PostgresAuth};
+
+    #[test]
+    fn test_extract_postgres_auth_basic() {
+        let auth = Auth::Postgres(PostgresAuth::Basic {
+            username: "pguser".into(),
+            password: "pgpass".into(),
+        });
+
+        let (user, pass) = __impl::extract_postgres_auth(&auth).unwrap();
+        assert_eq!(user, "pguser");
+        assert_eq!(pass, "pgpass");
+    }
+
+    #[test]
+    fn test_set_tokio_postgres_configs_basic() {
+        let datasource = DatasourceConfig {
+            name: "pg_test".into(),
+            properties: DatasourceProperties {
+                host: "localhost".into(),
+                db_name: "pg_db".into(),
+                port: Some(5433),
+                migrations: None,
+            },
+            auth: Auth::Postgres(PostgresAuth::Basic {
+                username: "pguser".into(),
+                password: "pgpass".into(),
+            }),
+        };
+
+        let config = __impl::set_tokio_postgres_configs(&datasource, "pguser", "pgpass");
+
+        assert_eq!(config.get_hosts(), vec![tokio_postgres::config::Host::Tcp("localhost".into())]);
+        assert_eq!(config.get_dbname(), Some("pg_db"));
+        assert_eq!(config.get_user(), Some("pguser"));
+        assert_eq!(*config.get_ports().first().unwrap(), 5433);
+
+        // sanity check for configured timeouts and keepalives
+        assert_eq!(config.get_connect_timeout(), Some(std::time::Duration::from_secs(5)).as_ref());
+        assert_eq!(config.get_keepalives_idle(), std::time::Duration::from_secs(30));
+        assert_eq!(config.get_keepalives_interval(), Some(std::time::Duration::from_secs(10)));
+        assert_eq!(config.get_keepalives_retries(), Some(3));
+    }
+
+    #[test]
+    fn test_set_tokio_postgres_configs_default_port() {
+        let datasource = DatasourceConfig {
+            name: "pg_test_default".into(),
+            properties: DatasourceProperties {
+                host: "127.0.0.1".into(),
+                db_name: "default_db".into(),
+                port: None,
+                migrations: None,
+            },
+            auth: Auth::Postgres(PostgresAuth::Basic {
+                username: "user".into(),
+                password: "pass".into(),
+            }),
+        };
+
+        let config = __impl::set_tokio_postgres_configs(&datasource, "user", "pass");
+        assert_eq!(*config.get_ports().first().unwrap(), 5432); // default Postgres port
+        assert_eq!(config.get_dbname(), Some("default_db"));
+        assert_eq!(config.get_user(), Some("user"));
+    }
+}

canyon_core/src/connection/mod.rs

@@ -32,23 +32,12 @@ use crate::canyon::Canyon;
 use crate::connection::contracts::DbConnection;
 use crate::connection::database_type::DatabaseType;
 
-use bb8_postgres::PostgresConnectionManager;
-use bb8_tiberius::ConnectionManager as TiberiusConnectionManager;
-
 use std::error::Error;
 use std::sync::{Arc, OnceLock};
 
 use tokio::runtime::Runtime;
 use tokio::sync::Mutex;
-use tokio_postgres::NoTls;
-
-type PgManager = PostgresConnectionManager<NoTls>;
-type PostgresConnectionPool = Arc<bb8::Pool<PgManager>>;
 
-type MsManager = TiberiusConnectionManager;
-type SqlServerConnectionPool = Arc<bb8::Pool<MsManager>>;
-
-//
 // // TODO's: DatabaseConnector and DataSource can implement default, so there's no need to use str and &str
 // // as defaults anymore, since the can load as the default the first one defined in the config file, or have more
 // // complex workflows that are deferred to initialization time