feat(cli): made perseus test actually run tests

This massively improves the ease of testing Perseus apps.

Author: arctic-hen7

packages/perseus-cli/src/bin/main.rs

@@ -2,34 +2,36 @@ use clap::Parser;
 use command_group::stdlib::CommandGroup;
 use directories::ProjectDirs;
 use fmterr::fmt_err;
+use indicatif::MultiProgress;
 use notify::{recommended_watcher, RecursiveMode, Watcher};
 use perseus_cli::parse::{
-    BuildOpts, CheckOpts, ExportOpts, ServeOpts, SnoopServeOpts, SnoopSubcommand,
+    BuildOpts, CheckOpts, ExportOpts, ServeOpts, SnoopServeOpts, SnoopSubcommand, TestOpts,
 };
 use perseus_cli::{
     build, check_env, delete_artifacts, deploy, export, init, new,
     parse::{Opts, Subcommand},
-    serve, serve_exported, tinker,
+    serve, serve_exported, test, tinker,
 };
 use perseus_cli::{
     check, create_dist, delete_dist, errors::*, export_error_page, order_reload, run_reload_server,
     snoop_build, snoop_server, snoop_wasm_build, Tools,
 };
 use std::env;
 use std::path::{Path, PathBuf};
-use std::process::Command;
+use std::process::{Command, ExitCode};
 use std::sync::mpsc::channel;
 
 // All this does is run the program and terminate with the acquired exit code
 #[tokio::main]
-async fn main() {
+async fn main() -> ExitCode {
     // In development, we'll test in the `basic` example
     if cfg!(debug_assertions) && env::var("TEST_EXAMPLE").is_ok() {
         let example_to_test = env::var("TEST_EXAMPLE").unwrap();
         env::set_current_dir(example_to_test).unwrap();
     }
     let exit_code = real_main().await;
-    std::process::exit(exit_code)
+    let u8_exit_code: u8 = exit_code.try_into().unwrap_or(1);
+    ExitCode::from(u8_exit_code)
 }
 
 // This manages error handling and returns a definite exit code to terminate
@@ -129,6 +131,11 @@ async fn core(dir: PathBuf) -> Result<i32, Error> {
             custom_watch,
             ..
         })
