update e2e tests

Author: branchseer

crates/vite_task_bin/test_bins/package.json

@@ -1,11 +1,12 @@
 {
-  "name": "vite-task-tests-bins",
+  "name": "vite-task-test-bins",
   "private": true,
   "bin": {
-    "readfile": "./readfile.mjs"
+    "print-file": "./src/print-file.ts",
+    "json-edit": "./src/json-edit.ts"
   },
   "dependencies": {
     "oxlint": "catalog:",
-    "vite-task-tests-bins": "link:"
+    "vite-task-test-bins": "link:"
   }
 }

crates/vite_task_bin/test_bins/src/json-edit.ts

@@ -0,0 +1,21 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { parseArgs } from 'node:util';
+
+const { positionals } = parseArgs({
+  allowPositionals: true,
+});
+
+const filename = positionals[0];
+const script = positionals[1];
+
+if (!filename || !script) {
+  console.error('Usage: json-edit <filename> <script>');
+  console.error('Example: json-edit package.json \'_.version = "1.2.3"\'');
+  process.exit(1);
+}
+
+const json = JSON.parse(readFileSync(filename, 'utf-8'));
+const func = new Function('_', script + '; return _;');
+const result = func(json);
+
+writeFileSync(filename, JSON.stringify(result, null, 2) + '\n', 'utf-8');

…tes/vite_task_bin/test_bins/readfile.mjs …ite_task_bin/test_bins/src/print-file.tscrates/vite_task_bin/test_bins/readfile.mjs renamed to crates/vite_task_bin/test_bins/src/print-file.ts crates/vite_task_bin/test_bins/readfile.mjs renamed to crates/vite_task_bin/test_bins/src/print-file.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from 'fs';
+import { readFileSync } from 'node:fs';
 
 const content = readFileSync(process.argv[2]);
 process.stdout.write(content);

crates/vite_task_bin/tests/test_snapshots/fixtures/cache-keys/package.json

