// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. use crate::compiler::ModuleMetaData; use crate::errors; use crate::errors::DenoError; use crate::errors::DenoResult; use crate::errors::ErrorKind; use crate::fs as deno_fs; use crate::http_util; use crate::js_errors::SourceMapGetter; use crate::msg; use crate::progress::Progress; use crate::tokio_util; use crate::version; use dirs; use futures::future::{loop_fn, Either, Loop}; use futures::Future; use http; use ring; use serde_json; use std; use std::fmt::Write; use std::fs; use std::path::Path; use std::path::PathBuf; use std::result::Result; use std::str; use url; use url::Url; #[derive(Clone)] pub struct DenoDir { // Example: /Users/rld/.deno/ pub root: PathBuf, // In the Go code this was called SrcDir. // This is where we cache http resources. Example: // /Users/rld/.deno/deps/github.com/ry/blah.js pub gen: PathBuf, // In the Go code this was called CacheDir. // This is where we cache compilation outputs. Example: // /Users/rld/.deno/gen/f39a473452321cacd7c346a870efb0e3e1264b43.js pub deps: PathBuf, // This splits to http and https deps pub deps_http: PathBuf, pub deps_https: PathBuf, /// The active configuration file contents (or empty array) which applies to /// source code cached by `DenoDir`. pub config: Vec, pub progress: Progress, } impl DenoDir { // Must be called before using any function from this module. // https://github.com/denoland/deno/blob/golang/deno_dir.go#L99-L111 pub fn new( custom_root: Option, state_config: &Option>, progress: Progress, ) -> std::io::Result { // Only setup once. let home_dir = dirs::home_dir().expect("Could not get home directory."); let fallback = home_dir.join(".deno"); // We use the OS cache dir because all files deno writes are cache files // Once that changes we need to start using different roots if DENO_DIR // is not set, and keep a single one if it is. let default = dirs::cache_dir() .map(|d| d.join("deno")) .unwrap_or(fallback); let root: PathBuf = custom_root.unwrap_or(default); let gen = root.as_path().join("gen"); let deps = root.as_path().join("deps"); let deps_http = deps.join("http"); let deps_https = deps.join("https"); // Internally within DenoDir, we use the config as part of the hash to // determine if a file has been transpiled with the same configuration, but // we have borrowed the `State` configuration, which we want to either clone // or create an empty `Vec` which we will use in our hash function. let config = match state_config { Some(config) => config.clone(), _ => b"".to_vec(), }; let deno_dir = Self { root, gen, deps, deps_http, deps_https, config, progress, }; // TODO Lazily create these directories. deno_fs::mkdir(deno_dir.gen.as_ref(), 0o755, true)?; deno_fs::mkdir(deno_dir.deps.as_ref(), 0o755, true)?; deno_fs::mkdir(deno_dir.deps_http.as_ref(), 0o755, true)?; deno_fs::mkdir(deno_dir.deps_https.as_ref(), 0o755, true)?; debug!("root {}", deno_dir.root.display()); debug!("gen {}", deno_dir.gen.display()); debug!("deps {}", deno_dir.deps.display()); debug!("deps_http {}", deno_dir.deps_http.display()); debug!("deps_https {}", deno_dir.deps_https.display()); Ok(deno_dir) } // https://github.com/denoland/deno/blob/golang/deno_dir.go#L32-L35 pub fn cache_path( self: &Self, filename: &str, source_code: &[u8], ) -> (PathBuf, PathBuf) { let cache_key = source_code_hash(filename, source_code, version::DENO, &self.config); ( self.gen.join(cache_key.to_string() + ".js"), self.gen.join(cache_key.to_string() + ".js.map"), ) } pub fn code_cache( self: &Self, module_meta_data: &ModuleMetaData, ) -> std::io::Result<()> { let (cache_path, source_map_path) = self .cache_path(&module_meta_data.filename, &module_meta_data.source_code); // TODO(ry) This is a race condition w.r.t to exists() -- probably should // create the file in exclusive mode. A worry is what might happen is there // are two processes and one reads the cache file while the other is in the // midst of writing it. if cache_path.exists() && source_map_path.exists() { Ok(()) } else { match &module_meta_data.maybe_output_code { Some(output_code) => fs::write(cache_path, output_code), _ => Ok(()), }?; match &module_meta_data.maybe_source_map { Some(source_map) => fs::write(source_map_path, source_map), _ => Ok(()), }?; Ok(()) } } pub fn fetch_module_meta_data_async( self: &Self, specifier: &str, referrer: &str, use_cache: bool, no_fetch: bool, ) -> impl Future { debug!( "fetch_module_meta_data. specifier {} referrer {}", specifier, referrer ); let specifier = specifier.to_string(); let referrer = referrer.to_string(); let result = self.resolve_module(&specifier, &referrer); if let Err(err) = result { return Either::A(futures::future::err(DenoError::from(err))); } let (module_name, filename) = result.unwrap(); let gen = self.gen.clone(); // If we don't clone the config, we then end up creating an implied lifetime // which gets returned in the future, so we clone here so as to not leak the // move below when the future is resolving. let config = self.config.clone(); Either::B( get_source_code_async( self, module_name.as_str(), filename.as_str(), use_cache, no_fetch, ).then(move |result| { let mut out = match result { Ok(out) => out, Err(err) => { if err.kind() == ErrorKind::NotFound { // For NotFound, change the message to something better. return Err(errors::new( ErrorKind::NotFound, format!( "Cannot resolve module \"{}\" from \"{}\"", specifier, referrer ), )); } else { return Err(err); } } }; if out.source_code.starts_with(b"#!") { out.source_code = filter_shebang(out.source_code); } // If TypeScript we have to also load corresponding compile js and // source maps (called output_code and output_source_map) if out.media_type != msg::MediaType::TypeScript || !use_cache { return Ok(out); } let cache_key = source_code_hash( &out.filename, &out.source_code, version::DENO, &config, ); let (output_code_filename, output_source_map_filename) = ( gen.join(cache_key.to_string() + ".js"), gen.join(cache_key.to_string() + ".js.map"), ); let result = load_cache2(&output_code_filename, &output_source_map_filename); match result { Err(err) => { if err.kind() == std::io::ErrorKind::NotFound { // If there's no compiled JS or source map, that's ok, just // return what we have. Ok(out) } else { Err(err.into()) } } Ok((output_code, source_map)) => { out.maybe_output_code = Some(output_code); out.maybe_source_map = Some(source_map); out.maybe_output_code_filename = Some(output_code_filename.to_str().unwrap().to_string()); out.maybe_source_map_filename = Some(output_source_map_filename.to_str().unwrap().to_string()); Ok(out) } } }), ) } /// Synchronous version of fetch_module_meta_data_async /// This function is deprecated. pub fn fetch_module_meta_data( self: &Self, specifier: &str, referrer: &str, use_cache: bool, no_fetch: bool, ) -> Result { tokio_util::block_on( self .fetch_module_meta_data_async(specifier, referrer, use_cache, no_fetch), ) } // Prototype: https://github.com/denoland/deno/blob/golang/os.go#L56-L68 fn src_file_to_url(self: &Self, filename: &str) -> String { let filename_path = Path::new(filename); if filename_path.starts_with(&self.deps) { let (rest, prefix) = if filename_path.starts_with(&self.deps_https) { let rest = filename_path.strip_prefix(&self.deps_https).unwrap(); let prefix = "https://".to_string(); (rest, prefix) } else if filename_path.starts_with(&self.deps_http) { let rest = filename_path.strip_prefix(&self.deps_http).unwrap(); let prefix = "http://".to_string(); (rest, prefix) } else { // TODO(kevinkassimo): change this to support other protocols than http unimplemented!() }; // Windows doesn't support ":" in filenames, so we represent port using a // special string. // TODO(ry) This current implementation will break on a URL that has // the default port but contains "_PORT" in the path. let rest = rest.to_str().unwrap().replacen("_PORT", ":", 1); prefix + &rest } else { String::from(filename) } } /// Returns (module name, local filename) pub fn resolve_module_url( self: &Self, specifier: &str, referrer: &str, ) -> Result { let specifier = self.src_file_to_url(specifier); let referrer = self.src_file_to_url(referrer); debug!( "resolve_module specifier {} referrer {}", specifier, referrer ); resolve_file_url(specifier, referrer) } /// Returns (module name, local filename) pub fn resolve_module( self: &Self, specifier: &str, referrer: &str, ) -> Result<(String, String), url::ParseError> { let j = self.resolve_module_url(specifier, referrer)?; let module_name = j.to_string(); let filename; match j.scheme() { "file" => { filename = deno_fs::normalize_path(j.to_file_path().unwrap().as_ref()); } "https" => { filename = deno_fs::normalize_path( get_cache_filename(self.deps_https.as_path(), &j).as_ref(), ) } "http" => { filename = deno_fs::normalize_path( get_cache_filename(self.deps_http.as_path(), &j).as_ref(), ) } // TODO(kevinkassimo): change this to support other protocols than http. _ => unimplemented!(), } debug!("module_name: {}, filename: {}", module_name, filename); Ok((module_name, filename)) } } impl SourceMapGetter for DenoDir { fn get_source_map(&self, script_name: &str) -> Option> { match self.fetch_module_meta_data(script_name, ".", true, true) { Err(_e) => None, Ok(out) => match out.maybe_source_map { None => None, Some(source_map) => Some(source_map), }, } } } /// This fetches source code, locally or remotely. /// module_name is the URL specifying the module. /// filename is the local path to the module (if remote, it is in the cache /// folder, and potentially does not exist yet) /// /// It *does not* fill the compiled JS nor source map portions of /// ModuleMetaData. This is the only difference between this function and /// fetch_module_meta_data_async(). TODO(ry) change return type to reflect this /// fact. /// /// If this is a remote module, and it has not yet been cached, the resulting /// download will be written to "filename". This happens no matter the value of /// use_cache. fn get_source_code_async( deno_dir: &DenoDir, module_name: &str, filename: &str, use_cache: bool, no_fetch: bool, ) -> impl Future { let filename = filename.to_string(); let module_name = module_name.to_string(); let is_module_remote = is_remote(&module_name); // We try fetch local. Three cases: // 1. Remote downloads are not allowed, we're only allowed to use cache. // 2. This is a remote module and we're allowed to use cached downloads. // 3. This is a local module. if !is_module_remote || use_cache || no_fetch { debug!( "fetch local or reload {} is_module_remote {}", module_name, is_module_remote ); // Note that local fetch is done synchronously. match fetch_local_source(deno_dir, &module_name, &filename, None) { Ok(Some(output)) => { debug!("found local source "); return Either::A(futures::future::ok(output)); } Ok(None) => { debug!("fetch_local_source returned None"); } Err(err) => { return Either::A(futures::future::err(err)); } } } // If not remote file stop here! if !is_module_remote { debug!("not remote file stop here"); return Either::A(futures::future::err(DenoError::from( std::io::Error::new( std::io::ErrorKind::NotFound, format!("cannot find local file '{}'", &filename), ), ))); } // If remote downloads are not allowed stop here! if no_fetch { debug!("remote file with no_fetch stop here"); return Either::A(futures::future::err(DenoError::from( std::io::Error::new( std::io::ErrorKind::NotFound, format!("cannot find remote file '{}' in cache", &filename), ), ))); } debug!("is remote but didn't find module"); // not cached/local, try remote. Either::B( fetch_remote_source_async(deno_dir, &module_name, &filename).and_then( move |maybe_remote_source| match maybe_remote_source { Some(output) => Ok(output), None => Err(DenoError::from(std::io::Error::new( std::io::ErrorKind::NotFound, format!("cannot find remote file '{}'", &filename), ))), }, ), ) } #[cfg(test)] /// Synchronous version of get_source_code_async /// This function is deprecated. fn get_source_code( deno_dir: &DenoDir, module_name: &str, filename: &str, use_cache: bool, no_fetch: bool, ) -> DenoResult { tokio_util::block_on(get_source_code_async( deno_dir, module_name, filename, use_cache, no_fetch, )) } fn get_cache_filename(basedir: &Path, url: &Url) -> PathBuf { let host = url.host_str().unwrap(); let host_port = match url.port() { // Windows doesn't support ":" in filenames, so we represent port using a // special string. Some(port) => format!("{}_PORT{}", host, port), None => host.to_string(), }; let mut out = basedir.to_path_buf(); out.push(host_port); for path_seg in url.path_segments().unwrap() { out.push(path_seg); } out } fn load_cache2( js_filename: &PathBuf, map_filename: &PathBuf, ) -> Result<(Vec, Vec), std::io::Error> { debug!( "load_cache code: {} map: {}", js_filename.display(), map_filename.display() ); let read_output_code = fs::read(&js_filename)?; let read_source_map = fs::read(&map_filename)?; Ok((read_output_code, read_source_map)) } /// Generate an SHA1 hash for source code, to be used to determine if a cached /// version of the code is valid or invalid. fn source_code_hash( filename: &str, source_code: &[u8], version: &str, config: &[u8], ) -> String { let mut ctx = ring::digest::Context::new(&ring::digest::SHA1); ctx.update(version.as_bytes()); ctx.update(filename.as_bytes()); ctx.update(source_code); ctx.update(config); let digest = ctx.finish(); let mut out = String::new(); // TODO There must be a better way to do this... for byte in digest.as_ref() { write!(&mut out, "{:02x}", byte).unwrap(); } out } fn is_remote(module_name: &str) -> bool { module_name.starts_with("http://") || module_name.starts_with("https://") } fn parse_local_or_remote(p: &str) -> Result { if is_remote(p) || p.starts_with("file:") { Url::parse(p) } else { Url::from_file_path(p).map_err(|_err| url::ParseError::IdnaError) } } fn map_file_extension(path: &Path) -> msg::MediaType { match path.extension() { None => msg::MediaType::Unknown, Some(os_str) => match os_str.to_str() { Some("ts") => msg::MediaType::TypeScript, Some("js") => msg::MediaType::JavaScript, Some("mjs") => msg::MediaType::JavaScript, Some("json") => msg::MediaType::Json, _ => msg::MediaType::Unknown, }, } } // convert a ContentType string into a enumerated MediaType fn map_content_type(path: &Path, content_type: Option<&str>) -> msg::MediaType { match content_type { Some(content_type) => { // sometimes there is additional data after the media type in // Content-Type so we have to do a bit of manipulation so we are only // dealing with the actual media type let ct_vector: Vec<&str> = content_type.split(';').collect(); let ct: &str = ct_vector.first().unwrap(); match ct.to_lowercase().as_ref() { "application/typescript" | "text/typescript" | "video/vnd.dlna.mpeg-tts" | "video/mp2t" | "application/x-typescript" => msg::MediaType::TypeScript, "application/javascript" | "text/javascript" | "application/ecmascript" | "text/ecmascript" | "application/x-javascript" => msg::MediaType::JavaScript, "application/json" | "text/json" => msg::MediaType::Json, "text/plain" => map_file_extension(path), _ => { debug!("unknown content type: {}", content_type); msg::MediaType::Unknown } } } None => map_file_extension(path), } } fn filter_shebang(bytes: Vec) -> Vec { let string = str::from_utf8(&bytes).unwrap(); if let Some(i) = string.find('\n') { let (_, rest) = string.split_at(i); rest.as_bytes().to_owned() } else { Vec::new() } } /// Asynchronously fetch remote source file specified by the URL `module_name` /// and write it to disk at `filename`. fn fetch_remote_source_async( deno_dir: &DenoDir, module_name: &str, filename: &str, ) -> impl Future, Error = DenoError> { use crate::http_util::FetchOnceResult; let download_job = deno_dir .progress .add(format!("Downloading {}", module_name)); let filename = filename.to_owned(); let module_name = module_name.to_owned(); // We write a special ".headers.json" file into the `.deno/deps` directory along side the // cached file, containing just the media type and possible redirect target (both are http headers). // If redirect target is present, the file itself if not cached. // In future resolutions, we would instead follow this redirect target ("redirect_to"). loop_fn( ( deno_dir.clone(), None, None, module_name.clone(), filename.clone(), ), |( dir, mut maybe_initial_module_name, mut maybe_initial_filename, module_name, filename, )| { let url = module_name.parse::().unwrap(); // Single pass fetch, either yields code or yields redirect. http_util::fetch_string_once(url).and_then(move |fetch_once_result| { match fetch_once_result { FetchOnceResult::Redirect(url) => { // If redirects, update module_name and filename for next looped call. let resolve_result = dir .resolve_module(&(url.to_string()), ".") .map_err(DenoError::from); match resolve_result { Ok((new_module_name, new_filename)) => { if maybe_initial_module_name.is_none() { maybe_initial_module_name = Some(module_name.clone()); maybe_initial_filename = Some(filename.clone()); } // Not yet completed. Follow the redirect and loop. Ok(Loop::Continue(( dir, maybe_initial_module_name, maybe_initial_filename, new_module_name, new_filename, ))) } Err(e) => Err(e), } } FetchOnceResult::Code(source, maybe_content_type) => { // We land on the code. let p = PathBuf::from(filename.clone()); match p.parent() { Some(ref parent) => fs::create_dir_all(parent), None => Ok(()), }?; // Write file and create .headers.json for the file. deno_fs::write_file(&p, &source, 0o666)?; { save_source_code_headers( &filename, maybe_content_type.clone(), None, ); } // Check if this file is downloaded due to some old redirect request. if maybe_initial_filename.is_some() { // If yes, record down the headers for redirect. // Also create its containing folder. let pp = PathBuf::from(filename.clone()); match pp.parent() { Some(ref parent) => fs::create_dir_all(parent), None => Ok(()), }?; { save_source_code_headers( &maybe_initial_filename.clone().unwrap(), maybe_content_type.clone(), Some(module_name.clone()), ); } } Ok(Loop::Break(Some(ModuleMetaData { module_name: module_name.to_string(), module_redirect_source_name: maybe_initial_module_name, filename: filename.to_string(), media_type: map_content_type( &p, maybe_content_type.as_ref().map(String::as_str), ), source_code: source.as_bytes().to_owned(), maybe_output_code_filename: None, maybe_output_code: None, maybe_source_map_filename: None, maybe_source_map: None, }))) } } }) }, ).then(move |r| { // Explicit drop to keep reference alive until future completes. drop(download_job); r }) } /// Fetch remote source code. #[cfg(test)] fn fetch_remote_source( deno_dir: &DenoDir, module_name: &str, filename: &str, ) -> DenoResult> { tokio_util::block_on(fetch_remote_source_async( deno_dir, module_name, filename, )) } /// Fetch local or cached source code. /// This is a recursive operation if source file has redirection. /// It will keep reading filename.headers.json for information about redirection. /// module_initial_source_name would be None on first call, /// and becomes the name of the very first module that initiates the call /// in subsequent recursions. /// AKA if redirection occurs, module_initial_source_name is the source path /// that user provides, and the final module_name is the resolved path /// after following all redirections. fn fetch_local_source( deno_dir: &DenoDir, module_name: &str, filename: &str, module_initial_source_name: Option, ) -> DenoResult> { let p = Path::new(&filename); let source_code_headers = get_source_code_headers(&filename); // If source code headers says that it would redirect elsewhere, // (meaning that the source file might not exist; only .headers.json is present) // Abort reading attempts to the cached source file and and follow the redirect. if let Some(redirect_to) = source_code_headers.redirect_to { // E.g. // module_name https://import-meta.now.sh/redirect.js // filename /Users/kun/Library/Caches/deno/deps/https/import-meta.now.sh/redirect.js // redirect_to https://import-meta.now.sh/sub/final1.js // real_filename /Users/kun/Library/Caches/deno/deps/https/import-meta.now.sh/sub/final1.js // real_module_name = https://import-meta.now.sh/sub/final1.js let (real_module_name, real_filename) = deno_dir.resolve_module(&redirect_to, ".")?; let mut module_initial_source_name = module_initial_source_name; // If this is the first redirect attempt, // then module_initial_source_name should be None. // In that case, use current module name as module_initial_source_name. if module_initial_source_name.is_none() { module_initial_source_name = Some(module_name.to_owned()); } // Recurse. return fetch_local_source( deno_dir, &real_module_name, &real_filename, module_initial_source_name, ); } // No redirect needed or end of redirects. // We can try read the file let source_code = match fs::read(p) { Err(e) => { if e.kind() == std::io::ErrorKind::NotFound { return Ok(None); } else { return Err(e.into()); } } Ok(c) => c, }; Ok(Some(ModuleMetaData { module_name: module_name.to_string(), module_redirect_source_name: module_initial_source_name, filename: filename.to_string(), media_type: map_content_type( &p, source_code_headers.mime_type.as_ref().map(String::as_str), ), source_code, maybe_output_code_filename: None, maybe_output_code: None, maybe_source_map_filename: None, maybe_source_map: None, })) } #[derive(Debug)] /// Header metadata associated with a particular "symbolic" source code file. /// (the associated source code file might not be cached, while remaining /// a user accessible entity through imports (due to redirects)). pub struct SourceCodeHeaders { /// MIME type of the source code. pub mime_type: Option, /// Where should we actually look for source code. /// This should be an absolute path! pub redirect_to: Option, } static MIME_TYPE: &'static str = "mime_type"; static REDIRECT_TO: &'static str = "redirect_to"; fn source_code_headers_filename(filename: &str) -> String { [&filename, ".headers.json"].concat() } /// Get header metadata associated with a single source code file. /// NOTICE: chances are that the source code itself is not downloaded due to redirects. /// In this case, the headers file provides info about where we should go and get /// the source code that redirect eventually points to (which should be cached). fn get_source_code_headers(filename: &str) -> SourceCodeHeaders { let headers_filename = source_code_headers_filename(filename); let hd = Path::new(&headers_filename); // .headers.json file might not exists. // This is okay for local source. let maybe_headers_string = fs::read_to_string(&hd).ok(); if let Some(headers_string) = maybe_headers_string { // TODO(kevinkassimo): consider introduce serde::Deserialize to make things simpler. let maybe_headers: serde_json::Result = serde_json::from_str(&headers_string); if let Ok(headers) = maybe_headers { return SourceCodeHeaders { mime_type: headers[MIME_TYPE].as_str().map(String::from), redirect_to: headers[REDIRECT_TO].as_str().map(String::from), }; } } SourceCodeHeaders { mime_type: None, redirect_to: None, } } /// Save headers related to source filename to {filename}.headers.json file, /// only when there is actually something necessary to save. /// For example, if the extension ".js" already mean JS file and we have /// content type of "text/javascript", then we would not save the mime type. /// If nothing needs to be saved, the headers file is not created. fn save_source_code_headers( filename: &str, mime_type: Option, redirect_to: Option, ) { let headers_filename = source_code_headers_filename(filename); // Remove possibly existing stale .headers.json file. // May not exist. DON'T unwrap. let _ = std::fs::remove_file(&headers_filename); let p = PathBuf::from(filename); // TODO(kevinkassimo): consider introduce serde::Deserialize to make things simpler. // This is super ugly at this moment... // Had trouble to make serde_derive work: I'm unable to build proc-macro2. let mut value_map = serde_json::map::Map::new(); if mime_type.is_some() { let mime_type_string = mime_type.clone().unwrap(); let resolved_mime_type = { map_content_type(Path::new(""), Some(mime_type_string.as_str())) }; let ext_based_mime_type = map_file_extension(&p); // Add mime to headers only when content type is different from extension. if ext_based_mime_type == msg::MediaType::Unknown || resolved_mime_type != ext_based_mime_type { value_map.insert(MIME_TYPE.to_string(), json!(mime_type_string)); } } if redirect_to.is_some() { value_map.insert(REDIRECT_TO.to_string(), json!(redirect_to.unwrap())); } // Only save to file when there is actually data. if !value_map.is_empty() { let _ = serde_json::to_string(&value_map).map(|s| { // It is possible that we need to create file // with parent folders not yet created. // (Due to .headers.json feature for redirection) let hd = PathBuf::from(&headers_filename); let _ = match hd.parent() { Some(ref parent) => fs::create_dir_all(parent), None => Ok(()), }; let _ = deno_fs::write_file(&(hd.as_path()), s, 0o666); }); } } pub fn resolve_file_url( specifier: String, mut referrer: String, ) -> Result { if referrer.starts_with('.') { let cwd = std::env::current_dir().unwrap(); let referrer_path = cwd.join(referrer); referrer = referrer_path.to_str().unwrap().to_string() + "/"; } let j = if is_remote(&specifier) || (Path::new(&specifier).is_absolute() && !is_remote(&referrer)) { parse_local_or_remote(&specifier)? } else if referrer.ends_with('/') { let r = Url::from_directory_path(&referrer); // TODO(ry) Properly handle error. if r.is_err() { error!("Url::from_directory_path error {}", referrer); } let base = r.unwrap(); base.join(specifier.as_ref())? } else { let base = parse_local_or_remote(&referrer)?; base.join(specifier.as_ref())? }; Ok(j) } pub fn resolve_path(path: &str) -> Result<(PathBuf, String), DenoError> { let url = resolve_file_url(path.to_string(), ".".to_string()) .map_err(DenoError::from)?; let path = url.to_file_path().unwrap(); let path_string = path.to_str().unwrap().to_string(); Ok((path, path_string)) } #[cfg(test)] mod tests { use super::*; use tempfile::TempDir; fn test_setup() -> (TempDir, DenoDir) { let temp_dir = TempDir::new().expect("tempdir fail"); let config = Some(b"{}".to_vec()); let deno_dir = DenoDir::new( Some(temp_dir.path().to_path_buf()), &config, Progress::new(), ).expect("setup fail"); (temp_dir, deno_dir) } // The `add_root` macro prepends "C:" to a string if on windows; on posix // systems it returns the input string untouched. This is necessary because // `Url::from_file_path()` fails if the input path isn't an absolute path. macro_rules! add_root { ($path:expr) => { if cfg!(target_os = "windows") { concat!("C:", $path) } else { $path } }; } macro_rules! file_url { ($path:expr) => { if cfg!(target_os = "windows") { concat!("file:///C:", $path) } else { concat!("file://", $path) } }; } #[test] fn test_get_cache_filename() { let url = Url::parse("http://example.com:1234/path/to/file.ts").unwrap(); let basedir = Path::new("/cache/dir/"); let cache_file = get_cache_filename(&basedir, &url); assert_eq!( cache_file, Path::new("/cache/dir/example.com_PORT1234/path/to/file.ts") ); } #[test] fn test_cache_path() { let (temp_dir, deno_dir) = test_setup(); let filename = "hello.js"; let source_code = b"1+2"; let config = b"{}"; let hash = source_code_hash(filename, source_code, version::DENO, config); assert_eq!( ( temp_dir.path().join(format!("gen/{}.js", hash)), temp_dir.path().join(format!("gen/{}.js.map", hash)) ), deno_dir.cache_path(filename, source_code) ); } #[test] fn test_cache_path_config() { // We are changing the compiler config from the "mock" and so we expect the // resolved files coming back to not match the calculated hash. let (temp_dir, deno_dir) = test_setup(); let filename = "hello.js"; let source_code = b"1+2"; let config = b"{\"compilerOptions\":{}}"; let hash = source_code_hash(filename, source_code, version::DENO, config); assert_ne!( ( temp_dir.path().join(format!("gen/{}.js", hash)), temp_dir.path().join(format!("gen/{}.js.map", hash)) ), deno_dir.cache_path(filename, source_code) ); } #[test] fn test_code_cache() { let (_temp_dir, deno_dir) = test_setup(); let filename = "hello.js"; let source_code = b"1+2"; let output_code = b"1+2 // output code"; let source_map = b"{}"; let config = b"{}"; let hash = source_code_hash(filename, source_code, version::DENO, config); let (cache_path, source_map_path) = deno_dir.cache_path(filename, source_code); assert!(cache_path.ends_with(format!("gen/{}.js", hash))); assert!(source_map_path.ends_with(format!("gen/{}.js.map", hash))); let out = ModuleMetaData { filename: filename.to_owned(), source_code: source_code[..].to_owned(), module_name: "hello.js".to_owned(), module_redirect_source_name: None, media_type: msg::MediaType::TypeScript, maybe_output_code: Some(output_code[..].to_owned()), maybe_output_code_filename: None, maybe_source_map: Some(source_map[..].to_owned()), maybe_source_map_filename: None, }; let r = deno_dir.code_cache(&out); r.expect("code_cache error"); assert!(cache_path.exists()); assert_eq!(output_code[..].to_owned(), fs::read(&cache_path).unwrap()); } #[test] fn test_source_code_hash() { assert_eq!( "830c8b63ba3194cf2108a3054c176b2bf53aee45", source_code_hash("hello.ts", b"1+2", "0.2.11", b"{}") ); // Different source_code should result in different hash. assert_eq!( "fb06127e9b2e169bea9c697fa73386ae7c901e8b", source_code_hash("hello.ts", b"1", "0.2.11", b"{}") ); // Different filename should result in different hash. assert_eq!( "3a17b6a493ff744b6a455071935f4bdcd2b72ec7", source_code_hash("hi.ts", b"1+2", "0.2.11", b"{}") ); // Different version should result in different hash. assert_eq!( "d6b2cfdc39dae9bd3ad5b493ee1544eb22e7475f", source_code_hash("hi.ts", b"1+2", "0.2.0", b"{}") ); } #[test] fn test_source_code_headers_get_and_save() { let (temp_dir, _deno_dir) = test_setup(); let filename = deno_fs::normalize_path(temp_dir.into_path().join("f.js").as_ref()); let headers_file_name = source_code_headers_filename(&filename); assert_eq!(headers_file_name, [&filename, ".headers.json"].concat()); let _ = deno_fs::write_file(&PathBuf::from(&headers_file_name), "{\"mime_type\":\"text/javascript\",\"redirect_to\":\"http://example.com/a.js\"}", 0o666); let headers = get_source_code_headers(&filename); assert_eq!(headers.mime_type.clone().unwrap(), "text/javascript"); assert_eq!( headers.redirect_to.clone().unwrap(), "http://example.com/a.js" ); save_source_code_headers( &filename, Some("text/typescript".to_owned()), Some("http://deno.land/a.js".to_owned()), ); let headers2 = get_source_code_headers(&filename); assert_eq!(headers2.mime_type.clone().unwrap(), "text/typescript"); assert_eq!( headers2.redirect_to.clone().unwrap(), "http://deno.land/a.js" ); } #[test] fn test_get_source_code_1() { let (_temp_dir, deno_dir) = test_setup(); // http_util::fetch_sync_string requires tokio tokio_util::init(|| { let module_name = "http://localhost:4545/tests/subdir/mod2.ts"; let filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/subdir/mod2.ts") .as_ref(), ); let headers_file_name = source_code_headers_filename(&filename); let result = get_source_code(&deno_dir, module_name, &filename, true, false); assert!(result.is_ok()); let r = result.unwrap(); assert_eq!( r.source_code, "export { printHello } from \"./print_hello.ts\";\n".as_bytes() ); assert_eq!(&(r.media_type), &msg::MediaType::TypeScript); // Should not create .headers.json file due to matching ext assert!(fs::read_to_string(&headers_file_name).is_err()); // Modify .headers.json, write using fs write and read using save_source_code_headers let _ = fs::write(&headers_file_name, "{ \"mime_type\": \"text/javascript\" }"); let result2 = get_source_code(&deno_dir, module_name, &filename, true, false); assert!(result2.is_ok()); let r2 = result2.unwrap(); assert_eq!( r2.source_code, "export { printHello } from \"./print_hello.ts\";\n".as_bytes() ); // If get_source_code does not call remote, this should be JavaScript // as we modified before! (we do not overwrite .headers.json due to no http fetch) assert_eq!(&(r2.media_type), &msg::MediaType::JavaScript); assert_eq!( get_source_code_headers(&filename).mime_type.unwrap(), "text/javascript" ); // Modify .headers.json again, but the other way around save_source_code_headers( &filename, Some("application/json".to_owned()), None, ); let result3 = get_source_code(&deno_dir, module_name, &filename, true, false); assert!(result3.is_ok()); let r3 = result3.unwrap(); assert_eq!( r3.source_code, "export { printHello } from \"./print_hello.ts\";\n".as_bytes() ); // If get_source_code does not call remote, this should be JavaScript // as we modified before! (we do not overwrite .headers.json due to no http fetch) assert_eq!(&(r3.media_type), &msg::MediaType::Json); assert!( fs::read_to_string(&headers_file_name) .unwrap() .contains("application/json") ); // Don't use_cache let result4 = get_source_code(&deno_dir, module_name, &filename, false, false); assert!(result4.is_ok()); let r4 = result4.unwrap(); let expected4 = "export { printHello } from \"./print_hello.ts\";\n".as_bytes(); assert_eq!(r4.source_code, expected4); // Now the old .headers.json file should have gone! Resolved back to TypeScript assert_eq!(&(r4.media_type), &msg::MediaType::TypeScript); assert!(fs::read_to_string(&headers_file_name).is_err()); }); } #[test] fn test_get_source_code_2() { let (_temp_dir, deno_dir) = test_setup(); // http_util::fetch_sync_string requires tokio tokio_util::init(|| { let module_name = "http://localhost:4545/tests/subdir/mismatch_ext.ts"; let filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/subdir/mismatch_ext.ts") .as_ref(), ); let headers_file_name = source_code_headers_filename(&filename); let result = get_source_code(&deno_dir, module_name, &filename, true, false); assert!(result.is_ok()); let r = result.unwrap(); let expected = "export const loaded = true;\n".as_bytes(); assert_eq!(r.source_code, expected); // Mismatch ext with content type, create .headers.json assert_eq!(&(r.media_type), &msg::MediaType::JavaScript); assert_eq!( get_source_code_headers(&filename).mime_type.unwrap(), "text/javascript" ); // Modify .headers.json save_source_code_headers( &filename, Some("text/typescript".to_owned()), None, ); let result2 = get_source_code(&deno_dir, module_name, &filename, true, false); assert!(result2.is_ok()); let r2 = result2.unwrap(); let expected2 = "export const loaded = true;\n".as_bytes(); assert_eq!(r2.source_code, expected2); // If get_source_code does not call remote, this should be TypeScript // as we modified before! (we do not overwrite .headers.json due to no http fetch) assert_eq!(&(r2.media_type), &msg::MediaType::TypeScript); assert!(fs::read_to_string(&headers_file_name).is_err()); // Don't use_cache let result3 = get_source_code(&deno_dir, module_name, &filename, false, false); assert!(result3.is_ok()); let r3 = result3.unwrap(); let expected3 = "export const loaded = true;\n".as_bytes(); assert_eq!(r3.source_code, expected3); // Now the old .headers.json file should be overwritten back to JavaScript! // (due to http fetch) assert_eq!(&(r3.media_type), &msg::MediaType::JavaScript); assert_eq!( get_source_code_headers(&filename).mime_type.unwrap(), "text/javascript" ); }); } #[test] fn test_get_source_code_3() { let (_temp_dir, deno_dir) = test_setup(); // Test basic follow and headers recording tokio_util::init(|| { let redirect_module_name = "http://localhost:4546/tests/subdir/redirects/redirect1.js"; let redirect_source_filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4546/tests/subdir/redirects/redirect1.js") .as_ref(), ); let target_module_name = "http://localhost:4545/tests/subdir/redirects/redirect1.js"; let redirect_target_filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/subdir/redirects/redirect1.js") .as_ref(), ); let mod_meta = get_source_code( &deno_dir, redirect_module_name, &redirect_source_filename, true, false, ).unwrap(); // File that requires redirection is not downloaded. assert!(fs::read_to_string(&redirect_source_filename).is_err()); // ... but its .headers.json is created. let redirect_source_headers = get_source_code_headers(&redirect_source_filename); assert_eq!( redirect_source_headers.redirect_to.unwrap(), "http://localhost:4545/tests/subdir/redirects/redirect1.js" ); // The target of redirection is downloaded instead. assert_eq!( fs::read_to_string(&redirect_target_filename).unwrap(), "export const redirect = 1;\n" ); let redirect_target_headers = get_source_code_headers(&redirect_target_filename); assert!(redirect_target_headers.redirect_to.is_none()); // Examine the meta result. assert_eq!(&mod_meta.module_name, target_module_name); assert_eq!( &mod_meta.module_redirect_source_name.clone().unwrap(), redirect_module_name ); }); } #[test] fn test_get_source_code_4() { let (_temp_dir, deno_dir) = test_setup(); // Test double redirects and headers recording tokio_util::init(|| { let redirect_module_name = "http://localhost:4548/tests/subdir/redirects/redirect1.js"; let redirect_source_filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4548/tests/subdir/redirects/redirect1.js") .as_ref(), ); let redirect_source_filename_intermediate = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4546/tests/subdir/redirects/redirect1.js") .as_ref(), ); let target_module_name = "http://localhost:4545/tests/subdir/redirects/redirect1.js"; let redirect_target_filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/subdir/redirects/redirect1.js") .as_ref(), ); let mod_meta = get_source_code( &deno_dir, redirect_module_name, &redirect_source_filename, true, false, ).unwrap(); // File that requires redirection is not downloaded. assert!(fs::read_to_string(&redirect_source_filename).is_err()); // ... but its .headers.json is created. let redirect_source_headers = get_source_code_headers(&redirect_source_filename); assert_eq!( redirect_source_headers.redirect_to.unwrap(), target_module_name ); // In the intermediate redirection step, file is also not downloaded. assert!( fs::read_to_string(&redirect_source_filename_intermediate).is_err() ); // The target of redirection is downloaded instead. assert_eq!( fs::read_to_string(&redirect_target_filename).unwrap(), "export const redirect = 1;\n" ); let redirect_target_headers = get_source_code_headers(&redirect_target_filename); assert!(redirect_target_headers.redirect_to.is_none()); // Examine the meta result. assert_eq!(&mod_meta.module_name, target_module_name); assert_eq!( &mod_meta.module_redirect_source_name.clone().unwrap(), redirect_module_name ); }); } #[test] fn test_get_source_code_no_fetch() { let (_temp_dir, deno_dir) = test_setup(); tokio_util::init(|| { let module_name = "http://localhost:4545/tests/002_hello.ts"; let filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/002_hello.ts") .as_ref(), ); // file hasn't been cached before and remote downloads are not allowed let result = get_source_code(&deno_dir, module_name, &filename, true, true); assert!(result.is_err()); let err = result.err().unwrap(); assert_eq!(err.kind(), ErrorKind::NotFound); // download and cache file let result = get_source_code(&deno_dir, module_name, &filename, true, false); assert!(result.is_ok()); // module is already cached, should be ok even with `no_fetch` let result = get_source_code(&deno_dir, module_name, &filename, true, true); assert!(result.is_ok()); }); } #[test] fn test_fetch_source_async_1() { use crate::tokio_util; // http_util::fetch_sync_string requires tokio tokio_util::init(|| { let (_temp_dir, deno_dir) = test_setup(); let module_name = "http://127.0.0.1:4545/tests/subdir/mt_video_mp2t.t3.ts".to_string(); let filename = deno_fs::normalize_path( deno_dir .deps_http .join("127.0.0.1_PORT4545/tests/subdir/mt_video_mp2t.t3.ts") .as_ref(), ); let headers_file_name = source_code_headers_filename(&filename); let result = tokio_util::block_on(fetch_remote_source_async( &deno_dir, &module_name, &filename, )); assert!(result.is_ok()); let r = result.unwrap().unwrap(); assert_eq!(r.source_code, b"export const loaded = true;\n"); assert_eq!(&(r.media_type), &msg::MediaType::TypeScript); // matching ext, no .headers.json file created assert!(fs::read_to_string(&headers_file_name).is_err()); // Modify .headers.json, make sure read from local save_source_code_headers( &filename, Some("text/javascript".to_owned()), None, ); let result2 = fetch_local_source(&deno_dir, &module_name, &filename, None); assert!(result2.is_ok()); let r2 = result2.unwrap().unwrap(); assert_eq!(r2.source_code, b"export const loaded = true;\n"); // Not MediaType::TypeScript due to .headers.json modification assert_eq!(&(r2.media_type), &msg::MediaType::JavaScript); }); } #[test] fn test_fetch_source_1() { use crate::tokio_util; // http_util::fetch_sync_string requires tokio tokio_util::init(|| { let (_temp_dir, deno_dir) = test_setup(); let module_name = "http://localhost:4545/tests/subdir/mt_video_mp2t.t3.ts"; let filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/subdir/mt_video_mp2t.t3.ts") .as_ref(), ); let headers_file_name = source_code_headers_filename(&filename); let result = fetch_remote_source(&deno_dir, module_name, &filename); assert!(result.is_ok()); let r = result.unwrap().unwrap(); assert_eq!(r.source_code, "export const loaded = true;\n".as_bytes()); assert_eq!(&(r.media_type), &msg::MediaType::TypeScript); // matching ext, no .headers.json file created assert!(fs::read_to_string(&headers_file_name).is_err()); // Modify .headers.json, make sure read from local save_source_code_headers( &filename, Some("text/javascript".to_owned()), None, ); let result2 = fetch_local_source(&deno_dir, module_name, &filename, None); assert!(result2.is_ok()); let r2 = result2.unwrap().unwrap(); assert_eq!(r2.source_code, "export const loaded = true;\n".as_bytes()); // Not MediaType::TypeScript due to .headers.json modification assert_eq!(&(r2.media_type), &msg::MediaType::JavaScript); }); } #[test] fn test_fetch_source_2() { use crate::tokio_util; // http_util::fetch_sync_string requires tokio tokio_util::init(|| { let (_temp_dir, deno_dir) = test_setup(); let module_name = "http://localhost:4545/tests/subdir/no_ext"; let filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/subdir/no_ext") .as_ref(), ); let result = fetch_remote_source(&deno_dir, module_name, &filename); assert!(result.is_ok()); let r = result.unwrap().unwrap(); assert_eq!(r.source_code, "export const loaded = true;\n".as_bytes()); assert_eq!(&(r.media_type), &msg::MediaType::TypeScript); // no ext, should create .headers.json file assert_eq!( get_source_code_headers(&filename).mime_type.unwrap(), "text/typescript" ); let module_name_2 = "http://localhost:4545/tests/subdir/mismatch_ext.ts"; let filename_2 = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/subdir/mismatch_ext.ts") .as_ref(), ); let result_2 = fetch_remote_source(&deno_dir, module_name_2, &filename_2); assert!(result_2.is_ok()); let r2 = result_2.unwrap().unwrap(); assert_eq!(r2.source_code, "export const loaded = true;\n".as_bytes()); assert_eq!(&(r2.media_type), &msg::MediaType::JavaScript); // mismatch ext, should create .headers.json file assert_eq!( get_source_code_headers(&filename_2).mime_type.unwrap(), "text/javascript" ); // test unknown extension let module_name_3 = "http://localhost:4545/tests/subdir/unknown_ext.deno"; let filename_3 = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/subdir/unknown_ext.deno") .as_ref(), ); let result_3 = fetch_remote_source(&deno_dir, module_name_3, &filename_3); assert!(result_3.is_ok()); let r3 = result_3.unwrap().unwrap(); assert_eq!(r3.source_code, "export const loaded = true;\n".as_bytes()); assert_eq!(&(r3.media_type), &msg::MediaType::TypeScript); // unknown ext, should create .headers.json file assert_eq!( get_source_code_headers(&filename_3).mime_type.unwrap(), "text/typescript" ); }); } #[test] fn test_fetch_source_3() { // only local, no http_util::fetch_sync_string called let (_temp_dir, deno_dir) = test_setup(); let cwd = std::env::current_dir().unwrap(); let cwd_string = cwd.to_str().unwrap(); let module_name = "http://example.com/mt_text_typescript.t1.ts"; // not used let filename = format!("{}/tests/subdir/mt_text_typescript.t1.ts", &cwd_string); let result = fetch_local_source(&deno_dir, module_name, &filename, None); assert!(result.is_ok()); let r = result.unwrap().unwrap(); assert_eq!(r.source_code, "export const loaded = true;\n".as_bytes()); assert_eq!(&(r.media_type), &msg::MediaType::TypeScript); } #[test] fn test_fetch_module_meta_data() { let (_temp_dir, deno_dir) = test_setup(); let cwd = std::env::current_dir().unwrap(); let cwd_string = String::from(cwd.to_str().unwrap()) + "/"; tokio_util::init(|| { // Test failure case. let specifier = "hello.ts"; let referrer = add_root!("/baddir/badfile.ts"); let r = deno_dir.fetch_module_meta_data(specifier, referrer, true, false); assert!(r.is_err()); // Assuming cwd is the deno repo root. let specifier = "./js/main.ts"; let referrer = cwd_string.as_str(); let r = deno_dir.fetch_module_meta_data(specifier, referrer, true, false); assert!(r.is_ok()); }) } #[test] fn test_fetch_module_meta_data_1() { /*recompile ts file*/ let (_temp_dir, deno_dir) = test_setup(); let cwd = std::env::current_dir().unwrap(); let cwd_string = String::from(cwd.to_str().unwrap()) + "/"; tokio_util::init(|| { // Test failure case. let specifier = "hello.ts"; let referrer = add_root!("/baddir/badfile.ts"); let r = deno_dir.fetch_module_meta_data(specifier, referrer, false, false); assert!(r.is_err()); // Assuming cwd is the deno repo root. let specifier = "./js/main.ts"; let referrer = cwd_string.as_str(); let r = deno_dir.fetch_module_meta_data(specifier, referrer, false, false); assert!(r.is_ok()); }) } #[test] fn test_src_file_to_url_1() { let (_temp_dir, deno_dir) = test_setup(); assert_eq!("hello", deno_dir.src_file_to_url("hello")); assert_eq!("/hello", deno_dir.src_file_to_url("/hello")); let x = deno_dir.deps_http.join("hello/world.txt"); assert_eq!( "http://hello/world.txt", deno_dir.src_file_to_url(x.to_str().unwrap()) ); } #[test] fn test_src_file_to_url_2() { let (_temp_dir, deno_dir) = test_setup(); assert_eq!("hello", deno_dir.src_file_to_url("hello")); assert_eq!("/hello", deno_dir.src_file_to_url("/hello")); let x = deno_dir.deps_https.join("hello/world.txt"); assert_eq!( "https://hello/world.txt", deno_dir.src_file_to_url(x.to_str().unwrap()) ); } #[test] fn test_src_file_to_url_3() { let (_temp_dir, deno_dir) = test_setup(); let x = deno_dir.deps_http.join("localhost_PORT4545/world.txt"); assert_eq!( "http://localhost:4545/world.txt", deno_dir.src_file_to_url(x.to_str().unwrap()) ); } #[test] fn test_src_file_to_url_4() { let (_temp_dir, deno_dir) = test_setup(); let x = deno_dir.deps_https.join("localhost_PORT4545/world.txt"); assert_eq!( "https://localhost:4545/world.txt", deno_dir.src_file_to_url(x.to_str().unwrap()) ); } // https://github.com/denoland/deno/blob/golang/os_test.go#L16-L87 #[test] fn test_resolve_module_1() { let (_temp_dir, deno_dir) = test_setup(); let test_cases = [ ( "./subdir/print_hello.ts", add_root!("/Users/rld/go/src/github.com/denoland/deno/testdata/006_url_imports.ts"), file_url!("/Users/rld/go/src/github.com/denoland/deno/testdata/subdir/print_hello.ts"), add_root!("/Users/rld/go/src/github.com/denoland/deno/testdata/subdir/print_hello.ts"), ), ( "testdata/001_hello.js", add_root!("/Users/rld/go/src/github.com/denoland/deno/"), file_url!("/Users/rld/go/src/github.com/denoland/deno/testdata/001_hello.js"), add_root!("/Users/rld/go/src/github.com/denoland/deno/testdata/001_hello.js"), ), ( add_root!("/Users/rld/src/deno/hello.js"), ".", file_url!("/Users/rld/src/deno/hello.js"), add_root!("/Users/rld/src/deno/hello.js"), ), ( add_root!("/this/module/got/imported.js"), add_root!("/that/module/did/it.js"), file_url!("/this/module/got/imported.js"), add_root!("/this/module/got/imported.js"), ), ]; for &test in test_cases.iter() { let specifier = String::from(test.0); let referrer = String::from(test.1); let (module_name, filename) = deno_dir.resolve_module(&specifier, &referrer).unwrap(); assert_eq!(module_name, test.2); assert_eq!(filename, test.3); } } #[test] fn test_resolve_module_2() { let (_temp_dir, deno_dir) = test_setup(); let specifier = "http://localhost:4545/testdata/subdir/print_hello.ts"; let referrer = add_root!("/deno/testdata/006_url_imports.ts"); let expected_module_name = "http://localhost:4545/testdata/subdir/print_hello.ts"; let expected_filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/testdata/subdir/print_hello.ts") .as_ref(), ); let (module_name, filename) = deno_dir.resolve_module(specifier, referrer).unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); } #[test] fn test_resolve_module_3() { let (_temp_dir, deno_dir) = test_setup(); let specifier_ = deno_dir.deps_http.join("unpkg.com/liltest@0.0.5/index.ts"); let specifier = specifier_.to_str().unwrap(); let referrer = "."; let expected_module_name = "http://unpkg.com/liltest@0.0.5/index.ts"; let expected_filename = deno_fs::normalize_path( deno_dir .deps_http .join("unpkg.com/liltest@0.0.5/index.ts") .as_ref(), ); let (module_name, filename) = deno_dir.resolve_module(specifier, referrer).unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); } #[test] fn test_resolve_module_4() { let (_temp_dir, deno_dir) = test_setup(); let specifier = "./util"; let referrer_ = deno_dir.deps_http.join("unpkg.com/liltest@0.0.5/index.ts"); let referrer = referrer_.to_str().unwrap(); // http containing files -> load relative import with http let expected_module_name = "http://unpkg.com/liltest@0.0.5/util"; let expected_filename = deno_fs::normalize_path( deno_dir .deps_http .join("unpkg.com/liltest@0.0.5/util") .as_ref(), ); let (module_name, filename) = deno_dir.resolve_module(specifier, referrer).unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); } #[test] fn test_resolve_module_5() { let (_temp_dir, deno_dir) = test_setup(); let specifier = "./util"; let referrer_ = deno_dir.deps_https.join("unpkg.com/liltest@0.0.5/index.ts"); let referrer = referrer_.to_str().unwrap(); // https containing files -> load relative import with https let expected_module_name = "https://unpkg.com/liltest@0.0.5/util"; let expected_filename = deno_fs::normalize_path( deno_dir .deps_https .join("unpkg.com/liltest@0.0.5/util") .as_ref(), ); let (module_name, filename) = deno_dir.resolve_module(specifier, referrer).unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); } #[test] fn test_resolve_module_6() { let (_temp_dir, deno_dir) = test_setup(); let specifier = "http://localhost:4545/tests/subdir/mod2.ts"; let referrer = add_root!("/deno/tests/006_url_imports.ts"); let expected_module_name = "http://localhost:4545/tests/subdir/mod2.ts"; let expected_filename = deno_fs::normalize_path( deno_dir .deps_http .join("localhost_PORT4545/tests/subdir/mod2.ts") .as_ref(), ); let (module_name, filename) = deno_dir.resolve_module(specifier, referrer).unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); } #[test] fn test_resolve_module_7() { let (_temp_dir, deno_dir) = test_setup(); let specifier = "http_test.ts"; let referrer = add_root!("/Users/rld/src/deno_net/"); let expected_module_name = file_url!("/Users/rld/src/deno_net/http_test.ts"); let expected_filename = add_root!("/Users/rld/src/deno_net/http_test.ts"); let (module_name, filename) = deno_dir.resolve_module(specifier, referrer).unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); } #[test] fn test_resolve_module_8() { let (_temp_dir, deno_dir) = test_setup(); let specifier = "/util"; let referrer_ = deno_dir.deps_https.join("unpkg.com/liltest@0.0.5/index.ts"); let referrer = referrer_.to_str().unwrap(); let expected_module_name = "https://unpkg.com/util"; let expected_filename = deno_fs::normalize_path( deno_dir.deps_https.join("unpkg.com/util").as_ref(), ); let (module_name, filename) = deno_dir.resolve_module(specifier, referrer).unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); } #[test] fn test_resolve_module_referrer_dot() { let (_temp_dir, deno_dir) = test_setup(); let specifier = "tests/001_hello.js"; let cwd = std::env::current_dir().unwrap(); let expected_path = cwd.join(specifier); let expected_module_name = Url::from_file_path(&expected_path).unwrap().to_string(); let expected_filename = deno_fs::normalize_path(&expected_path); let (module_name, filename) = deno_dir.resolve_module(specifier, ".").unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); let (module_name, filename) = deno_dir.resolve_module(specifier, "./").unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); } #[test] fn test_resolve_module_referrer_dotdot() { let (_temp_dir, deno_dir) = test_setup(); let specifier = "tests/001_hello.js"; let cwd = std::env::current_dir().unwrap(); let expected_path = cwd.join("..").join(specifier); let expected_module_name = Url::from_file_path(&expected_path).unwrap().to_string(); let expected_filename = deno_fs::normalize_path(&expected_path); let (module_name, filename) = deno_dir.resolve_module(specifier, "..").unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); let (module_name, filename) = deno_dir.resolve_module(specifier, "../").unwrap(); assert_eq!(module_name, expected_module_name); assert_eq!(filename, expected_filename); } #[test] fn test_map_file_extension() { assert_eq!( map_file_extension(Path::new("foo/bar.ts")), msg::MediaType::TypeScript ); assert_eq!( map_file_extension(Path::new("foo/bar.d.ts")), msg::MediaType::TypeScript ); assert_eq!( map_file_extension(Path::new("foo/bar.js")), msg::MediaType::JavaScript ); assert_eq!( map_file_extension(Path::new("foo/bar.json")), msg::MediaType::Json ); assert_eq!( map_file_extension(Path::new("foo/bar.txt")), msg::MediaType::Unknown ); assert_eq!( map_file_extension(Path::new("foo/bar")), msg::MediaType::Unknown ); } #[test] fn test_map_content_type() { // Extension only assert_eq!( map_content_type(Path::new("foo/bar.ts"), None), msg::MediaType::TypeScript ); assert_eq!( map_content_type(Path::new("foo/bar.d.ts"), None), msg::MediaType::TypeScript ); assert_eq!( map_content_type(Path::new("foo/bar.js"), None), msg::MediaType::JavaScript ); assert_eq!( map_content_type(Path::new("foo/bar.json"), None), msg::MediaType::Json ); assert_eq!( map_content_type(Path::new("foo/bar.txt"), None), msg::MediaType::Unknown ); assert_eq!( map_content_type(Path::new("foo/bar"), None), msg::MediaType::Unknown ); // Media Type assert_eq!( map_content_type(Path::new("foo/bar"), Some("application/typescript")), msg::MediaType::TypeScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("text/typescript")), msg::MediaType::TypeScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("video/vnd.dlna.mpeg-tts")), msg::MediaType::TypeScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("video/mp2t")), msg::MediaType::TypeScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("application/x-typescript")), msg::MediaType::TypeScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("application/javascript")), msg::MediaType::JavaScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("text/javascript")), msg::MediaType::JavaScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("application/ecmascript")), msg::MediaType::JavaScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("text/ecmascript")), msg::MediaType::JavaScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("application/x-javascript")), msg::MediaType::JavaScript ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("application/json")), msg::MediaType::Json ); assert_eq!( map_content_type(Path::new("foo/bar"), Some("text/json")), msg::MediaType::Json ); assert_eq!( map_content_type(Path::new("foo/bar.ts"), Some("text/plain")), msg::MediaType::TypeScript ); assert_eq!( map_content_type(Path::new("foo/bar.ts"), Some("foo/bar")), msg::MediaType::Unknown ); } #[test] fn test_filter_shebang() { assert_eq!(filter_shebang(b"#!"[..].to_owned()), b""); assert_eq!( filter_shebang("#!\n\n".as_bytes().to_owned()), "\n\n".as_bytes() ); let code = "#!/usr/bin/env deno\nconsole.log('hello');\n" .as_bytes() .to_owned(); assert_eq!(filter_shebang(code), "\nconsole.log('hello');\n".as_bytes()); } }