add tests and fix job impl

src/client.rs

@@ -0,0 +1,349 @@
+//! Job client implementation for managing jobs in Redis
+
+use chrono::Utc;
+use redis::AsyncCommands;
+use crate::job::{Job, JobStatus, JobError};
+
+/// Client for managing jobs in Redis
+#[derive(Debug, Clone)]
+pub struct Client {
+    redis_client: redis::Client,
+    namespace: String,
+}
+
+pub struct ClientBuilder {
+    /// Redis URL for connection
+    redis_url: String,
+    /// Namespace for queue keys
+    namespace: String,
+}
+
+impl ClientBuilder {
+    /// Create a new client builder
+    pub fn new() -> Self {
+        Self {
+            redis_url: "redis://localhost:6379".to_string(),
+            namespace: "".to_string(),
+        }
+    }
+
+    /// Set the Redis URL
+    pub fn redis_url<S: Into<String>>(mut self, url: S) -> Self {
+        self.redis_url = url.into();
+        self
+    }
+
+    /// Set the namespace for queue keys
+    pub fn namespace<S: Into<String>>(mut self, namespace: S) -> Self {
+        self.namespace = namespace.into();
+        self
+    }
+
+    /// Build the client
+    pub async fn build(self) -> Result<Client, JobError> {
+        // Create Redis client
+        let redis_client = redis::Client::open(self.redis_url.as_str())
+            .map_err(|e| JobError::Redis(e))?;
+
+        Ok(Client {
+            redis_client,
+            namespace: self.namespace,
+        })
+    }
+}
+
+impl Default for Client {
+    fn default() -> Self {
+        // Note: Default implementation creates an empty client
+        // Use Client::builder() for proper initialization
+        Self {
+            redis_client: redis::Client::open("redis://localhost:6379").unwrap(),
+            namespace: "".to_string(),
+        }
+    }
+}
+
+impl Client {
+    /// Create a new client builder
+    pub fn builder() -> ClientBuilder {
+        ClientBuilder::new()
+    }
+
+    /// List all job IDs from Redis
+    pub async fn list_jobs(&self) -> Result<Vec<String>, JobError> {
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+        
+        let keys: Vec<String> = conn.keys(format!("{}:*", &self.jobs_key())).await
+            .map_err(|e| JobError::Redis(e))?;
+        let job_ids: Vec<String> = keys
+            .into_iter()
+            .filter_map(|key| {
+                if key.starts_with(&format!("{}:", self.jobs_key())) {
+                    key.strip_prefix(&format!("{}:", self.jobs_key()))
+                        .map(|s| s.to_string())
+                } else {
+                    None
+                }
+            })
+            .collect();
+        
+        Ok(job_ids)
+    }
+
+    fn jobs_key(&self) -> String {
+        if self.namespace.is_empty() {
+            format!("job")
+        } else {
+            format!("{}:job", self.namespace)
+        }
+    }
+
+    pub fn job_key(&self, job_id: &str) -> String {
+        if self.namespace.is_empty() {
+            format!("job:{}", job_id)
+        } else {
+            format!("{}:job:{}", self.namespace, job_id)
+        }
+    }
+
+    pub fn job_reply_key(&self, job_id: &str) -> String {
+        if self.namespace.is_empty() {
+            format!("reply:{}", job_id)
+        } else {
+            format!("{}:reply:{}", self.namespace, job_id)
+        }
+    }
+
+    pub fn runner_key(&self, runner_name: &str) -> String {
+        if self.namespace.is_empty() {
+            format!("runner:{}", runner_name)
+        } else {
+            format!("{}:runner:{}", self.namespace, runner_name)
+        }
+    }
+
+    /// Set job error in Redis
+    pub async fn set_error(&self,
+        job_id: &str,
+        error: &str,
+    ) -> Result<(), JobError> {
+        let job_key = self.job_key(job_id);
+        let now = Utc::now();
+        
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+            
+        let _: () = conn.hset_multiple(&job_key, &[
+                ("error", error),
+                ("status", JobStatus::Error.as_str()),
+                ("updated_at", &now.to_rfc3339()),
+            ]).await
+            .map_err(|e| JobError::Redis(e))?;
+
+        Ok(())
+    }
+
+    /// Set job status in Redis
+    pub async fn set_job_status(&self,
+        job_id: &str,
+        status: JobStatus,
+    ) -> Result<(), JobError> {
+        let job_key = self.job_key(job_id);
+        let now = Utc::now();
+        
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+            
+        let _: () = conn.hset_multiple(&job_key, &[
+                ("status", status.as_str()),
+                ("updated_at", &now.to_rfc3339()),
+            ]).await
+            .map_err(|e| JobError::Redis(e))?;
+        Ok(())
+    }
+
+    /// Get job status from Redis
+    pub async fn get_status(
+        &self,
+        job_id: &str,
+    ) -> Result<JobStatus, JobError> {
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+        
+        let status_str: Option<String> = conn.hget(&self.job_key(job_id), "status").await
+            .map_err(|e| JobError::Redis(e))?;
+        
+        match status_str {
+            Some(s) => JobStatus::from_str(&s).ok_or_else(|| JobError::InvalidStatus(s)),
+            None => Err(JobError::NotFound(job_id.to_string())),
+        }
+    }
+
+    /// Delete job from Redis
+    pub async fn delete_from_redis(
+        &self,
+        job_id: &str,
+    ) -> Result<(), JobError> {
+        let mut conn = self.redis_client
+                .get_multiplexed_async_connection()
+                .await
+                .map_err(|e| JobError::Redis(e))?;
+
+        let job_key = self.job_key(job_id);
+        let _: () = conn.del(&job_key).await
+            .map_err(|e| JobError::Redis(e))?;
+        Ok(())
+    }
+
+    /// Store this job in Redis
+    pub async fn store_job_in_redis(&self, job: &Job) -> Result<(), JobError> {
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+
+        let job_key = self.job_key(&job.id);
+        
+        // Serialize the job data
+        let job_data = serde_json::to_string(job)
+            .map_err(|e| JobError::Serialization(e))?;
+        
+        // Store job data in Redis hash
+        let _: () = conn.hset_multiple(&job_key, &[
+            ("data", job_data),
+            ("status", JobStatus::Dispatched.as_str().to_string()),
+            ("created_at", job.created_at.to_rfc3339()),
+            ("updated_at", job.updated_at.to_rfc3339()),
+        ]).await
+            .map_err(|e| JobError::Redis(e))?;
+
+        // Set TTL for the job (24 hours)
+        let _: () = conn.expire(&job_key, 86400).await
+            .map_err(|e| JobError::Redis(e))?;
+
+        Ok(())
+    }
+
+    /// Load a job from Redis by ID
+    pub async fn load_job_from_redis(
+        &self,
+        job_id: &str,
+    ) -> Result<Job, JobError> {
+        let job_key = self.job_key(job_id);
+        
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+
+        // Get job data from Redis
+        let job_data: Option<String> = conn.hget(&job_key, "data").await
+            .map_err(|e| JobError::Redis(e))?;
+        
+        match job_data {
+            Some(data) => {
+                let job: Job = serde_json::from_str(&data)
+                    .map_err(|e| JobError::Serialization(e))?;
+                Ok(job)
+            }
+            None => Err(JobError::NotFound(job_id.to_string())),
+        }
+    }
+
+    /// Delete a job by ID
+    pub async fn delete_job(&mut self, job_id: &str) -> Result<(), JobError> {
+        let mut conn = self.redis_client.get_multiplexed_async_connection().await
+            .map_err(|e| JobError::Redis(e))?;
+        
+        let job_key = self.job_key(job_id);
+        let deleted_count: i32 = conn.del(&job_key).await
+            .map_err(|e| JobError::Redis(e))?;
+        
+        if deleted_count == 0 {
+            return Err(JobError::NotFound(job_id.to_string()));
+        }
+        
+        Ok(())
+    }
+
+    /// Set job result in Redis
+    pub async fn set_result(
+        &self,
+        job_id: &str,
+        result: &str,
+    ) -> Result<(), JobError> {
+        let job_key = self.job_key(&job_id);
+        let now = Utc::now();
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+        let _: () = conn.hset_multiple(&job_key, &[
+            ("result", result),
+            ("status", JobStatus::Finished.as_str()),
+            ("updated_at", &now.to_rfc3339()),
+        ]).await
+            .map_err(|e| JobError::Redis(e))?;
+
+        Ok(())
+    }
+
+    /// Get job result from Redis
+    pub async fn get_result(
+        &self,
+        job_id: &str,
+    ) -> Result<Option<String>, JobError> {
+        let job_key = self.job_key(job_id);
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+        let result: Option<String> = conn.hget(&job_key, "result").await
+            .map_err(|e| JobError::Redis(e))?;
+        Ok(result)
+    }
+
+    /// Get a job ID from the work queue (blocking pop)
+    pub async fn get_job_id(&self, queue_key: &str) -> Result<Option<String>, JobError> {
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+        
+        // Use BRPOP with a short timeout to avoid blocking indefinitely
+        let result: Option<(String, String)> = conn.brpop(queue_key, 1.0).await
+            .map_err(|e| JobError::Redis(e))?;
+        
+        Ok(result.map(|(_, job_id)| job_id))
+    }
+
+    /// Get a job by ID (alias for load_job_from_redis)
+    pub async fn get_job(&self, job_id: &str) -> Result<Job, JobError> {
+        self.load_job_from_redis(job_id).await
+    }
+
+    /// Dispatch a job to a runner's queue
+    pub async fn dispatch_job(&self, job_id: &str, runner_name: &str) -> Result<(), JobError> {
+        let mut conn = self.redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .map_err(|e| JobError::Redis(e))?;
+
+        let queue_key = self.runner_key(runner_name);
+        
+        // Push job ID to the runner's queue (LPUSH for FIFO with BRPOP)
+        let _: () = conn.lpush(&queue_key, job_id).await
+            .map_err(|e| JobError::Redis(e))?;
+
+        Ok(())
+    }
+}