Test fixes

Author: CodingAnarchy

cargo-hammerwork/tests/sql_query_tests.rs

@@ -4,7 +4,6 @@ use sqlx::{MySqlPool, PgPool, Row};
 /// Tests for SQL query validation and correctness
 /// These tests validate that our dynamic SQL queries are syntactically correct
 /// and produce expected results
-
 #[cfg(test)]
 mod postgres_tests {
     use super::*;

examples/autoscaling_example.rs

@@ -25,17 +25,23 @@ async fn main() -> Result<()> {
     // Uncomment the appropriate line below based on your database setup
 
     // For PostgreSQL:
-    #[cfg(feature = "postgres")]
+    #[cfg(all(feature = "postgres", not(feature = "mysql")))]
     let pool = sqlx::PgPool::connect("postgresql://localhost/hammerwork")
         .await
         .map_err(hammerwork::HammerworkError::Database)?;
 
     // For MySQL:
-    #[cfg(feature = "mysql")]
+    #[cfg(all(feature = "mysql", not(feature = "postgres")))]
     let pool = sqlx::MySqlPool::connect("mysql://localhost/hammerwork")
         .await
         .map_err(hammerwork::HammerworkError::Database)?;
 
+    // Default to PostgreSQL when both features are enabled
+    #[cfg(all(feature = "postgres", feature = "mysql"))]
+    let pool = sqlx::PgPool::connect("postgresql://localhost/hammerwork")
+        .await
+        .map_err(hammerwork::HammerworkError::Database)?;
+
     let queue = Arc::new(JobQueue::new(pool));
 
     // Initialize database tables

examples/priority_example.rs

@@ -404,14 +404,16 @@ async fn demonstrate_worker_pool_priorities(
     let mut pool = WorkerPool::new().with_stats_collector(stats_collector.clone());
 
     // Add workers with different priority configurations
-    let handler: Arc<
+    type JobHandler = Arc<
         dyn Fn(
                 Job,
             ) -> std::pin::Pin<
                 Box<dyn std::future::Future<Output = hammerwork::Result<()>> + Send>,
             > + Send
             + Sync,
-    > = Arc::new(|job: Job| {
+    >;
+
+    let handler: JobHandler = Arc::new(|job: Job| {
         Box::pin(async move {
             info!(
                 "🔄 Pool worker processing: {} (Priority: {:?})",

examples/retry_strategies.rs

@@ -47,12 +47,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let database_url = get_database_url();
     info!("🔗 Connecting to database: {}", database_url);
 
-    #[cfg(feature = "postgres")]
+    #[cfg(all(feature = "postgres", not(feature = "mysql")))]
     let pool = sqlx::PgPool::connect(&database_url).await?;
 
-    #[cfg(feature = "mysql")]
+    #[cfg(all(feature = "mysql", not(feature = "postgres")))]
     let pool = sqlx::MySqlPool::connect(&database_url).await?;
 
+    // Default to PostgreSQL when both features are enabled
+    #[cfg(all(feature = "postgres", feature = "mysql"))]
+    let pool = sqlx::PgPool::connect(&database_url).await?;
+
     let queue = Arc::new(JobQueue::new(pool));
 
     // Note: Database tables should be created using migrations

hammerwork-web/tests/integration_tests.rs

@@ -246,6 +246,7 @@ mod test_helpers {
     use std::process::Command;
 
     /// Check if PostgreSQL test database is available
+    #[allow(dead_code)]
     pub fn postgres_available() -> bool {
         let output = Command::new("pg_isready")
             .arg("-h")
@@ -263,6 +264,7 @@ mod test_helpers {
     }
 
     /// Check if MySQL test database is available
+    #[allow(dead_code)]
     pub fn mysql_available() -> bool {
         let output = Command::new("mysql")
             .arg("--host=127.0.0.1")
@@ -279,6 +281,7 @@ mod test_helpers {
     }
 
     /// Create a test configuration with minimal setup
+    #[allow(dead_code)]
     pub fn create_test_config() -> DashboardConfig {
         let temp_dir = tempdir().expect("Failed to create temp directory");
 

src/migrations/mysql.rs

@@ -128,7 +128,7 @@ impl MigrationRunner<sqlx::MySql> for MySqlMigrationRunner {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    // Tests for MySQL migration functionality
 
     #[test]
     fn test_sql_statement_splitting() {

src/migrations/postgres.rs

@@ -130,7 +130,7 @@ impl MigrationRunner<sqlx::Postgres> for PostgresMigrationRunner {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    // Tests for PostgreSQL migration functionality
 
     #[test]
     fn test_sql_statement_splitting() {

src/queue/mysql.rs

@@ -253,7 +253,7 @@ impl DatabaseQueue for crate::queue::JobQueue<MySql> {
 
         let row = sqlx::query_as::<_, JobRow>(
             r#"
-            SELECT id, queue_name, payload, status, priority, attempts, max_attempts, timeout_seconds, created_at, scheduled_at, started_at, completed_at, failed_at, timed_out_at, error_message, cron_schedule, next_run_at, recurring, timezone, batch_id, result_data, result_stored_at, result_expires_at, result_storage_type, result_ttl_seconds, result_max_size_bytes, depends_on, dependents, dependency_status, workflow_id, workflow_name
+            SELECT id, queue_name, payload, status, priority, attempts, max_attempts, timeout_seconds, created_at, scheduled_at, started_at, completed_at, failed_at, timed_out_at, error_message, cron_schedule, next_run_at, recurring, timezone, batch_id, result_data, result_stored_at, result_expires_at, result_storage_type, result_ttl_seconds, result_max_size_bytes, depends_on, dependents, dependency_status, workflow_id, workflow_name, trace_id, correlation_id, parent_span_id, span_context
             FROM hammerwork_jobs 
             WHERE queue_name = ? 
             AND status = ? 
@@ -313,7 +313,7 @@ impl DatabaseQueue for crate::queue::JobQueue<MySql> {
         // Get available jobs by priority
         let available_jobs = sqlx::query_as::<_, JobRow>(
             r#"
-            SELECT id, queue_name, payload, status, priority, attempts, max_attempts, timeout_seconds, created_at, scheduled_at, started_at, completed_at, failed_at, timed_out_at, error_message, cron_schedule, next_run_at, recurring, timezone, batch_id, result_data, result_stored_at, result_expires_at, result_storage_type, result_ttl_seconds, result_max_size_bytes, depends_on, dependents, dependency_status, workflow_id, workflow_name
+            SELECT id, queue_name, payload, status, priority, attempts, max_attempts, timeout_seconds, created_at, scheduled_at, started_at, completed_at, failed_at, timed_out_at, error_message, cron_schedule, next_run_at, recurring, timezone, batch_id, result_data, result_stored_at, result_expires_at, result_storage_type, result_ttl_seconds, result_max_size_bytes, depends_on, dependents, dependency_status, workflow_id, workflow_name, trace_id, correlation_id, parent_span_id, span_context
             FROM hammerwork_jobs 
             WHERE queue_name = ? 
             AND status = ? 

src/worker.rs

@@ -1082,10 +1082,11 @@ where
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use hammerwork::{Worker, worker::{JobEventHooks, JobHookEvent}};
     /// # use std::sync::Arc;
-    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await.unwrap()));
+    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await?));
     /// # let handler: hammerwork::worker::JobHandler = Arc::new(|job| Box::pin(async move { Ok(()) }));
     ///
     /// let hooks = JobEventHooks::new()
@@ -1105,6 +1106,8 @@ where
     ///
     /// let worker = Worker::new(queue, "traced_queue".to_string(), handler)
     ///     .with_event_hooks(hooks);
+    /// # Ok(())
+    /// # }
     /// ```
     pub fn with_event_hooks(mut self, hooks: JobEventHooks) -> Self {
         self.event_hooks = hooks;
@@ -1122,16 +1125,19 @@ where
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use hammerwork::Worker;
     /// # use std::sync::Arc;
-    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await.unwrap()));
+    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await?));
     /// # let handler: hammerwork::worker::JobHandler = Arc::new(|job| Box::pin(async move { Ok(()) }));
     ///
     /// let worker = Worker::new(queue, "queue".to_string(), handler)
     ///     .on_job_start(|event| {
     ///         println!("Starting job: {}", event.job.id);
     ///     });
+    /// # Ok(())
+    /// # }
     /// ```
     pub fn on_job_start<F>(mut self, handler: F) -> Self
     where
@@ -1149,10 +1155,11 @@ where
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use hammerwork::Worker;
     /// # use std::sync::Arc;
-    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await.unwrap()));
+    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await?));
     /// # let handler: hammerwork::worker::JobHandler = Arc::new(|job| Box::pin(async move { Ok(()) }));
     ///
     /// let worker = Worker::new(queue, "queue".to_string(), handler)
@@ -1161,6 +1168,8 @@ where
     ///             println!("Job {} completed in {:?}", event.job.id, duration);
     ///         }
     ///     });
+    /// # Ok(())
+    /// # }
     /// ```
     pub fn on_job_complete<F>(mut self, handler: F) -> Self
     where
@@ -1178,10 +1187,11 @@ where
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use hammerwork::Worker;
     /// # use std::sync::Arc;
-    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await.unwrap()));
+    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await?));
     /// # let handler: hammerwork::worker::JobHandler = Arc::new(|job| Box::pin(async move { Ok(()) }));
     ///
     /// let worker = Worker::new(queue, "queue".to_string(), handler)
@@ -1190,6 +1200,8 @@ where
     ///             eprintln!("Job {} failed: {}", event.job.id, error);
     ///         }
     ///     });
+    /// # Ok(())
+    /// # }
     /// ```
     pub fn on_job_fail<F>(mut self, handler: F) -> Self
     where
@@ -1207,16 +1219,19 @@ where
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use hammerwork::Worker;
     /// # use std::sync::Arc;
-    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await.unwrap()));
+    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await?));
     /// # let handler: hammerwork::worker::JobHandler = Arc::new(|job| Box::pin(async move { Ok(()) }));
     ///
     /// let worker = Worker::new(queue, "queue".to_string(), handler)
     ///     .on_job_timeout(|event| {
     ///         println!("Job {} timed out after {:?}", event.job.id, event.duration);
     ///     });
+    /// # Ok(())
+    /// # }
     /// ```
     pub fn on_job_timeout<F>(mut self, handler: F) -> Self
     where
@@ -1234,16 +1249,19 @@ where
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use hammerwork::Worker;
     /// # use std::sync::Arc;
-    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await.unwrap()));
+    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let queue = Arc::new(hammerwork::JobQueue::new(sqlx::PgPool::connect("").await?));
     /// # let handler: hammerwork::worker::JobHandler = Arc::new(|job| Box::pin(async move { Ok(()) }));
     ///
     /// let worker = Worker::new(queue, "queue".to_string(), handler)
     ///     .on_job_retry(|event| {
     ///         println!("Retrying job {} due to: {:?}", event.job.id, event.error);
     ///     });
+    /// # Ok(())
+    /// # }
     /// ```
     pub fn on_job_retry<F>(mut self, handler: F) -> Self
     where
@@ -1451,7 +1469,7 @@ where
                         span.record("error.type", "timeout");
                         span.record(
                             "error.message",
-                            &format!("Job timed out after {:?}", timeout),
+                            format!("Job timed out after {:?}", timeout),
                         );
                     }
 
