chore: move `test_util` to `tests/util/server` (#22444)

As discussed with @mmastrac.

---------

Signed-off-by: Asher Gomez <ashersaupingomez@gmail.com>
Co-authored-by: Matt Mastracci <matthew@mastracci.com>

1 files changed, 179 insertions, 0 deletions

diff --git a/tests/util/server/src/npm.rs b/tests/util/server/src/npm.rs
new file mode 100644
index 000000000..7469e9b9e
--- /dev/null
+++ b/tests/util/server/src/npm.rs
@@ -0,0 +1,179 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+use std::collections::HashMap;
+use std::fs;
+
+use anyhow::Context;
+use anyhow::Result;
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
+use flate2::write::GzEncoder;
+use flate2::Compression;
+use once_cell::sync::Lazy;
+use parking_lot::Mutex;
+use tar::Builder;
+
+use crate::testdata_path;
+
+pub static CUSTOM_NPM_PACKAGE_CACHE: Lazy<CustomNpmPackageCache> =
+  Lazy::new(CustomNpmPackageCache::default);
+
+struct CustomNpmPackage {
+  pub registry_file: String,
+  pub tarballs: HashMap<String, Vec<u8>>,
+}
+
+/// Creates tarballs and a registry json file for npm packages
+/// in the `testdata/npm/registry/@denotest` directory.
+#[derive(Default)]
+pub struct CustomNpmPackageCache(Mutex<HashMap<String, CustomNpmPackage>>);
+
+impl CustomNpmPackageCache {
+  pub fn tarball_bytes(
+    &self,
+    name: &str,
+    version: &str,
+  ) -> Result<Option<Vec<u8>>> {
+    Ok(
+      self
+        .get_package_property(name, |p| p.tarballs.get(version).cloned())?
+        .flatten(),
+    )
+  }
+
+  pub fn registry_file(&self, name: &str) -> Result<Option<Vec<u8>>> {
+    self.get_package_property(name, |p| p.registry_file.as_bytes().to_vec())
+  }
+
+  fn get_package_property<TResult>(
+    &self,
+    package_name: &str,
+    func: impl FnOnce(&CustomNpmPackage) -> TResult,
+  ) -> Result<Option<TResult>> {
+    // it's ok if multiple threads race here as they will do the same work twice
+    if !self.0.lock().contains_key(package_name) {
+      match get_npm_package(package_name)? {
+        Some(package) => {
+          self.0.lock().insert(package_name.to_string(), package);
+        }
+        None => return Ok(None),
+      }
+    }
+    Ok(self.0.lock().get(package_name).map(func))
+  }
+}
+
+fn get_npm_package(package_name: &str) -> Result<Option<CustomNpmPackage>> {
+  let package_folder = testdata_path().join("npm/registry").join(package_name);
+  if !package_folder.exists() {
+    return Ok(None);
+  }
+
+  // read all the package's versions
+  let mut tarballs = HashMap::new();
+  let mut versions = serde_json::Map::new();
+  let mut latest_version = semver::Version::parse("0.0.0").unwrap();
+  for entry in fs::read_dir(&package_folder)? {
+    let entry = entry?;
+    let file_type = entry.file_type()?;
+    if !file_type.is_dir() {
+      continue;
+    }
+    let version = entry.file_name().to_string_lossy().to_string();
+    let version_folder = package_folder.join(&version);
+
+    // create the tarball
+    let mut tarball_bytes = Vec::new();
+    {
+      let mut encoder =
+        GzEncoder::new(&mut tarball_bytes, Compression::default());
+      {
+        let mut builder = Builder::new(&mut encoder);
+        builder
+          .append_dir_all("package", &version_folder)
+          .with_context(|| {
+            format!("Error adding tarball for directory: {}", version_folder)
+          })?;
+        builder.finish()?;
+      }
+      encoder.finish()?;
+    }
+
+    // get tarball hash
+    let tarball_checksum = get_tarball_checksum(&tarball_bytes);
+
+    // create the registry file JSON for this version
+    let mut dist = serde_json::Map::new();
+    dist.insert(
+      "integrity".to_string(),
+      format!("sha512-{tarball_checksum}").into(),
+    );
+    dist.insert("shasum".to_string(), "dummy-value".into());
+    dist.insert(
+      "tarball".to_string(),
+      format!(
+        "http://localhost:4545/npm/registry/{package_name}/{version}.tgz"
+      )
+      .into(),
+    );
+
+    tarballs.insert(version.clone(), tarball_bytes);
+    let package_json_path = version_folder.join("package.json");
+    let package_json_text = fs::read_to_string(&package_json_path)
+      .with_context(|| {
+        format!("Error reading package.json at {}", package_json_path)
+      })?;
+    let mut version_info: serde_json::Map<String, serde_json::Value> =
+      serde_json::from_str(&package_json_text)?;
+    version_info.insert("dist".to_string(), dist.into());
+
+    if let Some(maybe_optional_deps) = version_info.get("optionalDependencies")
+    {
+      if let Some(optional_deps) = maybe_optional_deps.as_object() {
+        if let Some(maybe_deps) = version_info.get("dependencies") {
+          if let Some(deps) = maybe_deps.as_object() {
+            let mut cloned_deps = deps.to_owned();
+            for (key, value) in optional_deps {
+              cloned_deps.insert(key.to_string(), value.to_owned());
+            }
+            version_info.insert(
+              "dependencies".to_string(),
+              serde_json::to_value(cloned_deps).unwrap(),
+            );
+          }
+        } else {
+          version_info.insert(
+            "dependencies".to_string(),
+            serde_json::to_value(optional_deps).unwrap(),
+          );
+        }
+      }
+    }
+
+    versions.insert(version.clone(), version_info.into());
+    let version = semver::Version::parse(&version)?;
+    if version.cmp(&latest_version).is_gt() {
+      latest_version = version;
+    }
+  }
+
+  let mut dist_tags = serde_json::Map::new();
+  dist_tags.insert("latest".to_string(), latest_version.to_string().into());
+
+  // create the registry file for this package
+  let mut registry_file = serde_json::Map::new();
+  registry_file.insert("name".to_string(), package_name.to_string().into());
+  registry_file.insert("versions".to_string(), versions.into());
+  registry_file.insert("dist-tags".to_string(), dist_tags.into());
+  Ok(Some(CustomNpmPackage {
+    registry_file: serde_json::to_string(&registry_file).unwrap(),
+    tarballs,
+  }))
+}
+
+fn get_tarball_checksum(bytes: &[u8]) -> String {
+  use sha2::Digest;
+  let mut hasher = sha2::Sha512::new();
+  hasher.update(bytes);
+  BASE64_STANDARD.encode(hasher.finalize())
+}