@verdaccio/e2e-cli 2.10.2 → 3.0.0

package/src/e2e_tests/dist_tags.rs

@@ -0,0 +1,56 @@
+use super::prelude::*;
+
+pub(crate) fn test_dist_tags(ctx: &mut TestContext<'_>) -> Result<()> {
+    let pkg1 = format!("@foo/dt1-{}", ctx.run_id);
+    let tf1 = prepare_project(ctx, &pkg1, "1.0.0", BTreeMap::new(), BTreeMap::new())?;
+    publish_pkg(ctx, &tf1)?;
+    bump_version(ctx, &tf1, "minor")?;
+    publish_pkg_extra(ctx, &tf1, vec!["--tag".into(), "beta".into()])?;
+    let mut args = vec!["dist-tag".into(), "ls".into(), "--json".into()];
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, Some(&tf1), args)?;
+    assert_eq_str(
+        &normalize_dist_tag_list(&resp.stdout),
+        "beta: 1.1.0\nlatest: 1.0.0",
+    )?;
+
+    let pkg2 = format!("@verdaccio/dt2-{}", ctx.run_id);
+    let tf2 = prepare_project(ctx, &pkg2, "1.0.0", BTreeMap::new(), BTreeMap::new())?;
+    publish_pkg(ctx, &tf2)?;
+    bump_version(ctx, &tf2, "minor")?;
+    publish_pkg_extra(ctx, &tf2, vec!["--tag".into(), "beta".into()])?;
+    let mut args = vec![
+        "dist-tag".into(),
+        "rm".into(),
+        format!("{pkg2}@1.1.0"),
+        "beta".into(),
+    ];
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, Some(&tf2), args)?;
+    assert_eq_str(resp.stdout.trim(), &format!("-beta: {pkg2}@1.1.0"))?;
+
+    let pkg3 = format!("@verdaccio/dt3-{}", ctx.run_id);
+    let tf3 = prepare_project(ctx, &pkg3, "1.0.0", BTreeMap::new(), BTreeMap::new())?;
+    publish_pkg(ctx, &tf3)?;
+    bump_version(ctx, &tf3, "minor")?;
+    publish_pkg(ctx, &tf3)?;
+    let mut args = vec![
+        "dist-tag".into(),
+        "add".into(),
+        format!("{pkg3}@1.1.0"),
+        "alfa".into(),
+    ];
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, Some(&tf3), args)?;
+    assert_eq_str(resp.stdout.trim(), &format!("+alfa: {pkg3}@1.1.0"))?;
+    Ok(())
+}
+
+fn normalize_dist_tag_list(output: &str) -> String {
+    output
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty())
+        .collect::<Vec<_>>()
+        .join("\n")
+}

package/src/e2e_tests/info.rs

@@ -0,0 +1,43 @@
+use super::prelude::*;
+
+pub(crate) fn test_info(ctx: &mut TestContext<'_>) -> Result<()> {
+    let dir = create_temp_dir(ctx.state, "info-test")?
+        .path()
+        .to_path_buf();
+    fs::write(
+        dir.join("package.json"),
+        r#"{"name":"info-test","version":"1.0.0"}"#,
+    )?;
+    let mut args = vec!["info".into(), "verdaccio".into(), "--json".into()];
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, Some(&dir), args)?;
+    match ctx.adapter.kind {
+        AdapterType::YarnClassic => {
+            let found = resp.stdout.lines().any(|line| {
+                serde_json::from_str::<Value>(line)
+                    .ok()
+                    .and_then(|v| v.get("type").cloned())
+                    .and_then(|v| v.as_str().map(|s| s == "inspect"))
+                    .unwrap_or(false)
+            });
+            assert_true(
+                found,
+                "Expected yarn info NDJSON to contain an inspect entry",
+            )?;
+        }
+        AdapterType::Deno => assert_contains(&(resp.stdout + &resp.stderr), "verdaccio")?,
+        _ => {
+            let parsed = parse_info_json(&resp.stdout)?;
+            assert_eq_json(
+                parsed.get("name"),
+                "verdaccio",
+                "Expected package name verdaccio",
+            )?;
+            assert_true(
+                parsed.get("dependencies").is_some(),
+                "Expected dependencies to be defined",
+            )?;
+        }
+    }
+    Ok(())
+}

package/src/e2e_tests/install.rs