@@ -1,6 +1,7 @@
 {
   "scripts": {
     "lint": "vite lint",
+    "hello": "print-file",
     "lint-and-echo": "vite lint && echo",
     "echo-and-lint": "echo Linting && vite lint"
   }

crates/vite_task_bin/tests/test_snapshots/fixtures/cache-keys/snapshots.toml

@@ -1,22 +1,26 @@
 [[plan]]
-name = "user task cache key"
+name = "synthetic task in user task"
 args = ["run", "lint"]
 
 [[plan]]
-name = "user task cache key with extra args"
+name = "synthetic task with extra args in user task"
 args = ["run", "lint", "--fix"]
 
 [[plan]]
-name = "direct synthetic task cache key"
+name = "normal task with extra args"
+args = ["run", "hello", "a.txt"]
+
+[[plan]]
+name = "direct synthetic task"
 args = ["lint"]
 
 [[plan]]
-name = "direct synthetic task cache key with cwd"
+name = "direct synthetic task with cwd"
 cwd = "subdir"
 args = ["lint"]
 
 [[plan]]
-name = "direct synthetic task cache key with extra args"
+name = "direct synthetic task with extra args"
 args = ["lint", "--fix"]
 
 [[plan]]
@@ -26,3 +30,9 @@ args = ["run", "lint-and-echo", "Linting complete"]
 [[plan]]
 name = "echo and lint with extra args"
 args = ["run", "echo-and-lint", "--fix"]
+
+[[e2e]]
+name = "direct lint"
+steps = [
+  "vite lint",
+]

crates/vite_task_bin/tests/test_snapshots/main.rs

@@ -1,9 +1,18 @@
 mod redact;
 
-use std::{collections::HashMap, convert::Infallible, ffi::OsStr, path::Path, sync::Arc};
+use std::{
+    collections::HashMap,
+    convert::Infallible,
+    env::{self, join_paths, split_paths},
+    ffi::OsStr,
+    fmt::format,
+    path::Path,
+    process::Command,
+    sync::Arc,
+};
 
 use copy_dir::copy_dir;
-use redact::redact_snapshot;
+use redact::{redact_e2e_output, redact_snapshot};
 use tokio::runtime::Runtime;
 use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
@@ -21,6 +30,9 @@ struct Plan {
 
 #[derive(serde::Deserialize, Debug)]
 struct E2e {
+    pub name: Str,
+    #[serde(default)]
+    pub cwd: RelativePathBuf,
     pub steps: Vec<Str>,
 }
 
@@ -62,26 +74,47 @@ fn run_case(runtime: &Runtime, tmpdir: &AbsolutePath, fixture_path: &Path) {
         Err(err) => panic!("Failed to read cases.toml for fixture {}: {}", fixture_name, err),
     };
 
-    // Add bins to PATH so test programs (such as readfile) in fixtures can be found.
-    let envs: HashMap<Arc<OsStr>, Arc<OsStr>> = [(
-        Arc::<OsStr>::from(OsStr::new("PATH")),
-        Arc::<OsStr>::from(
-            std::env::current_dir()
-                .unwrap()
-                .join("test_bins")
-                .join("node_modules")
-                .join(".bin")
-                .into_os_string(),
+    let test_bin_path = Arc::<OsStr>::from(
+        std::env::current_dir()
+            .unwrap()
+            .join("test_bins")
+            .join("node_modules")
+            .join(".bin")
+            .into_os_string(),
+    );
+
+    // Add test_bins to PATH so test programs (such as print-file) in fixtures can be found.
+    let plan_envs: HashMap<Arc<OsStr>, Arc<OsStr>> =
+        [(Arc::<OsStr>::from(OsStr::new("PATH")), Arc::clone(&test_bin_path))]
+            .into_iter()
+            .collect();
+
+    // Prepare PATH for e2e tests
+    let e2e_env_path = join_paths(
+        [
+            // Include vite binary path to PATH so that e2e tests can run "vite ..." commands.
+            {
+                let vite_path = AbsolutePath::new(env!("CARGO_BIN_EXE_vite")).unwrap();
+                let vite_dir = vite_path.parent().unwrap();
+                vite_dir.as_path().as_os_str().into()
+            },
+            // Include test_bins to PATH so that e2e tests can run utilities such as json-edit.
+            test_bin_path,
+        ]
+        .into_iter()
+        .chain(
+            // the existing PATH
+            split_paths(&env::var_os("PATH").unwrap())
+                .map(|path| Arc::<OsStr>::from(path.into_os_string())),
         ),
-    )]
-    .into_iter()
-    .collect();
+    )
+    .unwrap();
 
     runtime.block_on(async {
         let workspace_root_str = workspace_root.path.as_path().to_str().unwrap();
         let mut owned_callbacks = vite_task_bin::OwnedSessionCallbacks::default();
         let mut session = Session::init_with(
-            envs,
+            plan_envs,
             Arc::clone(&workspace_root.path),
             owned_callbacks.as_callbacks(),
         )
@@ -95,6 +128,7 @@ fn run_case(runtime: &Runtime, tmpdir: &AbsolutePath, fixture_path: &Path) {
         );
         insta::assert_json_snapshot!("task graph", task_graph_json);
 
+        let mut e2e_count = 0u32;
         for plan in cases_file.plan_cases {
             let snapshot_name = format!("query - {}", plan.name);
 
@@ -126,29 +160,48 @@ fn run_case(runtime: &Runtime, tmpdir: &AbsolutePath, fixture_path: &Path) {
 
             let plan_json = redact_snapshot(&plan, workspace_root_str);
             insta::assert_json_snapshot!(snapshot_name, &plan_json);
-
-            //     let cwd: Arc<AbsolutePath> = case_stage_path.join(&cli_query.cwd).into();
-            //     let task_query = match cli_task_query.into_task_query(&cwd) {
-            //         Ok(ok) => ok,
-            //         Err(err) => {
-            //             insta::assert_json_snapshot!(snapshot_name, err);
-            //             continue;
-            //         }
-            //     };
-
-            //     let execution_graph = match indexed_task_graph.query_tasks(task_query) {
-            //         Ok(ok) => ok,
-            //         Err(err) => {
-            //             insta::assert_json_snapshot!(snapshot_name, err);
-            //             continue;
-            //         }
-            //     };
-
-            //     let execution_graph_snapshot =
-            //         snapshot_execution_graph(&execution_graph, &indexed_task_graph);
-            //     insta::assert_json_snapshot!(snapshot_name, execution_graph_snapshot);
         }
-        for e2e in cases_file.e2e_cases {}
+        for e2e in cases_file.e2e_cases {
+            let e2e_stage_path = tmpdir.join(format!("e2e_stage_{}", e2e_count));
+            e2e_count += 1;
+            assert!(copy_dir(fixture_path, &e2e_stage_path).unwrap().is_empty());
+
+            let e2e_stage_path_str = e2e_stage_path.as_path().to_str().unwrap();
+
+            let mut e2e_outputs = String::new();
+            for step in e2e.steps {
+                let mut cmd = if cfg!(windows) {
+                    let mut cmd = Command::new("cmd.exe");
+                    // https://github.com/nodejs/node/blob/dbd24b165128affb7468ca42f69edaf7e0d85a9a/lib/child_process.js#L633
+                    cmd.args(["/d", "/s", "/c"]);
+                    cmd
+                } else {
+                    let mut cmd = Command::new("sh");
+                    cmd.args(["-c"]);
+                    cmd
+                };
+                cmd.arg(step.as_str())
+                    .env_clear()
+                    .env("PATH", &e2e_env_path)
+                    .current_dir(e2e_stage_path.join(&e2e.cwd));
+                let output = cmd.output().unwrap();
+
+                let exit_code = output.status.code().unwrap_or(-1);
+                if exit_code != 0 {
+                    e2e_outputs.push_str(format!("[{}]", exit_code).as_str());
+                }
+                e2e_outputs.push_str("> ");
+                e2e_outputs.push_str(step.as_str());
+                e2e_outputs.push('\n');
+
+                let stdout = String::from_utf8(output.stdout).unwrap();
+                let stderr = String::from_utf8(output.stderr).unwrap();
+                e2e_outputs.push_str(&redact_e2e_output(stdout, e2e_stage_path_str));
+                e2e_outputs.push_str(&redact_e2e_output(stderr, e2e_stage_path_str));
+                e2e_outputs.push('\n');
+            }
+            insta::assert_snapshot!(e2e.name.as_str(), e2e_outputs);
+        }
     });
 }
 

crates/vite_task_bin/tests/test_snapshots/redact.rs

@@ -20,27 +20,40 @@ fn visit_json(value: &mut serde_json::Value, f: &mut impl FnMut(&mut serde_json:
     }
 }
 
-fn redact_paths(value: &mut serde_json::Value, redactions: &[(&str, &str)]) {
-    use cow_utils::CowUtils as _;
+fn redact_string_in_json(value: &mut serde_json::Value, redactions: &[(&str, &str)]) {
     visit_json(value, &mut |v| {
         if let serde_json::Value::String(s) = v {
-            for (from, to) in redactions {
-                if let Cow::Owned(mut replaced) = s.as_str().cow_replace(from, to) {
-                    if cfg!(windows) {
-                        // Also replace with backslashes on Windows
-                        replaced = replaced.cow_replace("\\", "/").into_owned();
-                    }
-                    *s = replaced;
-                }
-            }
+            redact_string(s, redactions);
         }
     });
 }
 
+fn redact_string(s: &mut String, redactions: &[(&str, &str)]) {
+    use cow_utils::CowUtils as _;
+    for (from, to) in redactions {
+        if let Cow::Owned(mut replaced) = s.as_str().cow_replace(from, to) {
+            if cfg!(windows) {
+                // Also replace with backslashes on Windows
+                replaced = replaced.cow_replace("\\", "/").into_owned();
+            }
+            *s = replaced;
+        }
+    }
+}
+
+pub fn redact_e2e_output(mut output: String, workspace_root: &str) -> String {
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    redact_string(
+        &mut output,
+        &[(workspace_root, "<workspace>"), (manifest_dir.as_str(), "<manifest_dir>")],
+    );
+    output
+}
+
 pub fn redact_snapshot(value: &impl Serialize, workspace_root: &str) -> serde_json::Value {
     let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
     let mut json_value = serde_json::to_value(value).unwrap();
-    redact_paths(
+    redact_string_in_json(
         &mut json_value,
         &[(workspace_root, "<workspace>"), (manifest_dir.as_str(), "<manifest_dir>")],
     );