Refactoring dos testes

Author: PedroFFranca

src/stdlib/process.rs

@@ -1,115 +1,108 @@
-use std::process::{Child, ExitStatus};
 use std::io;
+use std::process::{Child, ExitStatus};
+#[cfg(not(windows))]
+use nix::{
+    sys::signal::{self, Signal},
+    unistd::Pid,
+};
 
 pub struct Processo {
-    processo: Child,
+    pub processo: Child,
 }
 
 impl Processo {
+
     #[cfg(windows)]
     pub fn terminate(&mut self) -> io::Result<()> {
-        // No Windows, .kill() já usa TerminateProcess, que é o comportamento
-        // esperado para terminate() e kill() do Python nessa plataforma.
         self.processo.kill()
     }
 
     #[cfg(not(windows))]
     pub fn terminate(&mut self) -> io::Result<()> {
-        // Em sistemas POSIX (Linux, macOS), precisamos enviar SIGTERM manualmente.
-        // O .kill() padrão do Rust enviaria SIGKILL, que é muito agressivo.
-        
-        // 1. Pega o PID (Process ID) do processo filho.
         let pid = Pid::from_raw(self.processo.id() as i32);
-
-        // 2. Envia o sinal SIGTERM para o PID.
         match signal::kill(pid, Signal::SIGTERM) {
             Ok(_) => Ok(()),
-            Err(e) => {
-                // 3. Converte o erro da crate 'nix' para um erro padrão 'std::io::Error'.
-                Err(io::Error::new(io::ErrorKind::Other, e))
-            }
+            Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
         }
-    
     }
-    #[cfg(test)]
-    mod tests {
-        use super::*; // Importa tudo do módulo pai (Processo, etc.)
-        use std::thread;
-        use std::time::Duration;
-
-        #[test]
-        fn test_process_creation_and_wait_success() {
-            // Testa o caso mais básico: criar um processo que termina com sucesso.
-            // O comando `sleep 0.1` é rápido e deve sair com código 0.
-            let mut processo = Processo::new("sleep", &["0.1"]).expect("Falha ao criar processo 'sleep'");
-            
-            let exit_code = processo.wait().expect("Falha ao esperar pelo processo");
-            
-            // Assert: Verificamos se o código de saída é 0 (sucesso).
-            assert_eq!(exit_code, 0);
-        }
 
-        #[test]
-        fn test_process_creation_fails_for_invalid_command() {
-            // Testa se a criação falha quando o comando não existe.
-            let resultado = Processo::new("comando_que_definitivamente_nao_existe_123", &[]);
-            
-            // Assert: Verificamos que o resultado é um erro.
-            assert!(resultado.is_err());
-        }
+    pub fn kill(&mut self) -> io::Result<()> {
+        self.processo.kill()
+    }
+   
+}
+mod tests {
+    use super::*; 
+    use std::process::Command;
+    use std::thread;
+    use std::time::Duration;
 
-        #[test]
-        fn test_terminate_long_running_process() {
-            // 1. SETUP: Inicia um processo que demoraria muito para terminar sozinho.
-            let mut processo = Processo::new("sleep", &["30"]).expect("Falha ao criar processo 'sleep 30'");
-            // Dá um tempinho para o SO realmente iniciar o processo.
-            thread::sleep(Duration::from_millis(100));
-
-            // 2. ACTION: Chama o método que queremos testar.
-            processo.terminate().expect("Falha ao enviar sinal de terminate");
-
-            // 3. ASSERT: Verifica o resultado.
-            let exit_code = processo.wait().expect("Falha ao esperar pelo processo terminado");
-
-            #[cfg(not(windows))]
-            {
-                // Em Linux/macOS, um processo terminado por sinal não tem um código de saída.
-                // Nossa função wait() converte isso para -1. Esta é a verificação correta!
-                assert_eq!(exit_code, -1, "Em POSIX, o código de saída de um processo terminado por sinal deve ser -1 (na nossa implementação)");
-            }
-            #[cfg(windows)]
-            {
-                // No Windows, TerminateProcess força um código de saída, que geralmente é 1.
-                assert_eq!(exit_code, 1, "No Windows, o código de saída de um processo terminado geralmente é 1");
-            }
+    fn create_long_running_command() -> Command {
+        if cfg!(windows) {
+            let mut cmd = Command::new("timeout");
+            cmd.arg("/T").arg("30");
+            cmd
+        } else {
+            let mut cmd = Command::new("sleep");
+            cmd.arg("30");
+            cmd
         }
+    }
 
-        #[test]
-        fn test_kill_long_running_process() {
-            // O teste para kill() é quase idêntico ao de terminate(),
-            // pois ambos resultam em um encerramento anormal.
-
-            // 1. SETUP
-            let mut processo = Processo::new("sleep", &["30"]).expect("Falha ao criar processo 'sleep 30'");
-            thread::sleep(Duration::from_millis(100));
-
-            // 2. ACTION
-            processo.kill().expect("Falha ao enviar sinal de kill");
-
-            // 3. ASSERT
-            let exit_code = processo.wait().expect("Falha ao esperar pelo processo morto");
-
-            #[cfg(not(windows))]
-            {
-                // SIGKILL também resulta em um código de saída "None", que mapeamos para -1.
-                assert_eq!(exit_code, -1, "Em POSIX, o código de saída de um processo morto por sinal deve ser -1");
-            }
-            #[cfg(windows)]
-            {
-                // O comportamento é o mesmo de terminate() no Windows.
-                assert_eq!(exit_code, 1, "No Windows, o código de saída de um processo morto geralmente é 1");
-            }
-        }
-    } 
-    
+    #[test]
+    fn test_terminate_a_running_process() {
+        let child = create_long_running_command()
+            .spawn()
+            .expect("Falha ao iniciar processo para o teste de terminate");
+
+        let mut processo = Processo { processo: child };
+
+        thread::sleep(Duration::from_millis(100));
+
+        processo.terminate().expect("Falha ao chamar terminate");
+
+        let exit_code = processo.wait().expect("Falha ao esperar pelo processo terminado");
+
+        let expected_code = if cfg!(windows) { 1 } else { -1 };
+        assert_eq!(exit_code, expected_code, "O código de saída após terminate não foi o esperado.");
+    }
+
+    #[test]
+    fn test_kill_a_running_process() {
+        let child = create_long_running_command()
+            .spawn()
+            .expect("Falha ao iniciar processo para o teste de kill");
+
+
+        let mut processo = Processo { processo: child };
+
+        thread::sleep(Duration::from_millis(100));
+
+        processo.kill().expect("Falha ao chamar kill");
+
+
+        let exit_code = processo.wait().expect("Falha ao esperar pelo processo morto");
+
+        let expected_code = if cfg!(windows) { 1 } else { -1 };
+        assert_eq!(exit_code, expected_code, "O código de saída após kill não foi o esperado.");
+    }
+
+    #[test]
+    fn test_wait_on_a_process_that_finishes_normally() {
+        let mut command = if cfg!(windows) {
+            let mut cmd = Command::new("timeout");
+            cmd.arg("/T").arg("1");
+            cmd
+        } else {
+            let mut cmd = Command::new("sleep");
+            cmd.arg("1");
+            cmd
+        };
+        
+        let child = command.spawn().expect("Falha ao iniciar processo curto");
+        let mut processo = Processo { processo: child };
+        
+        let exit_code = processo.wait().expect("Falha ao esperar pelo processo");
+        assert_eq!(exit_code, 0);
+    }
 }