use tokio process test command

Author: lamb

cmd/Cargo.toml

@@ -18,6 +18,6 @@ clap = { version = "4.5.28", features = ["derive"] }
 tokio = { version = "1.43.0", features = ["rt-multi-thread", "macros", "signal", "time", "sync", "io-std"] }
 
 [dev-dependencies]
-assert_cmd = "2.0.16"
 assert_fs = "1.1.2"
-predicates = "3.1.3"
+tokio = { version = "1.43.0", features = ["process"] }
+axum = "0.8.1"

cmd/tests/command.rs

@@ -1,76 +1,87 @@
-use assert_cmd::prelude::*;
 use assert_fs::prelude::*;
-use predicates::prelude::*;
-use std::io::Write;
-use std::process::{Command, Stdio};
+use axum::routing::get;
+use axum::Router;
+use std::process::Stdio;
+use tokio::io::AsyncWriteExt;
+use tokio::process::Command;
 
-#[test]
-#[allow(clippy::zombie_processes)]
-fn test_command_repl() -> Result<(), Box<dyn std::error::Error>> {
-    let mut child = Command::cargo_bin("basjoofan")?
+#[tokio::test]
+async fn test_command_repl() -> Result<(), Box<dyn std::error::Error>> {
+    let mut child = Command::new("basjoofan")
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .spawn()
         .expect("Failed to spawn child process");
     if let Some(mut stdin) = child.stdin.take() {
-        stdin
-            .write_all("let x = 1 + 1; println(\"{x}\", x);\n".as_bytes())
-            .expect("Failed to write to stdin");
-        stdin.write_all("exit".as_bytes()).expect("Failed to write to stdin");
+        stdin.write_all("let x = 1 + 1; println(\"{x}\", x);\n".as_bytes()).await?;
+        stdin.write_all("exit".as_bytes()).await?;
     }
-    let output = child.wait_with_output().expect("Failed to read stdout");
+    let output = child.wait_with_output().await?;
     println!("output:{}", String::from_utf8_lossy(&output.stdout).trim());
     assert!(String::from_utf8_lossy(&output.stdout).trim() == "2\nnull");
     Ok(())
 }
 
-#[test]
-fn test_command_eval() -> Result<(), Box<dyn std::error::Error>> {
-    let mut cmd = Command::cargo_bin("basjoofan")?;
-    cmd.arg("eval").arg(r#"print("{integer}", 1 + 1 )"#);
-    cmd.assert().success().stdout(predicate::str::diff("2null\n"));
-    let mut cmd = Command::cargo_bin("basjoofan")?;
-    cmd.arg("eval").arg(r#"let x = 1 + 1; print("{integer}", x);"#);
-    cmd.assert().success().stdout(predicate::str::diff("2null\n"));
-    let mut cmd = Command::cargo_bin("basjoofan")?;
-    cmd.arg("eval").arg(r#"println("{string}", "Hello Basjoofan!")"#);
-    cmd.assert().success().stdout(predicate::str::diff("Hello Basjoofan!\nnull\n"));
+#[tokio::test]
+async fn test_command_eval() -> Result<(), Box<dyn std::error::Error>> {
+    let mut cmd = Command::new("basjoofan");
+    let output = cmd.arg("eval").arg(r#"print("{integer}", 1 + 1 )"#).output().await?;
+    assert!(output.status.success());
+    assert_eq!(String::from_utf8(output.stdout)?, "2null\n");
+    let mut cmd = Command::new("basjoofan");
+    let output = cmd.arg("eval").arg(r#"let x = 1 + 1; print("{integer}", x);"#).output().await?;
+    assert!(output.status.success());
+    assert_eq!(String::from_utf8(output.stdout)?, "2null\n");
+    let mut cmd = Command::new("basjoofan");
+    let output = cmd.arg("eval").arg(r#"println("{string}", "Hello Basjoofan!")"#).output().await?;
+    assert!(output.status.success());
+    assert_eq!(String::from_utf8(output.stdout)?, "Hello Basjoofan!\nnull\n");
     Ok(())
 }
 
-#[test]
-fn test_command_test() -> Result<(), Box<dyn std::error::Error>> {
+#[tokio::test]
+async fn test_command_test() -> Result<(), Box<dyn std::error::Error>> {
+    let router = Router::new().route("/hello", get(|| async { "Hello, World!" }));
+    let listener = tokio::net::TcpListener::bind(("127.0.0.1", 8888)).await.unwrap();
+    tokio::spawn(async move {
+        axum::serve(listener, router).await.unwrap();
+    });
     let temp = assert_fs::TempDir::new().unwrap();
-    let file = temp.child(format!("request.{}", "fan"));
+    let file = temp.child("request.fan");
     let text = r#"
-    let host = "httpbin.org";
-    request get`
-        GET http://{host}/get
+    let host = "localhost:8888";
+    request hello`
+        GET http://{host}/hello
         Host: {host}
-        Connection: close
     `[status == 200];
 
     test call {
-        let response = get();
+        let response = hello();
         response.status
     }
     "#;
     file.write_str(text)?;
     // command test
-    let mut command = Command::cargo_bin("basjoofan")?;
+    let mut command = Command::new("basjoofan");
     command.current_dir(&temp);
-    command.arg("test");
-    command.assert().success().stdout(predicate::str::contains("--- PASS  get ("));
+    let output = command.arg("test").output().await?;
+    assert!(output.status.success());
+    let stdout = String::from_utf8(output.stdout)?;
+    let stderr = String::from_utf8(output.stderr)?;
+    println!("stdout:{}", stdout);
+    println!("stderr:{}", stderr);
+    assert!(stdout.contains("--- PASS  hello ("));
     // command test call
-    let mut command = Command::cargo_bin("basjoofan")?;
+    let mut command = Command::new("basjoofan");
     command.current_dir(&temp);
-    command.arg("test").arg("call");
-    command.assert().success().stdout(predicate::str::contains("--- PASS  get ("));
+    let output = command.arg("test").arg("call").output().await?;
+    assert!(output.status.success());
+    assert!(String::from_utf8(output.stdout)?.contains("--- PASS  hello ("));
     // command test blank
-    let mut command = Command::cargo_bin("basjoofan")?;
+    let mut command = Command::new("basjoofan");
     command.current_dir(&temp);
-    command.arg("test").arg("blank");
-    command.assert().success().stdout(predicate::str::diff("Test not found: blank\n"));
-
+    let output = command.arg("test").arg("blank").output().await?;
+    assert!(output.status.success());
+    assert_eq!(String::from_utf8(output.stdout)?, "Test not found: blank\n");
     Ok(())
 }