feat: Improve testapp and refine state transitions

- Refactor `testapp` module to improve code clarity and organization.
- Improve the `State` transition logic for better error handling and
  state management.  This prevents invalid state transitions.
- Enhance error handling in `ZInitError` for better error reporting.

Author: Mahmoud-Emad

src/bin/testapp.rs

@@ -1,9 +1,9 @@
 extern crate zinit;
 
 use anyhow::Result;
+use std::env;
 use std::path::Path;
 use tokio::time::{sleep, Duration};
-use std::env;
 
 use zinit::app::api::Client;
 use zinit::testapp;
@@ -12,8 +12,16 @@ use zinit::testapp;
 async fn main() -> Result<()> {
     // Define paths for socket and config
     let temp_dir = env::temp_dir();
-    let socket_path = temp_dir.join("zinit-test.sock").to_str().unwrap().to_string();
-    let config_dir = temp_dir.join("zinit-test-config").to_str().unwrap().to_string();
+    let socket_path = temp_dir
+        .join("zinit-test.sock")
+        .to_str()
+        .unwrap()
+        .to_string();
+    let config_dir = temp_dir
+        .join("zinit-test-config")
+        .to_str()
+        .unwrap()
+        .to_string();
 
     println!("Starting zinit with socket at: {}", socket_path);
     println!("Using config directory: {}", config_dir);
@@ -29,16 +37,22 @@ async fn main() -> Result<()> {
 
     // Create service configurations
     println!("Creating service configurations...");
-    
+
     // Create a find service
-    testapp::create_service_config(&config_dir, "find-service", "find / -name \"*.txt\" -type f").await?;
-    
+    testapp::create_service_config(
+        &config_dir,
+        "find-service",
+        "find / -name \"*.txt\" -type f",
+    )
+    .await?;
+
     // Create a sleep service with echo
     testapp::create_service_config(
-        &config_dir, 
-        "sleep-service", 
-        "sh -c 'echo Starting sleep; sleep 30; echo Finished sleep'"
-    ).await?;
+        &config_dir,
+        "sleep-service",
+        "sh -c 'echo Starting sleep; sleep 30; echo Finished sleep'",
+    )
+    .await?;
 
     // Wait for zinit to load the configurations
     sleep(Duration::from_secs(1)).await;
@@ -58,7 +72,7 @@ async fn main() -> Result<()> {
     // Start the find service
     println!("\nStarting find-service...");
     client.start("find-service").await?;
-    
+
     // Wait a bit and check status
     sleep(Duration::from_secs(2)).await;
     let status = client.status("find-service").await?;
@@ -67,7 +81,7 @@ async fn main() -> Result<()> {
     // Start the sleep service
     println!("\nStarting sleep-service...");
     client.start("sleep-service").await?;
-    
+
     // Wait a bit and check status
     sleep(Duration::from_secs(2)).await;
     let status = client.status("sleep-service").await?;
@@ -76,7 +90,7 @@ async fn main() -> Result<()> {
     // Stop the find service
     println!("\nStopping find-service...");
     client.stop("find-service").await?;
-    
+
     // Wait a bit and check status
     sleep(Duration::from_secs(2)).await;
     let status = client.status("find-service").await?;
@@ -85,15 +99,16 @@ async fn main() -> Result<()> {
     // Kill the sleep service with SIGTERM
     println!("\nKilling sleep-service with SIGTERM...");
     client.kill("sleep-service", "SIGTERM").await?;
-    
+
     // Wait a bit and check status
     sleep(Duration::from_secs(2)).await;
     let status = client.status("sleep-service").await?;
     println!("sleep-service status after killing: {:?}", status);
 
     // Cleanup - forget services
     println!("\nForgetting services...");
-    if status.pid == 0 {  // Only forget if it's not running
+    if status.pid == 0 {
+        // Only forget if it's not running
         client.forget("sleep-service").await?;
     }
     client.forget("find-service").await?;
@@ -104,4 +119,4 @@ async fn main() -> Result<()> {
 
     println!("\nTest completed successfully!");
     Ok(())
-}
+}

src/lib.rs

@@ -7,5 +7,5 @@ extern crate tokio;
 
 pub mod app;
 pub mod manager;
+pub mod testapp;
 pub mod zinit;
-pub mod testapp;

src/testapp/mod.rs

@@ -1,9 +1,9 @@
 use anyhow::Result;
+use std::env;
 use std::path::Path;
+use std::process::Stdio;
 use tokio::process::Command;
 use tokio::time::{sleep, Duration};
-use std::process::Stdio;
-use std::env;
 
 pub async fn start_zinit(socket_path: &str, config_dir: &str) -> Result<()> {
     // Create a temporary config directory if it doesn't exist
@@ -27,12 +27,12 @@ pub async fn start_zinit(socket_path: &str, config_dir: &str) -> Result<()> {
         .stderr(Stdio::piped());
 
     let child = cmd.spawn()?;
-    
+
     // Give zinit some time to start up
     sleep(Duration::from_secs(1)).await;
-    
+
     println!("Zinit started with PID: {:?}", child.id());
-    
+
     Ok(())
 }
 
@@ -54,4 +54,4 @@ dir: /
 
     tokio::fs::write(config_path, config_content).await?;
     Ok(())
-}
+}

src/zinit/errors.rs

@@ -59,16 +59,22 @@ impl ZInitError {
 
     /// Create a new InvalidStateTransition error
     pub fn invalid_state_transition<S: Into<String>>(message: S) -> Self {
-        ZInitError::InvalidStateTransition { message: message.into() }
+        ZInitError::InvalidStateTransition {
+            message: message.into(),
+        }
     }
 
     /// Create a new DependencyError error
     pub fn dependency_error<S: Into<String>>(message: S) -> Self {
-        ZInitError::DependencyError { message: message.into() }
+        ZInitError::DependencyError {
+            message: message.into(),
+        }
     }
 
     /// Create a new ProcessError error
     pub fn process_error<S: Into<String>>(message: S) -> Self {
-        ZInitError::ProcessError { message: message.into() }
+        ZInitError::ProcessError {
+            message: message.into(),
+        }
     }
-}
+}

src/zinit/state.rs

@@ -16,27 +16,27 @@ pub enum Target {
 pub enum State {
     /// Service is in an unknown state
     Unknown,
-    
+
     /// Blocked means one or more dependencies hasn't been met yet. Service can stay in
     /// this state as long as at least one dependency is not in either Running, or Success
     Blocked,
-    
+
     /// Service has been started, but it didn't exit yet, or we didn't run the test command.
     Spawned,
-    
+
     /// Service has been started, and test command passed.
     Running,
-    
+
     /// Service has exited with success state, only one-shot can stay in this state
     Success,
-    
+
     /// Service exited with this error, only one-shot can stay in this state
     Error(WaitStatus),
-    
+
     /// The service test command failed, this might (or might not) be replaced
     /// with an Error state later on once the service process itself exits
     TestFailure,
-    
+
     /// Failure means the service has failed to spawn in a way that retrying
     /// won't help, like command line parsing error or failed to fork
     Failure,
@@ -48,58 +48,59 @@ impl State {
         match (self, new_state) {
             // From Unknown state, any transition is valid
             (State::Unknown, _) => true,
-            
+
             // From Blocked state
             (State::Blocked, State::Spawned) => true,
             (State::Blocked, State::Failure) => true,
-            
+
             // From Spawned state
             (State::Spawned, State::Running) => true,
             (State::Spawned, State::TestFailure) => true,
             (State::Spawned, State::Error(_)) => true,
             (State::Spawned, State::Success) => true,
-            
+
             // From Running state
             (State::Running, State::Success) => true,
             (State::Running, State::Error(_)) => true,
-            
+
             // To Unknown or Blocked state is always valid
             (_, State::Unknown) => true,
             (_, State::Blocked) => true,
-            
+
             // Any other transition is invalid
             _ => false,
         }
     }
-    
+
     /// Attempt to transition to a new state, validating the transition
     pub fn transition_to(&self, new_state: State) -> Result<State, ZInitError> {
         if self.can_transition_to(&new_state) {
             Ok(new_state)
         } else {
-            Err(ZInitError::invalid_state_transition(
-                format!("Invalid transition from {:?} to {:?}", self, new_state)
-            ))
+            Err(ZInitError::invalid_state_transition(format!(
+                "Invalid transition from {:?} to {:?}",
+                self, new_state
+            )))
         }
     }
-    
+
     /// Check if the state is considered "active" (running or in progress)
     pub fn is_active(&self) -> bool {
         matches!(self, State::Running | State::Spawned)
     }
-    
+
     /// Check if the state is considered "terminal" (success or failure)
     pub fn is_terminal(&self) -> bool {
         matches!(self, State::Success | State::Error(_) | State::Failure)
     }
-    
+
     /// Check if the state is considered "successful"
     pub fn is_successful(&self) -> bool {
         matches!(self, State::Success | State::Running)
     }
-    
+
     /// Check if the state is considered "failed"
     pub fn is_failed(&self) -> bool {
         matches!(self, State::Error(_) | State::Failure | State::TestFailure)
     }
-}
+}

src/zinit/types.rs

@@ -1,8 +1,8 @@
 use nix::sys::wait::WaitStatus;
 use std::collections::HashMap;
 use std::sync::Arc;
-use tokio::sync::RwLock;
 use tokio::sync::watch;
+use tokio::sync::RwLock;
 use tokio_stream::wrappers::WatchStream;
 
 /// Extension trait for WaitStatus to check if a process exited successfully
@@ -56,4 +56,4 @@ where
     pub fn watcher(&self) -> Watcher<T> {
         WatchStream::new(self.tx.subscribe())
     }
-}
+}