@@ -0,0 +1,27 @@
+use super::prelude::*;
+
+pub(crate) fn test_install(ctx: &mut TestContext<'_>) -> Result<()> {
+    let mut deps = BTreeMap::new();
+    deps.insert("react".into(), "18.2.0".into());
+    let temp = prepare_project(
+        ctx,
+        &format!("install-test-{}", ctx.run_id),
+        "1.0.0",
+        deps,
+        BTreeMap::new(),
+    )?;
+    let mut args = vec!["install".into()];
+    if ctx.adapter.kind == AdapterType::Npm {
+        args.push("--json".into());
+    }
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, Some(&temp), args)?;
+    if ctx.adapter.kind == AdapterType::Npm {
+        let parsed: Value = serde_json::from_str(&resp.stdout)?;
+        assert_true(
+            parsed.get("added").is_some(),
+            "Expected \"added\" field in install response",
+        )?;
+    }
+    Ok(())
+}

package/src/e2e_tests/login.rs

@@ -0,0 +1,64 @@
+use super::prelude::*;
+
+pub(crate) fn test_login(ctx: &mut TestContext<'_>) -> Result<()> {
+    if ctx.adapter.kind != AdapterType::YarnModern {
+        return Ok(());
+    }
+    let user1 = format!("login-a-{}", ctx.run_id);
+    let password1 = "test-password-123";
+    let email1 = format!("{user1}@test.example.com");
+    sub_test(ctx, "create new user + whoami", |ctx| {
+        let tf = prepare_login_project(ctx, &format!("verdaccio-login1-{}", ctx.run_id))?;
+        let login = yarn_login(ctx, &tf, &user1, password1, &email1)?;
+        assert_true(
+            login.stdout.contains("Logged in") || login.stdout.contains("token saved"),
+            "Expected login success message",
+        )?;
+        assert_contains(&yarn_whoami(ctx, &tf)?, &user1)
+    })?;
+    sub_test(ctx, "login existing user", |ctx| {
+        let tf = prepare_login_project(ctx, &format!("verdaccio-login2-{}", ctx.run_id))?;
+        let login = yarn_login(ctx, &tf, &user1, password1, &email1)?;
+        assert_true(
+            login.stdout.contains("Logged in") || login.stdout.contains("token saved"),
+            "Expected login success message",
+        )?;
+        assert_contains(&yarn_whoami(ctx, &tf)?, &user1)
+    })?;
+    sub_test(ctx, "wrong password fails", |ctx| {
+        let tf = prepare_login_project(ctx, &format!("verdaccio-login3-{}", ctx.run_id))?;
+        let failed = yarn_login(ctx, &tf, &user1, "wrong-password", &email1).is_err();
+        assert_true(failed, "Login with wrong password should have failed")
+    })?;
+    sub_test(ctx, "login then publish", |ctx| {
+        let pkg = format!("@verdaccio/login-pub-{}", ctx.run_id);
+        let tf = create_temp_dir(ctx.state, &format!("login-pub-{}", ctx.run_id))?
+            .path()
+            .to_path_buf();
+        fs::write(
+            tf.join(".yarnrc.yml"),
+            yarn_config(&ctx.registry_url, None, ctx.adapter.yarn_major)?,
+        )?;
+        fs::write(
+            tf.join("package.json"),
+            package_json(&pkg, "1.0.0", BTreeMap::new(), BTreeMap::new())?,
+        )?;
+        fs::write(tf.join("README.md"), readme(&pkg))?;
+        import_plugin(ctx, &tf, "npm-login")?;
+        yarn_login(ctx, &tf, &user1, password1, &email1)?;
+        exec_adapter(ctx, Some(&tf), vec!["install".into()])?;
+        let published = exec_adapter(ctx, Some(&tf), vec!["publish".into()])?;
+        assert_contains(&published.stdout, "Package archive published")
+    })?;
+    sub_test(ctx, "switch users", |ctx| {
+        let user2 = format!("login-b-{}", ctx.run_id);
+        let password2 = "other-password-456";
+        let email2 = format!("{user2}@test.example.com");
+        let tf = prepare_login_project(ctx, &format!("verdaccio-login5-{}", ctx.run_id))?;
+        yarn_login(ctx, &tf, &user1, password1, &email1)?;
+        assert_contains(&yarn_whoami(ctx, &tf)?, &user1)?;
+        yarn_login(ctx, &tf, &user2, password2, &email2)?;
+        assert_contains(&yarn_whoami(ctx, &tf)?, &user2)
+    })?;
+    Ok(())
+}

package/src/e2e_tests/mod.rs

