@verdaccio/e2e-cli 2.10.1 → 3.0.0

package/src/main.rs

@@ -0,0 +1,1411 @@
+use anyhow::{anyhow, bail, Context, Result};
+use clap::Parser;
+use reqwest::blocking::Client;
+use serde_json::{json, Value};
+use std::collections::{BTreeMap, BTreeSet};
+use std::env;
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+use tempfile::{Builder, TempDir};
+use url::Url;
+
+mod e2e_tests;
+mod scenarios;
+
+static RUN_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+const RESET: &str = "\x1b[0m";
+const RED: &str = "\x1b[31m";
+const GREEN: &str = "\x1b[32m";
+const YELLOW: &str = "\x1b[33m";
+const CYAN: &str = "\x1b[36m";
+const DIM: &str = "\x1b[2m";
+const BOLD: &str = "\x1b[1m";
+
+#[derive(Parser, Debug)]
+#[command(
+    name = "verdaccio-e2e",
+    disable_version_flag = true,
+    after_help = "Examples:\n  verdaccio-e2e -r http://localhost:4873 --pm npm --pm pnpm\n  verdaccio-e2e -r http://localhost:4873 --test publish --test install\n  verdaccio-e2e -r http://localhost:4873 --pm yarn-modern@4 -v"
+)]
+struct Cli {
+    #[arg(short = 'r', long = "registry")]
+    registry: String,
+    #[arg(long = "pm")]
+    pm: Vec<String>,
+    #[arg(short = 't', long = "test")]
+    test: Vec<String>,
+    #[arg(short = 'c', long = "concurrency", default_value_t = 1)]
+    concurrency: usize,
+    #[arg(long = "timeout", default_value_t = 50_000)]
+    timeout: u64,
+    #[arg(long = "token")]
+    token: Option<String>,
+    #[arg(short = 'v', long = "verbose")]
+    verbose: bool,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum AdapterType {
+    Npm,
+    Pnpm,
+    YarnClassic,
+    YarnModern,
+    Bun,
+    Deno,
+}
+
+#[derive(Clone, Debug)]
+struct Adapter {
+    name: String,
+    kind: AdapterType,
+    bin: String,
+    supports: BTreeSet<&'static str>,
+    version: String,
+    yarn_major: u64,
+}
+
+#[derive(Debug)]
+struct ExecOutput {
+    stdout: String,
+    stderr: String,
+}
+
+#[derive(Debug)]
+struct TestResult {
+    name: &'static str,
+    passed: bool,
+    duration: Duration,
+    error: Option<String>,
+    sub_tests: Vec<SubTestResult>,
+}
+
+#[derive(Debug)]
+struct SubTestResult {
+    label: &'static str,
+    passed: bool,
+    duration: Duration,
+    error: Option<String>,
+}
+
+#[derive(Debug)]
+struct SuiteResult {
+    adapter: String,
+    tests: Vec<TestResult>,
+    passed: usize,
+    failed: usize,
+    skipped: usize,
+    duration: Duration,
+}
+
+struct RunState {
+    temp_dirs: Vec<TempDir>,
+    verbose: bool,
+}
+
+struct TestContext<'a> {
+    registry_url: String,
+    token: String,
+    adapter: Adapter,
+    run_id: String,
+    timeout: Duration,
+    deadline: Instant,
+    state: &'a mut RunState,
+    sub_results: Vec<SubTestResult>,
+}
+
+struct TestDefinition {
+    name: &'static str,
+    requires: &'static [&'static str],
+    applies_to: fn(&Adapter) -> bool,
+    run: fn(&mut TestContext<'_>) -> Result<()>,
+}
+
+fn main() {
+    let code = match run() {
+        Ok(code) => code,
+        Err(err) => {
+            eprintln!("{RED}Error:{RESET} {err:#}");
+            1
+        }
+    };
+    std::process::exit(code);
+}
+
+fn run() -> Result<i32> {
+    let cli = Cli::parse();
+    let mut state = RunState {
+        temp_dirs: Vec::new(),
+        verbose: cli.verbose,
+    };
+
+    let run_dir = create_temp_dir(&mut state, "e2e-run")?;
+    env::set_current_dir(run_dir.path()).context("failed to enter isolated run directory")?;
+
+    println!("Checking registry at {}...", cli.registry);
+    if !ping_registry(&cli.registry) {
+        bail!("Registry at {} is not reachable", cli.registry);
+    }
+    println!("Registry is alive.");
+
+    let token = match cli.token {
+        Some(token) => token,
+        None => {
+            println!("Creating test user...");
+            let user = format!("e2e-user-{}", now_millis());
+            let token = create_user(&cli.registry, &user, "e2e-test-password")?;
+            println!("User \"{user}\" created.");
+            token
+        }
+    };
+
+    let adapters = parse_adapters(&cli.pm, &mut state)?;
+    println!(
+        "Adapters: {}",
+        adapters
+            .iter()
+            .map(|adapter| adapter.name.as_str())
+            .collect::<Vec<_>>()
+            .join(", ")
+    );
+
+    let tests = e2e_tests::all_tests();
+    let selected = if cli.test.is_empty() {
+        tests.iter().map(|test| test.name).collect::<Vec<_>>()
+    } else {
+        cli.test.iter().map(String::as_str).collect::<Vec<_>>()
+    };
+    println!("Tests: {}", selected.join(", "));
+
+    let results = run_all(
+        &adapters,
+        &tests,
+        &cli.registry,
+        &token,
+        &cli.test,
+        cli.timeout,
+        &mut state,
+    );
+    report_summary(&results)?;
+    Ok(if results.iter().any(|suite| suite.failed > 0) {
+        1
+    } else {
+        0
+    })
+}
+
+fn run_all(
+    adapters: &[Adapter],
+    tests: &[TestDefinition],
+    registry_url: &str,
+    token: &str,
+    test_filter: &[String],
+    timeout_ms: u64,
+    state: &mut RunState,
+) -> Vec<SuiteResult> {
+    let mut results = Vec::new();
+    for adapter in adapters {
+        results.push(run_suite(
+            adapter,
+            tests,
+            registry_url,
+            token,
+            test_filter,
+            timeout_ms,
+            state,
+        ));
+    }
+    results
+}
+
+fn run_suite(
+    adapter: &Adapter,
+    tests: &[TestDefinition],
+    registry_url: &str,
+    token: &str,
+    test_filter: &[String],
+    timeout_ms: u64,
+    state: &mut RunState,
+) -> SuiteResult {
+    let suite_start = Instant::now();
+    let mut results = Vec::new();
+    let mut skipped = 0usize;
+    println!("\n{BOLD}{CYAN}{}{RESET}", adapter.name);
+
+    for test in tests {
+        if !test_filter.is_empty() && !test_filter.iter().any(|name| name == test.name) {
+            continue;
+        }
+        let unsupported = test
+            .requires
+            .iter()
+            .any(|command| !adapter.supports.contains(command));
+        if unsupported || !(test.applies_to)(adapter) {
+            println!("  {YELLOW}SKIP{RESET} {}", test.name);
+            skipped += 1;
+            continue;
+        }
+
+        println!("  {DIM}running{RESET} {} > {}...", adapter.name, test.name);
+        let started = Instant::now();
+        let timeout = Duration::from_millis(timeout_ms);
+        let deadline = started + timeout;
+        let mut ctx = TestContext {
+            registry_url: registry_url.to_string(),
+            token: token.to_string(),
+            adapter: adapter.clone(),
+            run_id: run_id(),
+            timeout,
+            deadline,
+            state,
+            sub_results: Vec::new(),
+        };
+
+        let result = match (test.run)(&mut ctx) {
+            Ok(()) if started.elapsed() > timeout => TestResult {
+                name: test.name,
+                passed: false,
+                duration: started.elapsed(),
+                error: Some(format!("Test timed out after {timeout_ms}ms")),
+                sub_tests: ctx.sub_results,
+            },
+            Ok(()) => TestResult {
+                name: test.name,
+                passed: true,
+                duration: started.elapsed(),
+                error: None,
+                sub_tests: ctx.sub_results,
+            },
+            Err(err) => TestResult {
+                name: test.name,
+                passed: false,
+                duration: started.elapsed(),
+                error: Some(format!("{err:#}")),
+                sub_tests: ctx.sub_results,
+            },
+        };
+        report_test_result(&result);
+        results.push(result);
+    }
+
+    let passed = results.iter().filter(|result| result.passed).count();
+    let failed = results.iter().filter(|result| !result.passed).count();
+    SuiteResult {
+        adapter: adapter.name.clone(),
+        tests: results,
+        passed,
+        failed,
+        skipped,
+        duration: suite_start.elapsed(),
+    }
+}
+
+fn parse_adapters(filters: &[String], state: &mut RunState) -> Result<Vec<Adapter>> {
+    if filters.is_empty() {
+        return Ok(vec![create_adapter("npm", None, None, state)?]);
+    }
+    filters
+        .iter()
+        .map(|filter| {
+            let (name, version, bin_path) = parse_pm_spec(filter);
+            create_adapter(&name, version.as_deref(), bin_path.as_deref(), state)
+        })
+        .collect()
+}
+
+fn parse_pm_spec(filter: &str) -> (String, Option<String>, Option<String>) {
+    if let Some((name, bin)) = filter.split_once('=') {
+        return (name.to_ascii_lowercase(), None, Some(bin.to_string()));
+    }
+    if let Some((name, version)) = filter.split_once('@') {
+        return (name.to_ascii_lowercase(), Some(version.to_string()), None);
+    }
+    (filter.to_ascii_lowercase(), None, None)
+}
+
+fn create_adapter(
+    name: &str,
+    version: Option<&str>,
+    bin_path: Option<&str>,
+    state: &mut RunState,
+) -> Result<Adapter> {
+    match name {
+        "npm" => {
+            let bin = resolve_installed_bin(bin_path, version, "npm", "npm", "npm", state)?;
+            let resolved = detect_version(&bin, &[])?;
+            Ok(Adapter {
+                name: format!("npm@{resolved}"),
+                kind: AdapterType::Npm,
+                bin,
+                supports: set(&["publish", "unpublish", "install", "info", "audit", "deprecate", "dist-tag", "ping", "search"]),
+                version: resolved,
+                yarn_major: 0,
+            })
+        }
+        "pnpm" => {
+            let bin = resolve_installed_bin(bin_path, version, "pnpm", "pnpm", "pnpm", state)?;
+            let resolved = detect_version(&bin, &[])?;
+            let major = parse_major(&resolved);
+            let supports = if major >= 11 {
+                set(&["publish", "unpublish", "install", "info", "audit", "deprecate"])
+            } else {
+                set(&["publish", "unpublish", "install", "info", "audit", "deprecate", "dist-tag", "ping", "search"])
+            };
+            Ok(Adapter {
+                name: format!("pnpm@{resolved}"),
+                kind: AdapterType::Pnpm,
+                bin,
+                supports,
+                version: resolved,
+                yarn_major: 0,
+            })
+        }
+        "yarn-classic" | "yarn1" => {
+            let bin = match (bin_path, version) {
+                (Some(bin), _) => bin.to_string(),
+                (_, Some(version)) => {
+                    let package = if version.starts_with('1') {
+                        format!("yarn@{version}")
+                    } else {
+                        "yarn@1".to_string()
+                    };
+                    install_package_bin(&package, "node_modules/.bin/yarn", state)?
+                }
+                _ => resolve_yarn_classic_bin(state)?,
+            };
+            let resolved = detect_version_with_env(&bin, &[], yarn_base_env())?;
+            Ok(Adapter {
+                name: format!("yarn-classic@{resolved}"),
+                kind: AdapterType::YarnClassic,
+                bin,
+                supports: set(&["publish", "install", "info", "audit"]),
+                version: resolved,
+                yarn_major: 1,
+            })
+        }
+        "yarn-modern" | "yarn" => {
+            let bin = match (bin_path, version) {
+                (Some(bin), _) => bin.to_string(),
+                (_, Some(version)) => install_package_bin(
+                    &format!("@yarnpkg/cli-dist@{version}"),
+                    "node_modules/@yarnpkg/cli-dist/bin/yarn.js",
+                    state,
+                )?,
+                _ => resolve_yarn_modern_bin(state)?,
+            };
+            let resolved = detect_version_with_env(&bin, &[], yarn_base_env())?;
+            let major = parse_major(&resolved);
+            Ok(Adapter {
+                name: format!("yarn-modern@{resolved}"),
+                kind: AdapterType::YarnModern,
+                bin,
+                supports: set(&["publish", "install", "info", "ping", "deprecate", "login"]),
+                version: resolved,
+                yarn_major: major,
+            })
+        }
+        "bun" => {
+            let bin = bin_path.unwrap_or("bun").to_string();
+            let resolved = detect_version(&bin, &[])?;
+            Ok(Adapter {
+                name: format!("bun@{resolved}"),
+                kind: AdapterType::Bun,
+                bin,
+                supports: set(&["publish", "install", "info", "audit"]),
+                version: resolved,
+                yarn_major: 0,
+            })
+        }
+        "deno" => {
+            let bin = bin_path.unwrap_or("deno").to_string();
+            let output = command_output(&bin, &["--version"], None, &[], false, None)?;
+            let resolved = output
+                .stdout
+                .lines()
+                .find_map(|line| line.strip_prefix("deno ").map(str::to_string))
+                .unwrap_or_else(|| "unknown".to_string());
+            Ok(Adapter {
+                name: format!("deno@{resolved}"),
+                kind: AdapterType::Deno,
+                bin,
+                supports: set(&["install", "info"]),
+                version: resolved,
+                yarn_major: 0,
+            })
+        }
+        other => bail!("Unknown package manager: \"{other}\". Supported: npm, pnpm, yarn-classic, yarn-modern, bun, deno"),
+    }
+}
+
+fn set(items: &[&'static str]) -> BTreeSet<&'static str> {
+    items.iter().copied().collect()
+}
+
+fn resolve_installed_bin(
+    bin_path: Option<&str>,
+    version: Option<&str>,
+    package_name: &str,
+    default_bin: &str,
+    bin_rel: &str,
+    state: &mut RunState,
+) -> Result<String> {
+    if let Some(bin) = bin_path {
+        return Ok(bin.to_string());
+    }
+    if let Some(version) = version {
+        return install_package_bin(
+            &format!("{package_name}@{version}"),
+            &format!("node_modules/.bin/{bin_rel}"),
+            state,
+        );
+    }
+    Ok(default_bin.to_string())
+}
+
+fn resolve_yarn_classic_bin(state: &mut RunState) -> Result<String> {
+    if let Ok(output) = command_output("which", &["yarn"], None, &[], false, None) {
+        let bin = output.stdout.trim();
+        if !bin.is_empty() {
+            let version = detect_version_with_env(bin, &[], yarn_base_env())
+                .unwrap_or_else(|_| "unknown".to_string());
+            if parse_major(&version) == 1 {
+                return Ok(bin.to_string());
+            }
+        }
+    }
+    install_package_bin("yarn@1", "node_modules/.bin/yarn", state)
+}
+
+fn resolve_yarn_modern_bin(state: &mut RunState) -> Result<String> {
+    if let Ok(output) = command_output("which", &["yarn"], None, &[], false, None) {
+        let bin = output.stdout.trim();
+        if !bin.is_empty() {
+            let version = detect_version_with_env(bin, &[], yarn_base_env())
+                .unwrap_or_else(|_| "unknown".to_string());
+            if parse_major(&version) >= 2 {
+                return Ok(bin.to_string());
+            }
+        }
+    }
+    install_package_bin(
+        "@yarnpkg/cli-dist@4",
+        "node_modules/@yarnpkg/cli-dist/bin/yarn.js",
+        state,
+    )
+}
+
+fn install_package_bin(package: &str, bin_rel: &str, state: &mut RunState) -> Result<String> {
+    let dir = tempfile::tempdir().context("failed to create package-manager install dir")?;
+    let path = dir.path().to_path_buf();
+    let prefix = path.to_string_lossy().to_string();
+    command_output(
+        "npm",
+        &[
+            "install",
+            "--prefix",
+            &prefix,
+            package,
+            "--loglevel=error",
+            "--min-release-age=0",
+        ],
+        None,
+        &[],
+        false,
+        None,
+    )
+    .with_context(|| format!("failed to install {package}"))?;
+    let bin = path.join(bin_rel).to_string_lossy().to_string();
+    let installed = detect_version(&bin, &[]).unwrap_or_else(|_| "unknown".to_string());
+    println!("  Auto-installed {} {}", package_label(package), installed);
+    state.temp_dirs.push(dir);
+    Ok(bin)
+}
+
+fn package_label(package: &str) -> &str {
+    package.rsplit_once('@').map_or(
+        package,
+        |(name, _)| {
+            if name.is_empty() {
+                package
+            } else {
+                name
+            }
+        },
+    )
+}
+
+fn detect_version(bin: &str, args: &[&str]) -> Result<String> {
+    detect_version_with_env(bin, args, Vec::new())
+}
+
+fn detect_version_with_env(
+    bin: &str,
+    args: &[&str],
+    envs: Vec<(&'static str, &'static str)>,
+) -> Result<String> {
+    let mut full_args = Vec::from(args);
+    full_args.push("--version");
+    Ok(command_output(bin, &full_args, None, &envs, false, None)?
+        .stdout
+        .trim()
+        .to_string())
+}
+
+fn parse_major(version: &str) -> u64 {
+    version
+        .split('.')
+        .next()
+        .and_then(|part| part.parse().ok())
+        .unwrap_or(0)
+}
+
+fn yarn_base_env() -> Vec<(&'static str, &'static str)> {
+    vec![("COREPACK_ENABLE_STRICT", "0"), ("YARN_IGNORE_PATH", "1")]
+}
+
+fn yarn_env(adapter: &Adapter) -> Vec<(&'static str, &'static str)> {
+    let mut envs = yarn_base_env();
+    if adapter.yarn_major >= 4 {
+        envs.push(("YARN_ENABLE_HARDENED_MODE", "0"));
+        envs.push(("YARN_NPM_MINIMAL_AGE_GATE", "0"));
+    }
+    envs
+}
+
+fn command_output(
+    bin: &str,
+    args: &[&str],
+    cwd: Option<&Path>,
+    envs: &[(&str, &str)],
+    verbose: bool,
+    timeout: Option<Duration>,
+) -> Result<ExecOutput> {
+    if verbose {
+        let cwd_label = cwd
+            .and_then(|path| path.file_name())
+            .and_then(|name| name.to_str())
+            .map(|name| format!(" {DIM}(cwd: {name}){RESET}"))
+            .unwrap_or_default();
+        println!(
+            "      {CYAN}${RESET} {} {}{}",
+            short_bin(bin),
+            args.join(" "),
+            cwd_label
+        );
+    }
+
+    let started = Instant::now();
+    let mut command = Command::new(bin);
+    command.args(args);
+    command.stdout(Stdio::piped());
+    command.stderr(Stdio::piped());
+    if let Some(cwd) = cwd {
+        command.current_dir(cwd);
+    }
+    for (key, value) in envs {
+        command.env(key, value);
+    }
+    let mut child = command
+        .spawn()
+        .with_context(|| format!("failed to start command: {bin} {}", args.join(" ")))?;
+    let status = loop {
+        if let Some(status) = child
+            .try_wait()
+            .with_context(|| format!("failed waiting for command: {bin} {}", args.join(" ")))?
+        {
+            break status;
+        }
+        if let Some(limit) = timeout {
+            if started.elapsed() >= limit {
+                let _ = child.kill();
+                let _ = child.wait();
+                bail!(
+                    "Running \"{} {}\" timed out after {}",
+                    bin,
+                    args.join(" "),
+                    format_duration(limit)
+                );
+            }
+        }
+        std::thread::sleep(Duration::from_millis(25));
+    };
+    let mut stdout = String::new();
+    let mut stderr = String::new();
+    if let Some(mut pipe) = child.stdout.take() {
+        pipe.read_to_string(&mut stdout)
+            .context("failed to read command stdout")?;
+    }
+    if let Some(mut pipe) = child.stderr.take() {
+        pipe.read_to_string(&mut stderr)
+            .context("failed to read command stderr")?;
+    }
+
+    if verbose {
+        let status_label = if status.success() {
+            format!("{GREEN}ok{RESET}")
+        } else {
+            format!("{RED}exit {}{RESET}", status.code().unwrap_or(-1))
+        };
+        println!(
+            "      {DIM}  -> {status_label} {DIM}({}){RESET}",
+            format_duration(started.elapsed())
+        );
+    }
+
+    if status.success() {
+        Ok(ExecOutput { stdout, stderr })
+    } else {
+        bail!(
+            "Running \"{} {}\" returned error code {}...\n\nSTDOUT:\n{}\n\nSTDERR:\n{}\n",
+            bin,
+            args.join(" "),
+            status.code().unwrap_or(-1),
+            stdout,
+            stderr
+        )
+    }
+}
+
+fn short_bin(bin: &str) -> &str {
+    Path::new(bin)
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or(bin)
+}
+
+fn exec_adapter(
+    ctx: &TestContext<'_>,
+    cwd: Option<&Path>,
+    args: Vec<String>,
+) -> Result<ExecOutput> {
+    let args = normalize_adapter_args(&ctx.adapter, args);
+    let refs = args.iter().map(String::as_str).collect::<Vec<_>>();
+    let envs = match ctx.adapter.kind {
+        AdapterType::YarnClassic | AdapterType::YarnModern => yarn_env(&ctx.adapter),
+        _ => Vec::new(),
+    };
+    command_output(
+        &ctx.adapter.bin,
+        &refs,
+        cwd,
+        &envs,
+        ctx.state.verbose,
+        Some(remaining_test_time(ctx)?),
+    )
+}
+
+fn remaining_test_time(ctx: &TestContext<'_>) -> Result<Duration> {
+    ctx.deadline
+        .checked_duration_since(Instant::now())
+        .ok_or_else(|| anyhow!("Test timed out after {}", format_duration(ctx.timeout)))
+}
+
+fn normalize_adapter_args(adapter: &Adapter, args: Vec<String>) -> Vec<String> {
+    match adapter.kind {
+        AdapterType::Pnpm if parse_major(&adapter.version) >= 11 => {
+            let cmd = args.first().map(String::as_str).unwrap_or_default();
+            let mut filtered = if matches!(cmd, "deprecate" | "unpublish" | "publish" | "dist-tag")
+            {
+                args.into_iter()
+                    .filter(|arg| arg != "--json" && !arg.starts_with("--loglevel"))
+                    .collect::<Vec<_>>()
+            } else if cmd == "version" {
+                args.into_iter()
+                    .filter(|arg| {
+                        !arg.starts_with("--registry")
+                            && !arg.starts_with("--loglevel")
+                            && !arg.starts_with("--no-git-tag-version")
+                    })
+                    .collect::<Vec<_>>()
+            } else {
+                args
+            };
+            if filtered.first().map(String::as_str) == Some("deprecate")
+                && filtered.get(2).map(String::as_str) == Some("")
+            {
+                let mut updated = vec!["undeprecate".to_string(), filtered[1].clone()];
+                updated.extend(filtered.drain(3..));
+                filtered = updated;
+            }
+            filtered
+        }
+        AdapterType::YarnModern => {
+            let cmd = args.first().cloned().unwrap_or_default();
+            let mut rest = args
+                .into_iter()
+                .skip(1)
+                .filter(|arg| !arg.starts_with("--registry"))
+                .collect::<Vec<_>>();
+            match cmd.as_str() {
+                "publish" => {
+                    rest.retain(|arg| arg != "--json");
+                    let mut out = vec!["npm".to_string(), "publish".to_string()];
+                    out.extend(rest);
+                    out
+                }
+                "info" => prepend(&["npm", "info"], rest),
+                "ping" => prepend(&["npm", "ping"], rest),
+                "deprecate" => prepend(&["npm", "deprecate"], rest),
+                "login" => prepend(&["npm", "login"], rest),
+                "whoami" => prepend(&["npm", "whoami"], rest),
+                _ => {
+                    let mut out = vec![cmd.to_string()];
+                    out.extend(rest);
+                    out
+                }
+            }
+        }
+        AdapterType::Bun if args.first().map(String::as_str) == Some("info") => {
+            let pkg = args.get(1).cloned().unwrap_or_default();
+            let cleaned = args
+                .into_iter()
+                .skip(2)
+                .filter(|arg| arg != "--registry" && !arg.starts_with("http"))
+                .collect::<Vec<_>>();
+            let mut out = vec!["info".to_string(), pkg];
+            out.extend(cleaned);
+            out
+        }
+        AdapterType::Deno if args.first().map(String::as_str) == Some("info") => {
+            let pkg = args.get(1).cloned().unwrap_or_default();
+            let mut out = vec![
+                "info".to_string(),
+                format!("npm:{pkg}"),
+                "--node-modules-dir=auto".to_string(),
+            ];
+            out.extend(args.into_iter().skip(2).filter(|arg| arg != "--json"));
+            out
+        }
+        AdapterType::Deno if args.first().map(String::as_str) == Some("install") => {
+            vec!["install".to_string()]
+        }
+        _ => args,
+    }
+}
+
+fn prepend(prefix: &[&str], rest: Vec<String>) -> Vec<String> {
+    let mut out = prefix
+        .iter()
+        .map(|item| item.to_string())
+        .collect::<Vec<_>>();
+    out.extend(rest);
+    out
+}
+
+fn registry_arg(adapter: &Adapter, url: &str) -> Vec<String> {
+    match adapter.kind {
+        AdapterType::Deno | AdapterType::YarnModern => Vec::new(),
+        _ => vec!["--registry".to_string(), url.to_string()],
+    }
+}
+
+fn prepare_project(
+    ctx: &mut TestContext<'_>,
+    package_name: &str,
+    version: &str,
+    dependencies: BTreeMap<String, String>,
+    dev_dependencies: BTreeMap<String, String>,
+) -> Result<PathBuf> {
+    let dir = create_temp_dir(ctx.state, package_name)?;
+    let path = dir.path().to_path_buf();
+    fs::write(
+        path.join("package.json"),
+        package_json(package_name, version, dependencies, dev_dependencies)?,
+    )?;
+    fs::write(path.join("README.md"), readme(package_name))?;
+
+    if ctx.adapter.kind == AdapterType::YarnModern {
+        let yaml = yarn_config(&ctx.registry_url, Some(&ctx.token), ctx.adapter.yarn_major)?;
+        fs::write(path.join(".yarnrc.yml"), yaml)?;
+    } else {
+        let npmrc = format!(
+            "{}:_authToken={}\nregistry={}\nmin-release-age=0\nminimum-release-age=0",
+            npm_auth_scope(&ctx.registry_url)?,
+            ctx.token,
+            ctx.registry_url
+        );
+        fs::write(path.join(".npmrc"), npmrc)?;
+        if ctx.adapter.kind == AdapterType::Pnpm {
+            fs::write(
+                path.join("pnpm-workspace.yaml"),
+                "packages:\n  - .\nminimumReleaseAge: 0\n",
+            )?;
+        }
+    }
+    Ok(path)
+}
+
+fn package_json(
+    package_name: &str,
+    version: &str,
+    dependencies: BTreeMap<String, String>,
+    dev_dependencies: BTreeMap<String, String>,
+) -> Result<String> {
+    Ok(serde_json::to_string(&json!({
+        "name": package_name,
+        "version": version,
+        "description": "some cool project",
+        "main": "index.js",
+        "scripts": { "test": "echo exit 1" },
+        "dependencies": dependencies,
+        "devDependencies": dev_dependencies,
+        "keywords": ["foo", "bar"],
+        "author": "Verdaccio E2E <verdaccio@example.org>",
+        "license": "MIT"
+    }))?)
+}
+
+fn readme(package_name: &str) -> String {
+    format!("\n   # My README {package_name}\n\n   some text\n\n   ## subtitle\n\n   more text\n  ")
+}
+
+fn yarn_config(registry: &str, token: Option<&str>, major: u64) -> Result<String> {
+    let mut value = serde_yaml::Mapping::new();
+    value.insert("npmRegistryServer".into(), registry.into());
+    value.insert("enableImmutableInstalls".into(), false.into());
+    value.insert("unsafeHttpWhitelist".into(), vec!["localhost"].into());
+    if major >= 4 {
+        value.insert("enableHardenedMode".into(), false.into());
+        value.insert("npmMinimalAgeGate".into(), 0.into());
+    }
+    if let Some(token) = token {
+        let mut registry_config = serde_yaml::Mapping::new();
+        registry_config.insert("npmAlwaysAuth".into(), true.into());
+        registry_config.insert("npmAuthToken".into(), token.into());
+        let mut registries = serde_yaml::Mapping::new();
+        registries.insert(registry.into(), registry_config.into());
+        value.insert("npmRegistries".into(), registries.into());
+    }
+    Ok(serde_yaml::to_string(&value)?)
+}
+
+fn create_temp_dir<'a>(state: &'a mut RunState, prefix: &str) -> Result<&'a TempDir> {
+    let sanitized = prefix
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '-' || c == '_' {
+                c
+            } else {
+                '-'
+            }
+        })
+        .collect::<String>();
+    let dir = Builder::new()
+        .prefix(&format!("verdaccio-e2e-{sanitized}-"))
+        .tempdir()
+        .context("failed to create temp dir")?;
+    state.temp_dirs.push(dir);
+    Ok(state.temp_dirs.last().expect("temp dir was just pushed"))
+}
+
+fn ping_registry(registry_url: &str) -> bool {
+    Client::new()
+        .get(format!("{}/-/ping", registry_url.trim_end_matches('/')))
+        .timeout(Duration::from_secs(10))
+        .send()
+        .map(|resp| resp.status().is_success())
+        .unwrap_or(false)
+}
+
+fn create_user(registry_url: &str, user: &str, password: &str) -> Result<String> {
+    let url = format!(
+        "{}/-/user/org.couchdb.user:{}",
+        registry_url.trim_end_matches('/'),
+        user
+    );
+    let body = json!({
+        "name": user,
+        "password": password,
+        "_id": format!("org.couchdb.user:{user}"),
+        "type": "user",
+        "roles": [],
+        "date": unix_millis_string(),
+    });
+    let response = Client::new()
+        .put(url)
+        .header("Content-Type", "application/json")
+        .json(&body)
+        .send()
+        .context("failed to create registry user")?;
+    let status = response.status();
+    let body: Value = response.json().unwrap_or(Value::Null);
+    if matches!(status.as_u16(), 200 | 201 | 409) {
+        if let Some(token) = body.get("token").and_then(Value::as_str) {
+            return Ok(token.to_string());
+        }
+    }
+    bail!("Failed to create/login user \"{user}\" on {registry_url}: {status} {body}")
+}
+
+fn unix_millis_string() -> String {
+    format!("{}", now_millis())
+}
+
+fn now_millis() -> u128 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis()
+}
+
+fn run_id() -> String {
+    let counter = RUN_COUNTER.fetch_add(1, Ordering::Relaxed);
+    format!("{:x}-{counter:x}", now_millis())
+}
+
+fn npm_auth_scope(registry_url: &str) -> Result<String> {
+    let url = Url::parse(registry_url)
+        .with_context(|| format!("failed to parse registry URL: {registry_url}"))?;
+    let host = url
+        .host_str()
+        .ok_or_else(|| anyhow!("registry URL has no host: {registry_url}"))?;
+    let port = url.port().map_or(String::new(), |port| format!(":{port}"));
+    let path = url.path().trim_end_matches('/');
+    Ok(format!("//{host}{port}{path}/"))
+}
+
+fn sub_test(
+    ctx: &mut TestContext<'_>,
+    label: &'static str,
+    f: impl FnOnce(&mut TestContext<'_>) -> Result<()>,
+) -> Result<()> {
+    let started = Instant::now();
+    match f(ctx) {
+        Ok(()) => {
+            let duration = started.elapsed();
+            ctx.sub_results.push(SubTestResult {
+                label,
+                passed: true,
+                duration,
+                error: None,
+            });
+            report_sub_test(label, true, duration);
+            Ok(())
+        }
+        Err(err) => {
+            let duration = started.elapsed();
+            let error = format!("{err:#}");
+            ctx.sub_results.push(SubTestResult {
+                label,
+                passed: false,
+                duration,
+                error: Some(error.clone()),
+            });
+            report_sub_test(label, false, duration);
+            Err(anyhow!(error))
+        }
+    }
+}
+
+fn prepare_deprecate_project(
+    ctx: &mut TestContext<'_>,
+    pkg: &str,
+    version: &str,
+) -> Result<PathBuf> {
+    let temp = prepare_project(ctx, pkg, version, BTreeMap::new(), BTreeMap::new())?;
+    if ctx.adapter.kind == AdapterType::YarnModern {
+        import_plugin(ctx, &temp, "npm-deprecate")?;
+    }
+    Ok(temp)
+}
+
+fn publish_pkg(ctx: &TestContext<'_>, temp: &Path) -> Result<()> {
+    publish_pkg_extra(ctx, temp, Vec::new())
+}
+
+fn publish_pkg_extra(ctx: &TestContext<'_>, temp: &Path, extra: Vec<String>) -> Result<()> {
+    if ctx.adapter.kind == AdapterType::YarnModern {
+        exec_adapter(ctx, Some(temp), vec!["install".into()])?;
+    }
+    let mut args = vec!["publish".into()];
+    args.extend(extra);
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    exec_adapter(ctx, Some(temp), args)?;
+    Ok(())
+}
+
+fn publish_seed(
+    ctx: &mut TestContext<'_>,
+    pkg: &str,
+    version: &str,
+    deps: BTreeMap<String, String>,
+) -> Result<()> {
+    let temp = prepare_project(ctx, pkg, version, deps, BTreeMap::new())?;
+    publish_pkg(ctx, &temp)
+}
+
+fn deprecate_pkg(
+    ctx: &TestContext<'_>,
+    temp: &Path,
+    package_version: &str,
+    message: &str,
+) -> Result<()> {
+    let mut args = vec!["deprecate".into(), package_version.into(), message.into()];
+    if ctx.adapter.kind != AdapterType::YarnModern {
+        args.push("--json".into());
+    }
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    exec_adapter(ctx, Some(temp), args)?;
+    Ok(())
+}
+
+fn info_pkg(ctx: &TestContext<'_>, temp: &Path, pkg: &str) -> Result<Value> {
+    let mut args = vec!["info".into(), pkg.into(), "--json".into()];
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, Some(temp), args)?;
+    if ctx.adapter.kind == AdapterType::YarnClassic {
+        for line in resp.stdout.lines() {
+            if let Ok(value) = serde_json::from_str::<Value>(line) {
+                if value.get("type").and_then(Value::as_str) == Some("inspect") {
+                    return Ok(normalize_info(
+                        value.get("data").cloned().unwrap_or(Value::Null),
+                    ));
+                }
+            }
+        }
+    }
+    parse_info_json(&resp.stdout)
+}
+
+fn parse_info_json(stdout: &str) -> Result<Value> {
+    Ok(normalize_info(serde_json::from_str(stdout)?))
+}
+
+fn normalize_info(value: Value) -> Value {
+    if let Some(array) = value.as_array() {
+        array.last().cloned().unwrap_or(Value::Null)
+    } else {
+        value
+    }
+}
+
+fn bump_version(ctx: &TestContext<'_>, temp: &Path, bump: &str) -> Result<()> {
+    if ctx.adapter.kind == AdapterType::YarnModern {
+        let path = temp.join("package.json");
+        let mut pkg: Value = serde_json::from_str(&fs::read_to_string(&path)?)?;
+        let current = pkg
+            .get("version")
+            .and_then(Value::as_str)
+            .unwrap_or("1.0.0");
+        let mut parts = current
+            .split('.')
+            .map(|p| p.parse::<u64>().unwrap_or(0))
+            .collect::<Vec<_>>();
+        while parts.len() < 3 {
+            parts.push(0);
+        }
+        match bump {
+            "major" => {
+                parts[0] += 1;
+                parts[1] = 0;
+                parts[2] = 0;
+            }
+            _ => {
+                parts[1] += 1;
+                parts[2] = 0;
+            }
+        }
+        pkg["version"] = format!("{}.{}.{}", parts[0], parts[1], parts[2]).into();
+        fs::write(path, serde_json::to_string_pretty(&pkg)?)?;
+    } else {
+        let mut args = vec![
+            "version".into(),
+            bump.into(),
+            "--no-git-tag-version".into(),
+            "--loglevel=info".into(),
+        ];
+        args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+        exec_adapter(ctx, Some(temp), args)?;
+    }
+    Ok(())
+}
+
+fn prepare_login_project(ctx: &mut TestContext<'_>, name: &str) -> Result<PathBuf> {
+    let temp = create_temp_dir(ctx.state, name)?.path().to_path_buf();
+    fs::write(
+        temp.join(".yarnrc.yml"),
+        yarn_config(&ctx.registry_url, None, ctx.adapter.yarn_major)?,
+    )?;
+    fs::write(
+        temp.join("package.json"),
+        serde_json::to_string(&json!({ "name": name, "version": "1.0.0" }))?,
+    )?;
+    import_plugin(ctx, &temp, "npm-login")?;
+    Ok(temp)
+}
+
+fn yarn_login(
+    ctx: &TestContext<'_>,
+    cwd: &Path,
+    user: &str,
+    password: &str,
+    email: &str,
+) -> Result<ExecOutput> {
+    exec_adapter(
+        ctx,
+        Some(cwd),
+        vec![
+            "login".into(),
+            "--auth-type=legacy".into(),
+            format!("--user={user}"),
+            format!("--password={password}"),
+            format!("--email={email}"),
+        ],
+    )
+}
+
+fn yarn_whoami(ctx: &TestContext<'_>, cwd: &Path) -> Result<String> {
+    Ok(exec_adapter(ctx, Some(cwd), vec!["whoami".into()])?.stdout)
+}
+
+fn import_plugin(ctx: &TestContext<'_>, cwd: &Path, plugin_name: &str) -> Result<()> {
+    if ctx.adapter.kind != AdapterType::YarnModern {
+        return Ok(());
+    }
+    let tmp = tempfile::tempdir()?;
+    let tmp_path = tmp.path().to_string_lossy().to_string();
+    let pkg = format!("@verdaccio/yarn-plugin-{plugin_name}");
+    command_output(
+        "npm",
+        &["pack", &pkg, "--pack-destination", &tmp_path],
+        None,
+        &[],
+        false,
+        None,
+    )?;
+    let tgz = fs::read_dir(tmp.path())?
+        .filter_map(Result::ok)
+        .map(|entry| entry.path())
+        .find(|path| path.extension().and_then(|ext| ext.to_str()) == Some("tgz"))
+        .ok_or_else(|| anyhow!("failed to find packed yarn plugin"))?;
+    let tgz_str = tgz.to_string_lossy().to_string();
+    command_output(
+        "tar",
+        &["xzf", &tgz_str, "-C", &tmp_path],
+        None,
+        &[],
+        false,
+        None,
+    )?;
+    let bundle = tmp
+        .path()
+        .join(format!("package/bundles/@yarnpkg/plugin-{plugin_name}.js"));
+    let bundle = bundle.to_string_lossy().to_string();
+    exec_adapter(
+        ctx,
+        Some(cwd),
+        vec!["plugin".into(), "import".into(), bundle],
+    )?;
+    Ok(())
+}
+
+fn prepare_cooldown_consumer(
+    ctx: &mut TestContext<'_>,
+    name: &str,
+    deps: BTreeMap<String, String>,
+) -> Result<PathBuf> {
+    let temp = prepare_project(ctx, name, "1.0.0", deps, BTreeMap::new())?;
+    fs::write(
+        temp.join(".npmrc"),
+        format!(
+            "{}:_authToken={}\nregistry={}",
+            npm_auth_scope(&ctx.registry_url)?,
+            ctx.token,
+            ctx.registry_url
+        ),
+    )?;
+    fs::write(
+        temp.join("pnpm-workspace.yaml"),
+        "packages:\n  - .\nminimumReleaseAge: 10080\nminimumReleaseAgeExclude:\n  - '@verdaccio/*'\n  - 'verdaccio-*'\n",
+    )?;
+    Ok(temp)
+}
+
+fn is_pnpm_minimum_release_age_capable(adapter: &Adapter) -> bool {
+    if adapter.kind != AdapterType::Pnpm {
+        return false;
+    }
+    let mut parts = adapter
+        .version
+        .split('.')
+        .filter_map(|part| part.parse::<u64>().ok());
+    let major = parts.next().unwrap_or(0);
+    let minor = parts.next().unwrap_or(0);
+    major == 11 && minor >= 1
+}
+
+fn assert_true(condition: bool, message: &str) -> Result<()> {
+    if condition {
+        Ok(())
+    } else {
+        bail!("{message}")
+    }
+}
+
+fn assert_contains(haystack: &str, needle: &str) -> Result<()> {
+    assert_true(
+        haystack.contains(needle),
+        &format!("Expected output to contain \"{needle}\" but got \"{haystack}\""),
+    )
+}
+
+fn assert_eq_str(actual: &str, expected: &str) -> Result<()> {
+    if actual == expected {
+        Ok(())
+    } else {
+        bail!("Expected \"{expected}\" but got \"{actual}\"")
+    }
+}
+
+fn assert_eq_json<T: Into<Value>>(
+    actual: Option<&Value>,
+    expected: T,
+    message: &str,
+) -> Result<()> {
+    let expected = expected.into();
+    if actual == Some(&expected) {
+        Ok(())
+    } else {
+        bail!(
+            "{message}: expected {expected}, got {}",
+            actual.cloned().unwrap_or(Value::Null)
+        )
+    }
+}
+
+fn report_test_result(result: &TestResult) {
+    if result.passed {
+        if result.sub_tests.is_empty() {
+            println!(
+                "  {GREEN}✓{RESET} {} {DIM}{}{RESET}",
+                result.name,
+                format_duration(result.duration)
+            );
+        } else {
+            println!(
+                "  {GREEN}PASS{RESET} {} {DIM}{}{RESET}",
+                result.name,
+                format_duration(result.duration)
+            );
+        }
+    } else {
+        println!(
+            "  {RED}FAIL{RESET} {} {DIM}{}{RESET}",
+            result.name,
+            format_duration(result.duration)
+        );
+        if let Some(error) = &result.error {
+            for line in error.lines() {
+                println!("    {RED}{line}{RESET}");
+            }
+            if env::var_os("GITHUB_ACTIONS").is_some() {
+                let first = error.lines().next().unwrap_or(error);
+                println!("::error title=E2E {}::{first}", result.name);
+            }
+        }
+    }
+}
+
+fn report_sub_test(label: &str, passed: bool, duration: Duration) {
+    let icon = if passed {
+        format!("{BOLD}{GREEN}✓{RESET}")
+    } else {
+        format!("{BOLD}{RED}✗{RESET}")
+    };
+    println!(
+        "\n    {icon} {BOLD}{label}{RESET} {DIM}{}{RESET}\n",
+        format_duration(duration)
+    );
+}
+
+fn report_summary(results: &[SuiteResult]) -> Result<()> {
+    println!("\n{BOLD}{}{RESET}", "=".repeat(50));
+    println!("{BOLD}Summary{RESET}\n");
+    let mut total_passed = 0usize;
+    let mut total_failed = 0usize;
+    let mut total_skipped = 0usize;
+    let mut total_duration = Duration::ZERO;
+    for suite in results {
+        let color = if suite.failed > 0 { RED } else { GREEN };
+        let icon = if suite.failed > 0 { "x" } else { "v" };
+        println!(
+            "  {color}{icon}{RESET} {}: {GREEN}{} passed{RESET}, {RED}{} failed{RESET}, {YELLOW}{} skipped{RESET} {DIM}({}){RESET}",
+            suite.adapter,
+            suite.passed,
+            suite.failed,
+            suite.skipped,
+            format_duration(suite.duration)
+        );
+        total_passed += suite.passed;
+        total_failed += suite.failed;
+        total_skipped += suite.skipped;
+        total_duration += suite.duration;
+    }
+    println!(
+        "\n  Total: {GREEN}{total_passed} passed{RESET}, {RED}{total_failed} failed{RESET}, {YELLOW}{total_skipped} skipped{RESET} {DIM}({}){RESET}",
+        format_duration(total_duration)
+    );
+    println!("{BOLD}{}{RESET}\n", "=".repeat(50));
+    if let Some(summary) = env::var_os("GITHUB_STEP_SUMMARY") {
+        write_github_summary(Path::new(&summary), results)?;
+    }
+    Ok(())
+}
+
+fn write_github_summary(path: &Path, results: &[SuiteResult]) -> Result<()> {
+    let mut file = fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(path)?;
+    writeln!(file, "## E2E Test Results\n")?;
+    for suite in results {
+        let status = if suite.failed > 0 { "❌" } else { "✅" };
+        writeln!(file, "### {status} {}\n", suite.adapter)?;
+        writeln!(file, "| Test | Status | Duration |")?;
+        writeln!(file, "|------|--------|----------|")?;
+        for test in &suite.tests {
+            let icon = if test.passed { "✅" } else { "❌" };
+            writeln!(
+                file,
+                "| {} | {} | {} |",
+                test.name,
+                icon,
+                format_duration(test.duration)
+            )?;
+            for sub in &test.sub_tests {
+                let icon = if sub.passed { "✅" } else { "❌" };
+                let label = if sub.passed {
+                    sub.label.to_string()
+                } else {
+                    format!("{}: {}", sub.label, sub.error.as_deref().unwrap_or(""))
+                };
+                writeln!(
+                    file,
+                    "| &nbsp;&nbsp;&nbsp;&nbsp;{} | {} | {} |",
+                    label,
+                    icon,
+                    format_duration(sub.duration)
+                )?;
+            }
+        }
+        writeln!(file)?;
+    }
+    let total_passed: usize = results.iter().map(|suite| suite.passed).sum();
+    let total_failed: usize = results.iter().map(|suite| suite.failed).sum();
+    let total_skipped: usize = results.iter().map(|suite| suite.skipped).sum();
+    let emoji = if total_failed > 0 { "❌" } else { "✅" };
+    writeln!(file, "{emoji} **{total_passed} passed**, **{total_failed} failed**, **{total_skipped} skipped**\n")?;
+    Ok(())
+}
+
+fn format_duration(duration: Duration) -> String {
+    if duration < Duration::from_secs(1) {
+        format!("{}ms", duration.as_millis())
+    } else {
+        format!("{:.1}s", duration.as_secs_f64())
+    }
+}