+        | Subcommand::Test(TestOpts {
+            watch,
+            custom_watch,
+            ..
+        })
         | Subcommand::Snoop(SnoopSubcommand::Build {
             watch,
             custom_watch,
@@ -327,20 +334,19 @@ async fn core_watch(dir: PathBuf, opts: Opts) -> Result<i32, Error> {
                 delete_artifacts(dir.clone(), "mutable")?;
             }
             // This orders reloads internally
-            let (exit_code, _server_path) = serve(dir, serve_opts, &tools, &opts)?;
+            let (exit_code, _server_path) =
+                serve(dir, serve_opts, &tools, &opts, &MultiProgress::new(), false)?;
             exit_code
         }
         Subcommand::Test(ref test_opts) => {
             create_dist(&dir)?;
             let tools = Tools::new(&dir, &opts).await?;
-            // This will be used by the subcrates
-            env::set_var("PERSEUS_TESTING", "true");
             // Delete old build artifacts if `--no-build` wasn't specified
             if !test_opts.no_build {
                 delete_artifacts(dir.clone(), "static")?;
                 delete_artifacts(dir.clone(), "mutable")?;
             }
-            let (exit_code, _server_path) = serve(dir, test_opts, &tools, &opts)?;
+            let exit_code = test(dir, &test_opts, &tools, &opts)?;
             exit_code
         }
         Subcommand::Clean => {

packages/perseus-cli/src/deploy.rs

@@ -6,6 +6,7 @@ use crate::parse::{DeployOpts, ExportOpts, ServeOpts};
 use crate::serve;
 use fs_extra::copy_items;
 use fs_extra::dir::{copy as copy_dir, CopyOptions};
+use indicatif::MultiProgress;
 use std::fs;
 use std::path::PathBuf;
 
@@ -59,6 +60,9 @@ fn deploy_full(
         },
         tools,
         global_opts,
+        &MultiProgress::new(),
+        // We're not testing
+        false,
     )?;
     if serve_exit_code != 0 {
         return Ok(serve_exit_code);
@@ -160,7 +164,7 @@ fn deploy_full(
         Ok(0)
     } else {
         // If we don't have the executable, throw an error
-        Err(DeployError::GetServerExecutableFailed.into())
+        Err(ExecutionError::GetServerExecutableFailedSimple.into())
     }
 }
 

packages/perseus-cli/src/errors.rs

@@ -52,6 +52,8 @@ pub enum ExecutionError {
         #[source]
         source: serde_json::Error,
     },
+    #[error("couldn't get path to server executable (if this persists, try `perseus clean`)")]
+    GetServerExecutableFailedSimple,
     #[error("expected second-last message from Cargo to contain server executable path, none existed (too few messages) (report this as a bug if it persists)")]
     ServerExecutableMsgNotFound,
     #[error("couldn't parse server executable path from Cargo (report this as a bug if it persists): {err}")]
@@ -126,8 +128,6 @@ pub enum DeployError {
         #[source]
         source: std::io::Error,
     },
-    #[error("couldn't get path to server executable (if this persists, try `perseus clean`)")]
-    GetServerExecutableFailed,
     #[error("couldn't copy file from '{from}' to '{to}' for deployment packaging")]
     MoveAssetFailed {
         to: String,

packages/perseus-cli/src/lib.rs

@@ -31,6 +31,7 @@ mod reload_server;
 mod serve;
 mod serve_exported;
 mod snoop;
+mod test;
 mod thread;
 mod tinker;
 
@@ -52,6 +53,7 @@ pub use reload_server::{order_reload, run_reload_server};
 pub use serve::serve;
 pub use serve_exported::serve_exported;
 pub use snoop::{snoop_build, snoop_server, snoop_wasm_build};
+pub use test::test;
 pub use tinker::tinker;
 
 /// Creates the `dist/` directory in the project root, which is necessary

packages/perseus-cli/src/parse.rs

@@ -90,8 +90,7 @@ pub enum Subcommand {
     ExportErrorPage(ExportErrorPageOpts),
     Export(ExportOpts),
     Serve(ServeOpts),
-    /// Serves your app as `perseus serve` does, but puts it in testing mode
-    Test(ServeOpts),
+    Test(TestOpts),
     /// Removes build artifacts in the `dist/` directory
     Clean,
     Deploy(DeployOpts),
@@ -153,8 +152,7 @@ pub struct ExportErrorPageOpts {
     #[clap(short, long)]
     pub output: String,
 }
-/// Serves your app (set the `$HOST` and `$PORT` environment variables to change
-/// the location it's served at)
+/// Serves your app
 #[derive(Parser, Clone)]
 pub struct ServeOpts {
     /// Don't run the final binary, but print its location instead as the last
@@ -186,6 +184,33 @@ pub struct ServeOpts {
     #[clap(long, default_value = "8080")]
     pub port: u16,
 }
+/// Serves your app as `perseus serve` does, but puts it in testing mode
+#[derive(Parser, Clone)]
+pub struct TestOpts {
+    /// Only build the testing server, and use the results of a previous
+    /// `perseus build`
+    #[clap(long)]
+    pub no_build: bool,
+    /// Show the browser window when testing (by default, the browser is used in
+    /// 'headless' mode); this can be useful for debugging failing tests in
+    /// some cases
+    #[clap(long)]
+    pub show_browser: bool,
+    /// Watch the files in your working directory for changes (excluding
+    /// `target/` and `dist/`)
+    #[clap(short, long)]
+    pub watch: bool,
+    /// Marks a specific file/directory to be watched (directories will be
+    /// recursively watched)
+    #[clap(long)]
+    pub custom_watch: Vec<String>,
+    /// Where to host your exported app
+    #[clap(long, default_value = "127.0.0.1")]
+    pub host: String,
+    /// The port to host your exported app on
+    #[clap(long, default_value = "8080")]
+    pub port: u16,
+}
 /// Packages your app for deployment
 #[derive(Parser, Clone)]
 pub struct DeployOpts {

packages/perseus-cli/src/serve.rs

@@ -36,7 +36,8 @@ macro_rules! handle_exit_code {
 fn build_server(
     dir: PathBuf,
     spinners: &MultiProgress,
-    did_build: bool,
+    num_steps: u8,
+    step_offset: u8,
     exec: Arc<Mutex<String>>,
     is_release: bool,
     tools: &Tools,
@@ -49,15 +50,11 @@ fn build_server(
     let Opts {
         cargo_engine_args, ..
     } = global_opts.clone();
-    let num_steps = match did_build {
-        true => 4,
-        false => 2,
-    };
 
     // Server building message
     let sb_msg = format!(
         "{} {} Building server",
-        style(format!("[{}/{}]", num_steps - 1, num_steps))
+        style(format!("[{}/{}]", num_steps - step_offset, num_steps))
             .bold()
             .dim(),
         BUILDING_SERVER
@@ -66,7 +63,7 @@ fn build_server(
     // We'll parallelize the building of the server with any build commands that are
     // currently running We deliberately insert the spinner at the end of the
     // list
-    let sb_spinner = spinners.insert(num_steps - 1, ProgressBar::new_spinner());
+    let sb_spinner = spinners.insert((num_steps - step_offset).into(), ProgressBar::new_spinner());
     let sb_spinner = cfg_spinner(sb_spinner, &sb_msg);
     let sb_target = dir;
     let sb_thread = spawn_thread(
@@ -133,16 +130,13 @@ fn build_server(
 
 /// Runs the server at the given path, handling any errors therewith. This will
 /// likely be a black hole until the user manually terminates the process.
+///
+/// This function is not used by the testing process.
 fn run_server(
     exec: Arc<Mutex<String>>,
     dir: PathBuf,
-    did_build: bool,
+    num_steps: u8,
 ) -> Result<i32, ExecutionError> {
-    let num_steps = match did_build {
-        true => 4,
-        false => 2,
-    };
-
     // First off, handle any issues with the executable path
     let exec_val = exec.lock().unwrap();
     if exec_val.is_empty() {
@@ -214,32 +208,52 @@ pub fn serve(
     opts: &ServeOpts,
     tools: &Tools,
     global_opts: &Opts,
+    spinners: &MultiProgress,
+    testing: bool,
 ) -> Result<(i32, Option<String>), ExecutionError> {
     // Set the environment variables for the host and port
     // NOTE Another part of this code depends on setting these in this way
     env::set_var("PERSEUS_HOST", &opts.host);
     env::set_var("PERSEUS_PORT", opts.port.to_string());
 
-    let spinners = MultiProgress::new();
     let did_build = !opts.no_build;
     let should_run = !opts.no_run;
+
+    // Weird naming here, but this is right
+    let num_steps = if testing && did_build {
+        4
+    } else if testing && !did_build {
+        3
+    } else if !testing && did_build {
+        4
+    } else {
+        2
+    };
+
     // We need to have a way of knowing what the executable path to the server is
     let exec = Arc::new(Mutex::new(String::new()));
     // We can begin building the server in a thread without having to deal with the
     // rest of the build stage yet
     let sb_thread = build_server(
         dir.clone(),
         &spinners,
-        did_build,
+        num_steps,
+        if testing { 2 } else { 1 },
         Arc::clone(&exec),
         opts.release,
         tools,
         global_opts,
     )?;
     // Only build if the user hasn't set `--no-build`, handling non-zero exit codes
     if did_build {
-        let (sg_thread, wb_thread) =
-            build_internal(dir.clone(), &spinners, 4, opts.release, tools, global_opts)?;
+        let (sg_thread, wb_thread) = build_internal(
+            dir.clone(),
+            &spinners,
+            num_steps,
+            opts.release,
+            tools,
+            global_opts,
+        )?;
         let sg_res = sg_thread
             .join()
             .map_err(|_| ExecutionError::ThreadWaitFailed)??;
@@ -268,13 +282,17 @@ pub fn serve(
 
     // Now actually run that executable path if we should
     if should_run {
-        let exit_code = run_server(Arc::clone(&exec), dir, did_build)?;
+        let exit_code = run_server(Arc::clone(&exec), dir, num_steps)?;
         Ok((exit_code, None))
     } else {
         // The user doesn't want to run the server, so we'll give them the executable
         // path instead
         let exec_str = (*exec.lock().unwrap()).to_string();
-        println!("Not running server because `--no-run` was provided. You can run it manually by running the following executable from the root of the project.\n{}", &exec_str);
+        // Only tell the user about this if we're not testing (which is a whole separate
+        // workflow)
+        if !testing {
+            println!("Not running server because `--no-run` was provided. You can run it manually by running the following executable from the root of the project.\n{}", &exec_str);
+        }
         Ok((0, Some(exec_str)))
     }
 }