@@ -2687,8 +2705,10 @@ mod tests {
     #[test]
     fn test_scaling_decision_logic() {
         // This test simulates the scaling decision logic
-        let mut metrics = AutoscaleMetrics::default();
-        metrics.active_workers = 3;
+        let mut metrics = AutoscaleMetrics {
+            active_workers: 3,
+            ..Default::default()
+        };
 
         let config = AutoscaleConfig::default();
 
@@ -2735,14 +2755,13 @@ mod tests {
     #[test]
     fn test_queue_depth_averaging() {
         let now = Utc::now();
-        let mut history = Vec::new();
-
-        // Add some history entries
-        history.push((now - chrono::Duration::seconds(25), 10));
-        history.push((now - chrono::Duration::seconds(20), 8));
-        history.push((now - chrono::Duration::seconds(15), 12));
-        history.push((now - chrono::Duration::seconds(10), 6));
-        history.push((now - chrono::Duration::seconds(5), 14));
+        let history = vec![
+            (now - chrono::Duration::seconds(25), 10),
+            (now - chrono::Duration::seconds(20), 8),
+            (now - chrono::Duration::seconds(15), 12),
+            (now - chrono::Duration::seconds(10), 6),
+            (now - chrono::Duration::seconds(5), 14),
+        ];
 
         // Calculate average
         let avg =
@@ -2764,10 +2783,10 @@ mod tests {
     #[test]
     fn test_worker_count_boundaries() {
         let config = AutoscaleConfig::default();
-        let mut metrics = AutoscaleMetrics::default();
-
-        // Test scaling up to max workers
-        metrics.active_workers = config.max_workers - 1;
+        let mut metrics = AutoscaleMetrics {
+            active_workers: config.max_workers - 1,
+            ..Default::default()
+        };
         let new_count = (metrics.active_workers + config.scale_step).min(config.max_workers);
         assert_eq!(new_count, config.max_workers);
 
@@ -2813,14 +2832,13 @@ mod tests {
     #[test]
     fn test_history_cleanup() {
         let now = Utc::now();
-        let mut history = Vec::new();
-
-        // Add entries with various ages
-        history.push((now - chrono::Duration::seconds(60), 10)); // Too old
-        history.push((now - chrono::Duration::seconds(45), 8)); // Too old
-        history.push((now - chrono::Duration::seconds(25), 12)); // Recent
-        history.push((now - chrono::Duration::seconds(15), 6)); // Recent
-        history.push((now - chrono::Duration::seconds(5), 14)); // Recent
+        let mut history = vec![
+            (now - chrono::Duration::seconds(60), 10), // Too old
+            (now - chrono::Duration::seconds(45), 8),  // Too old
+            (now - chrono::Duration::seconds(25), 12), // Recent
+            (now - chrono::Duration::seconds(15), 6),  // Recent
+            (now - chrono::Duration::seconds(5), 14),  // Recent
+        ];
 
         // Filter based on 30-second window
         let evaluation_window = Duration::from_secs(30);

tests/batch_tests.rs

@@ -1,8 +1,9 @@
 mod test_utils;
 
 use hammerwork::{
-    Job,
+    BatchStatus, Job, JobStatus,
     batch::{JobBatch, PartialFailureMode},
+    queue::DatabaseQueue,
 };
 use serde_json::json;
 // use std::sync::Arc;