fix: avoid global declaration collisions in cjs (#15608)

* Use a default stack size * 2 in debug for Windows because swc using so much stack size. We should look into this more later though.
author: David Sherret <dsherret@users.noreply.github.com> 2022-08-25 20:24:18 -0400
committer: GitHub <noreply@github.com> 2022-08-25 20:24:18 -0400
commit: 376665d1154501660e7b20f760a0482509cff8b0 (patch)
tree: 0a979722c66f8ede48f1dff21c8ceb335521a94a /test_util/src
parent: 0fe590bbcbf270b50abd8d73db1c5e0be69591f1 (diff)
2 files changed, 190 insertions, 1 deletions
diff --git a/test_util/src/lib.rs b/test_util/src/lib.rs
index 1e80c0d1d..af4c814c4 100644
--- a/test_util/src/lib.rs
+++ b/test_util/src/lib.rs
@@ -14,6 +14,7 @@ use hyper::Request;
 use hyper::Response;
 use hyper::StatusCode;
 use lazy_static::lazy_static;
+use npm::custom_npm_cache;
 use os_pipe::pipe;
 use pretty_assertions::assert_eq;
 use regex::Regex;
@@ -51,6 +52,7 @@ use tokio_tungstenite::accept_async;
 
 pub mod assertions;
 pub mod lsp;
+mod npm;
 pub mod pty;
 mod temp_dir;
 
@@ -953,7 +955,22 @@ async fn main_server(
       }
 
       // serve npm registry files
-      if req.uri().path().starts_with("/npm/registry/") {
+      if let Some(suffix) =
+        req.uri().path().strip_prefix("/npm/registry/@denotest/")
+      {
+        // serve all requests to /npm/registry/@deno using the file system
+        // at that path
+        match handle_custom_npm_registry_path(suffix) {
+          Ok(Some(response)) => return Ok(response),
+          Ok(None) => {} // ignore, not found
+          Err(err) => {
+            return Response::builder()
+              .status(StatusCode::INTERNAL_SERVER_ERROR)
+              .body(format!("{:#}", err).into());
+          }
+        }
+      } else if req.uri().path().starts_with("/npm/registry/") {
+        // otherwise, serve based on registry.json and tgz files
         let is_tarball = req.uri().path().ends_with(".tgz");
         if !is_tarball {
           file_path.push("registry.json");
@@ -985,6 +1002,33 @@ async fn main_server(
   };
 }
 
+fn handle_custom_npm_registry_path(
+  path: &str,
+) -> Result<Option<Response<Body>>, anyhow::Error> {
+  let parts = path
+    .split('/')
+    .filter(|p| !p.is_empty())
+    .collect::<Vec<_>>();
+  let cache = custom_npm_cache()?;
+  let package_name = format!("@denotest/{}", parts[0]);
+  if parts.len() == 2 {
+    if let Some(file_bytes) =
+      cache.tarball_bytes(&package_name, parts[1].trim_end_matches(".tgz"))
+    {
+      let file_resp = custom_headers("file.tgz", file_bytes.to_owned());
+      return Ok(Some(file_resp));
+    }
+  } else if parts.len() == 1 {
+    if let Some(registry_file) = cache.registry_file(&package_name) {
+      let file_resp =
+        custom_headers("registry.json", registry_file.as_bytes().to_vec());
+      return Ok(Some(file_resp));
+    }
+  }
+
+  Ok(None)
+}
+
 fn should_download_npm_packages() -> bool {
   // when this env var is set, it will download and save npm packages
   // to the testdata/npm/registry directory
@@ -1489,6 +1533,8 @@ fn custom_headers(p: &str, body: Vec<u8>) -> Response<Body> {
     Some("application/json")
   } else if p.ends_with(".wasm") {
     Some("application/wasm")
+  } else if p.ends_with(".tgz") {
+    Some("application/gzip")
   } else {
     None
   };
diff --git a/test_util/src/npm.rs b/test_util/src/npm.rs
new file mode 100644
index 000000000..dd194facc
--- /dev/null
+++ b/test_util/src/npm.rs
@@ -0,0 +1,143 @@
+use std::collections::HashMap;
+use std::fs;
+
+use anyhow::Context;
+use flate2::write::GzEncoder;
+use flate2::Compression;
+use once_cell::sync::Lazy;
+use tar::Builder;
+
+use crate::testdata_path;
+
+static CUSTOM_NPM_PACKAGE_CACHE: Lazy<Result<CustomNpmPackageCache, String>> =
+  Lazy::new(|| CustomNpmPackageCache::load().map_err(|e| e.to_string()));
+
+/// Get a reference to the custom npm cache which is lazily created.
+pub fn custom_npm_cache(
+) -> Result<&'static CustomNpmPackageCache, anyhow::Error> {
+  match &*CUSTOM_NPM_PACKAGE_CACHE {
+    Ok(cache) => Ok(cache),
+    Err(err) => Err(anyhow::anyhow!("{}", err)),
+  }
+}
+
+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.
+pub struct CustomNpmPackageCache(HashMap<String, CustomNpmPackage>);
+
+impl CustomNpmPackageCache {
+  pub fn load() -> Result<Self, anyhow::Error> {
+    use ring::digest::Context;
+    use ring::digest::SHA512;
+
+    // read all the packages in the @denotest folder
+    let custom_packages_path = testdata_path().join("npm/registry/@denotest");
+    let mut packages = HashMap::new();
+    for entry in fs::read_dir(&custom_packages_path)? {
+      let entry = entry?;
+      let file_type = entry.file_type()?;
+      if !file_type.is_dir() {
+        continue;
+      }
+
+      // read all the package's versions
+      let mut tarballs = HashMap::new();
+      let package_folder_name = entry.file_name().to_string_lossy().to_string();
+      let package_name = format!("@denotest/{}", package_folder_name);
+      let package_folder = custom_packages_path.join(&package_folder_name);
+      let mut versions = serde_json::Map::new();
+      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.display()
+                )
+              })?;
+            builder.finish()?;
+          }
+          encoder.finish()?;
+        }
+
+        // get tarball hash
+        let mut hash_ctx = Context::new(&SHA512);
+        hash_ctx.update(&tarball_bytes);
+        let digest = hash_ctx.finish();
+        let tarball_checksum = base64::encode(digest.as_ref()).to_lowercase();
+
+        // 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/{}/{}.tgz",
+            package_name, version
+          )
+          .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.display()
+            )
+          })?;
+        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());
+        versions.insert(version, version_info.into());
+      }
+
+      // create the registry file for this package
+      let mut registry_file = serde_json::Map::new();
+      registry_file.insert("name".to_string(), package_name.clone().into());
+      registry_file.insert("versions".to_string(), versions.into());
+      packages.insert(
+        package_name,
+        CustomNpmPackage {
+          registry_file: serde_json::to_string(&registry_file).unwrap(),
+          tarballs,
+        },
+      );
+    }
+
+    Ok(Self(packages))
+  }
+
+  pub fn tarball_bytes(&self, name: &str, version: &str) -> Option<&Vec<u8>> {
+    self.0.get(name).and_then(|p| p.tarballs.get(version))
+  }
+
+  pub fn registry_file(&self, name: &str) -> Option<&String> {
+    self.0.get(name).map(|p| &p.registry_file)
+  }
+}
author	David Sherret <dsherret@users.noreply.github.com>	2022-08-25 20:24:18 -0400
committer	GitHub <noreply@github.com>	2022-08-25 20:24:18 -0400
commit	376665d1154501660e7b20f760a0482509cff8b0 (patch)
tree	0a979722c66f8ede48f1dff21c8ceb335521a94a /test_util/src
parent	0fe590bbcbf270b50abd8d73db1c5e0be69591f1 (diff)