@@ -0,0 +1,104 @@
+pub(crate) mod audit;
+pub(crate) mod ci;
+pub(crate) mod deprecate;
+pub(crate) mod dist_tags;
+pub(crate) mod info;
+pub(crate) mod install;
+pub(crate) mod login;
+pub(crate) mod ping;
+pub(crate) mod publish;
+pub(crate) mod search;
+pub(crate) mod unpublish;
+
+pub(crate) mod prelude {
+    pub(crate) use anyhow::{Context, Result};
+    pub(crate) use reqwest::blocking::Client;
+    pub(crate) use serde_json::Value;
+    pub(crate) use std::collections::BTreeMap;
+    pub(crate) use std::fs;
+
+    pub(crate) use crate::*;
+}
+
+pub(crate) fn all_tests() -> Vec<crate::TestDefinition> {
+    vec![
+        crate::TestDefinition {
+            name: "publish",
+            requires: &["publish"],
+            applies_to: |_| true,
+            run: publish::test_publish,
+        },
+        crate::TestDefinition {
+            name: "install",
+            requires: &["install"],
+            applies_to: |_| true,
+            run: install::test_install,
+        },
+        crate::TestDefinition {
+            name: "ci",
+            requires: &["install"],
+            applies_to: |_| true,
+            run: ci::test_ci,
+        },
+        crate::TestDefinition {
+            name: "audit",
+            requires: &["audit"],
+            applies_to: |_| true,
+            run: audit::test_audit,
+        },
+        crate::TestDefinition {
+            name: "info",
+            requires: &["info"],
+            applies_to: |_| true,
+            run: info::test_info,
+        },
+        crate::TestDefinition {
+            name: "deprecate",
+            requires: &["deprecate"],
+            applies_to: |_| true,
+            run: deprecate::test_deprecate,
+        },
+        crate::TestDefinition {
+            name: "dist-tags",
+            requires: &["dist-tag"],
+            applies_to: |_| true,
+            run: dist_tags::test_dist_tags,
+        },
+        crate::TestDefinition {
+            name: "login",
+            requires: &["login"],
+            applies_to: |_| true,
+            run: login::test_login,
+        },
+        crate::TestDefinition {
+            name: "ping",
+            requires: &["ping"],
+            applies_to: |_| true,
+            run: ping::test_ping,
+        },
+        crate::TestDefinition {
+            name: "search",
+            requires: &["search"],
+            applies_to: |_| true,
+            run: search::test_search,
+        },
+        crate::TestDefinition {
+            name: "unpublish",
+            requires: &["unpublish"],
+            applies_to: |_| true,
+            run: unpublish::test_unpublish,
+        },
+        crate::TestDefinition {
+            name: "scenario:install-multiple-deps",
+            requires: &["publish", "install", "info"],
+            applies_to: |_| true,
+            run: crate::scenarios::install_multiple_deps::scenario_install_multiple_deps,
+        },
+        crate::TestDefinition {
+            name: "scenario:minimum-release-age",
+            requires: &["publish", "install"],
+            applies_to: crate::is_pnpm_minimum_release_age_capable,
+            run: crate::scenarios::minimum_release_age::scenario_minimum_release_age,
+        },
+    ]
+}

package/src/e2e_tests/ping.rs

@@ -0,0 +1,33 @@
+use super::prelude::*;
+
+pub(crate) fn test_ping(ctx: &mut TestContext<'_>) -> Result<()> {
+    let cwd = if ctx.adapter.kind == AdapterType::YarnModern {
+        let temp = prepare_project(
+            ctx,
+            &format!("verdaccio-ping-{}", ctx.run_id),
+            "1.0.0",
+            BTreeMap::new(),
+            BTreeMap::new(),
+        )?;
+        import_plugin(ctx, &temp, "npm-ping")?;
+        Some(temp)
+    } else {
+        None
+    };
+    let mut args = vec!["ping".into()];
+    if ctx.adapter.kind != AdapterType::YarnModern {
+        args.push("--json".into());
+    }
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, cwd.as_deref(), args)?;
+    if ctx.adapter.kind != AdapterType::YarnModern {
+        let parsed: Value = serde_json::from_str(&resp.stdout)?;
+        let expected_registry = format!("{}/", ctx.registry_url);
+        assert_eq_json(
+            parsed.get("registry"),
+            expected_registry.as_str(),
+            "Registry mismatch",
+        )?;
+    }
+    Ok(())
+}

package/src/e2e_tests/publish.rs

@@ -0,0 +1,68 @@
+use super::prelude::*;
+
+pub(crate) fn test_publish(ctx: &mut TestContext<'_>) -> Result<()> {
+    let packages = vec![
+        format!("verdaccio-memory-{}", ctx.run_id),
+        format!("verdaccio-{}", ctx.run_id),
+        format!("@verdaccio/foo-{}", ctx.run_id),
+        format!("@verdaccio/some-foo-{}", ctx.run_id),
+    ];
+    for pkg_name in packages {
+        let temp = prepare_project(ctx, &pkg_name, "1.0.0", BTreeMap::new(), BTreeMap::new())?;
+        if ctx.adapter.kind == AdapterType::YarnModern {
+            exec_adapter(ctx, Some(&temp), vec!["install".into()])?;
+        }
+        let mut args = vec!["publish".into(), "--json".into()];
+        args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+        let resp = exec_adapter(ctx, Some(&temp), args)?;
+        match ctx.adapter.kind {
+            AdapterType::YarnModern => assert_contains(&resp.stdout, "Package archive published")?,
+            AdapterType::YarnClassic => {
+                assert_true(!resp.stdout.is_empty(), "Expected publish output")?
+            }
+            AdapterType::Bun => {}
+            _ => {
+                if let Ok(parsed) = serde_json::from_str::<Value>(&resp.stdout) {
+                    let expected_id = format!("{pkg_name}@1.0.0");
+                    let published_name = parsed.get("name").and_then(Value::as_str);
+                    let published_id = parsed.get("id").and_then(Value::as_str);
+                    if published_name.is_some() || published_id.is_some() {
+                        assert_true(
+                            published_name == Some(pkg_name.as_str())
+                                || published_id == Some(expected_id.as_str()),
+                            &format!(
+                                "Expected package name \"{pkg_name}\" or id \"{expected_id}\""
+                            ),
+                        )?;
+                    }
+                }
+            }
+        }
+        assert_published(ctx, &pkg_name)?;
+    }
+    Ok(())
+}
+
+fn assert_published(ctx: &TestContext<'_>, pkg_name: &str) -> Result<()> {
+    let encoded = pkg_name.replace('/', "%2F");
+    let response = Client::new()
+        .get(format!(
+            "{}/{}",
+            ctx.registry_url.trim_end_matches('/'),
+            encoded
+        ))
+        .bearer_auth(&ctx.token)
+        .send()
+        .with_context(|| format!("failed to fetch published package {pkg_name}"))?;
+    let status = response.status();
+    let body: Value = response.json().unwrap_or(Value::Null);
+    assert_true(
+        status.is_success(),
+        &format!("Expected published package {pkg_name}, got {status} {body}"),
+    )?;
+    assert_eq_json(
+        body.get("name"),
+        pkg_name,
+        "Expected published registry package name",
+    )
+}

package/src/e2e_tests/search.rs

@@ -0,0 +1,14 @@
+use super::prelude::*;
+
+pub(crate) fn test_search(ctx: &mut TestContext<'_>) -> Result<()> {
+    let mut args = vec!["search".into(), "@verdaccio/cli".into(), "--json".into()];
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, None, args)?;
+    let parsed: Value = serde_json::from_str(&resp.stdout)?;
+    let found = parsed
+        .as_array()
+        .unwrap_or(&Vec::new())
+        .iter()
+        .any(|item| item.get("name").and_then(Value::as_str) == Some("@verdaccio/cli"));
+    assert_true(found, "Expected to find @verdaccio/cli in search results")
+}

package/src/e2e_tests/unpublish.rs

@@ -0,0 +1,37 @@
+use super::prelude::*;
+
+pub(crate) fn test_unpublish(ctx: &mut TestContext<'_>) -> Result<()> {
+    let pkg = format!("@verdaccio/unpub1-{}", ctx.run_id);
+    let temp = prepare_project(ctx, &pkg, "1.0.0", BTreeMap::new(), BTreeMap::new())?;
+    for bump in ["minor", "minor", "major"] {
+        publish_pkg(ctx, &temp)?;
+        bump_version(ctx, &temp, bump)?;
+    }
+    publish_pkg(ctx, &temp)?;
+    let mut args = vec![
+        "unpublish".into(),
+        pkg.clone(),
+        "--force".into(),
+        "--loglevel=info".into(),
+        "--json".into(),
+    ];
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, Some(&temp), args)?;
+    assert_contains(&resp.stdout, &pkg)?;
+
+    let pkg2 = format!("@verdaccio/unpub2-{}", ctx.run_id);
+    let temp2 = prepare_project(ctx, &pkg2, "1.0.0", BTreeMap::new(), BTreeMap::new())?;
+    publish_pkg(ctx, &temp2)?;
+    bump_version(ctx, &temp2, "minor")?;
+    publish_pkg(ctx, &temp2)?;
+    let mut args = vec![
+        "unpublish".into(),
+        format!("{pkg2}@1.0.0"),
+        "--force".into(),
+        "--loglevel=info".into(),
+        "--json".into(),
+    ];
+    args.extend(registry_arg(&ctx.adapter, &ctx.registry_url));
+    let resp = exec_adapter(ctx, Some(&temp2), args)?;
+    assert_contains(&resp.stdout, &pkg2)
+}