// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. use test_util as util; use util::assert_contains; use util::assert_not_contains; use util::testdata_path; use util::TestContext; use util::TestContextBuilder; #[test] fn compile_basic() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("welcome.exe") } else { dir.path().join("welcome") }; // try this twice to ensure it works with the cache for _ in 0..2 { let output = context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "../../tests/testdata/welcome.ts", ]) .run(); output.assert_exit_code(0); output.skip_output_check(); let output = context.new_command().name(&exe).run(); output.assert_matches_text("Welcome to Deno!\n"); } // now ensure this works when the deno_dir is readonly let readonly_dir = dir.path().join("readonly"); readonly_dir.make_dir_readonly(); let readonly_sub_dir = readonly_dir.join("sub"); let output = context .new_command() // it should fail creating this, but still work .env("DENO_DIR", readonly_sub_dir) .name(exe) .run(); output.assert_matches_text("Welcome to Deno!\n"); } #[test] fn standalone_args() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("args.exe") } else { dir.path().join("args") }; context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/args.ts", "a", "b", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .name(&exe) .args("foo --bar --unstable") .run() .assert_matches_text("a\nb\nfoo\n--bar\n--unstable\n") .assert_exit_code(0); } #[test] fn standalone_error() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("error.exe") } else { dir.path().join("error") }; context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/standalone_error.ts", ]) .run() .skip_output_check() .assert_exit_code(0); let output = context.new_command().name(&exe).split_output().run(); output.assert_exit_code(1); output.assert_stdout_matches_text(""); let stderr = output.stderr(); // On Windows, we cannot assert the file path (because '\'). // Instead we just check for relevant output. assert_contains!(stderr, "error: Uncaught (in promise) Error: boom!"); assert_contains!(stderr, "throw new Error(\"boom!\");"); assert_contains!(stderr, "\n at boom (file://"); assert_contains!(stderr, "standalone_error.ts:2:9"); assert_contains!(stderr, "at foo (file://"); assert_contains!(stderr, "standalone_error.ts:5:3"); assert_contains!(stderr, "standalone_error.ts:7:1"); } #[test] fn standalone_error_module_with_imports() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("error.exe") } else { dir.path().join("error") }; context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/standalone_error_module_with_imports_1.ts", ]) .run() .skip_output_check() .assert_exit_code(0); let output = context .new_command() .name(&exe) .env("NO_COLOR", "1") .split_output() .run(); output.assert_stdout_matches_text("hello\n"); let stderr = output.stderr(); // On Windows, we cannot assert the file path (because '\'). // Instead we just check for relevant output. assert_contains!(stderr, "error: Uncaught (in promise) Error: boom!"); assert_contains!(stderr, "throw new Error(\"boom!\");"); assert_contains!(stderr, "\n at file://"); assert_contains!(stderr, "standalone_error_module_with_imports_2.ts:2:7"); output.assert_exit_code(1); } #[test] fn standalone_load_datauri() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("load_datauri.exe") } else { dir.path().join("load_datauri") }; context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/standalone_import_datauri.ts", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .name(&exe) .run() .assert_matches_text("Hello Deno!\n") .assert_exit_code(0); } // https://github.com/denoland/deno/issues/13704 #[test] fn standalone_follow_redirects() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("follow_redirects.exe") } else { dir.path().join("follow_redirects") }; context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/standalone_follow_redirects.ts", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .name(&exe) .run() .assert_matches_text("Hello\n") .assert_exit_code(0); } #[test] fn compile_with_file_exists_error() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let output_path = if cfg!(windows) { dir.path().join(r"args\") } else { dir.path().join("args/") }; let file_path = dir.path().join("args"); file_path.write(""); context .new_command() .args_vec([ "compile", "--output", &output_path.to_string_lossy(), "./compile/args.ts", ]) .run() .assert_matches_text(&format!( concat!( "[WILDCARD]error: Could not compile to file '{}' because its parent directory ", "is an existing file. You can use the `--output ` flag to ", "provide an alternative name.\n", ), file_path, )) .assert_exit_code(1); } #[test] fn compile_with_directory_exists_error() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("args.exe") } else { dir.path().join("args") }; std::fs::create_dir(&exe).unwrap(); context.new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/args.ts" ]).run() .assert_matches_text(&format!( concat!( "[WILDCARD]error: Could not compile to file '{}' because a directory exists with ", "the same name. You can use the `--output ` flag to ", "provide an alternative name.\n" ), exe )) .assert_exit_code(1); } #[test] fn compile_with_conflict_file_exists_error() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("args.exe") } else { dir.path().join("args") }; std::fs::write(&exe, b"SHOULD NOT BE OVERWRITTEN").unwrap(); context.new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/args.ts" ]).run() .assert_matches_text(&format!( concat!( "[WILDCARD]error: Could not compile to file '{}' because the file already exists ", "and cannot be overwritten. Please delete the existing file or ", "use the `--output ` flag to provide an alternative name.\n" ), exe )) .assert_exit_code(1); exe.assert_matches_text("SHOULD NOT BE OVERWRITTEN"); } #[test] fn compile_and_overwrite_file() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("args.exe") } else { dir.path().join("args") }; // do this twice for _ in 0..2 { context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/args.ts", ]) .run() .skip_output_check() .assert_exit_code(0); assert!(&exe.exists()); } } #[test] fn standalone_runtime_flags() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("flags.exe") } else { dir.path().join("flags") }; context .new_command() .args_vec([ "compile", "--allow-read", "--seed", "1", "--output", &exe.to_string_lossy(), "./compile/standalone_runtime_flags.ts", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .env("NO_COLOR", "1") .name(&exe) .split_output() .run() .assert_stdout_matches_text("0.147205063401058\n") .assert_stderr_matches_text( "[WILDCARD]PermissionDenied: Requires write access to[WILDCARD]", ) .assert_exit_code(1); } #[test] fn standalone_ext_flag_ts() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("ext_flag_ts.exe") } else { dir.path().join("ext_flag_ts") }; context .new_command() .args_vec([ "compile", "--ext", "ts", "--output", &exe.to_string_lossy(), "./file_extensions/ts_without_extension", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .env("NO_COLOR", "1") .name(&exe) .run() .assert_matches_text("executing typescript with no extension\n") .assert_exit_code(0); } #[test] fn standalone_ext_flag_js() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("ext_flag_js.exe") } else { dir.path().join("ext_flag_js") }; context .new_command() .args_vec([ "compile", "--ext", "js", "--output", &exe.to_string_lossy(), "./file_extensions/js_without_extension", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .env("NO_COLOR", "1") .name(&exe) .run() .assert_matches_text("executing javascript with no extension\n"); } #[test] fn standalone_import_map() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("import_map.exe") } else { dir.path().join("import_map") }; context .new_command() .args_vec([ "compile", "--allow-read", "--import-map", "compile/standalone_import_map.json", "--output", &exe.to_string_lossy(), "./compile/standalone_import_map.ts", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .name(&exe) .run() .skip_output_check() .assert_exit_code(0); } #[test] fn standalone_import_map_config_file() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("import_map.exe") } else { dir.path().join("import_map") }; context .new_command() .args_vec([ "compile", "--allow-read", "--config", "compile/standalone_import_map_config.json", "--output", &exe.to_string_lossy(), "./compile/standalone_import_map.ts", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .name(&exe) .run() .skip_output_check() .assert_exit_code(0); } #[test] // https://github.com/denoland/deno/issues/12670 fn skip_rebundle() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("hello_world.exe") } else { dir.path().join("hello_world") }; let output = context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./run/001_hello.js", ]) .run(); //no "Bundle testdata_path/run/001_hello.js" in output assert_not_contains!(output.combined_output(), "Bundle"); context .new_command() .name(&exe) .run() .assert_matches_text("Hello World\n") .assert_exit_code(0); } #[test] fn check_local_by_default() { let context = TestContext::with_http_server(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("welcome.exe") } else { dir.path().join("welcome") }; context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/check_local_by_default.ts", ]) .run() .skip_output_check() .assert_exit_code(0); } #[test] fn check_local_by_default2() { let context = TestContext::with_http_server(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("welcome.exe") } else { dir.path().join("welcome") }; context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/check_local_by_default2.ts" ]) .run() .assert_matches_text( r#"[WILDCARD]error: TS2322 [ERROR]: Type '12' is not assignable to type '"b"'.[WILDCARD]"#, ) .assert_exit_code(1); } #[test] fn workers_basic() { let context = TestContext::with_http_server(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("basic.exe") } else { dir.path().join("basic") }; context .new_command() .args_vec([ "compile", "--no-check", "--output", &exe.to_string_lossy(), "./compile/workers/basic.ts", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .name(&exe) .run() .assert_matches_file("./compile/workers/basic.out") .assert_exit_code(0); } #[test] fn workers_not_in_module_map() { let context = TestContext::with_http_server(); let temp_dir = context.temp_dir(); let exe = if cfg!(windows) { temp_dir.path().join("not_in_module_map.exe") } else { temp_dir.path().join("not_in_module_map") }; let output = context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/workers/not_in_module_map.ts", ]) .run(); output.assert_exit_code(0); output.skip_output_check(); let output = context.new_command().name(exe).env("NO_COLOR", "").run(); output.assert_exit_code(1); output.assert_matches_text(concat!( "error: Uncaught (in worker \"\") Module not found: [WILDCARD]", "error: Uncaught (in promise) Error: Unhandled error in child worker.\n[WILDCARD]" )); } #[test] fn workers_with_include_flag() { let context = TestContext::with_http_server(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("workers_with_include_flag.exe") } else { dir.path().join("workers_with_include_flag") }; context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "--include", "./compile/workers/worker.ts", "./compile/workers/not_in_module_map.ts", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .name(&exe) .env("NO_COLOR", "") .run() .assert_matches_text("Hello from worker!\nReceived 42\nClosing\n"); } #[test] fn dynamic_import() { let context = TestContext::with_http_server(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("dynamic_import.exe") } else { dir.path().join("dynamic_import") }; context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/dynamic_imports/main.ts", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .name(&exe) .env("NO_COLOR", "") .run() .assert_matches_file("./compile/dynamic_imports/main.out") .assert_exit_code(0); } #[test] fn dynamic_import_unanalyzable() { let context = TestContext::with_http_server(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("dynamic_import_unanalyzable.exe") } else { dir.path().join("dynamic_import_unanalyzable") }; context .new_command() .args_vec([ "compile", "--allow-read", "--include", "./compile/dynamic_imports/import1.ts", "--output", &exe.to_string_lossy(), "./compile/dynamic_imports/main_unanalyzable.ts", ]) .run() .skip_output_check() .assert_exit_code(0); context .new_command() .current_dir(util::root_path()) .name(&exe) .env("NO_COLOR", "") .run() .assert_matches_file("./compile/dynamic_imports/main.out") .assert_exit_code(0); } #[test] fn compile_npm_specifiers() { let context = TestContextBuilder::for_npm().use_temp_cwd().build(); let temp_dir = context.temp_dir(); temp_dir.write( "main.ts", concat!( "import path from 'node:path';\n", "import { getValue, setValue } from 'npm:@denotest/esm-basic';\n", "import getValueDefault from 'npm:@denotest/esm-import-cjs-default';\n", "setValue(2);\n", "console.log(path.join('testing', 'this'));", "console.log(getValue());", "console.log(getValueDefault());", ), ); let binary_path = if cfg!(windows) { temp_dir.path().join("binary.exe") } else { temp_dir.path().join("binary") }; // try with and without --node-modules-dir let compile_commands = &[ "compile --output binary main.ts", "compile --node-modules-dir --output binary main.ts", ]; for compile_command in compile_commands { let output = context.new_command().args(compile_command).run(); output.assert_exit_code(0); output.skip_output_check(); let output = context.new_command().name(&binary_path).run(); output.assert_matches_text( r#"Node esm importing node cjs =========================== { default: [Function (anonymous)], named: [Function (anonymous)], MyClass: [class MyClass] } { default: [Function (anonymous)], named: [Function (anonymous)] } [Module: null prototype] { MyClass: [class MyClass], __esModule: true, default: { default: [Function (anonymous)], named: [Function (anonymous)], MyClass: [class MyClass] }, named: [Function (anonymous)] } [Module: null prototype] { __esModule: true, default: { default: [Function (anonymous)], named: [Function (anonymous)] }, named: [Function (anonymous)] } =========================== static method testing[WILDCARD]this 2 5 "#, ); } // try with a package.json temp_dir.remove_dir_all("node_modules"); temp_dir.write( "main.ts", concat!( "import { getValue, setValue } from '@denotest/esm-basic';\n", "setValue(2);\n", "console.log(getValue());", ), ); temp_dir.write( "package.json", r#"{ "dependencies": { "@denotest/esm-basic": "1" } }"#, ); context .new_command() .args("compile --output binary main.ts") .run() .assert_exit_code(0) .skip_output_check(); context .new_command() .name(&binary_path) .run() .assert_matches_text("2\n"); // now try with byonm temp_dir.remove_dir_all("node_modules"); temp_dir.write("deno.json", r#"{"unstable":["byonm"]}"#); context.run_npm("install"); context .new_command() .args("compile --output binary main.ts") .run() .assert_exit_code(0) .assert_matches_text("Check file:///[WILDCARD]/main.ts\nCompile file:///[WILDCARD]/main.ts to binary[WILDCARD]\n"); context .new_command() .name(&binary_path) .run() .assert_matches_text("2\n"); } #[test] fn compile_npm_file_system() { run_npm_bin_compile_test(RunNpmBinCompileOptions { input_specifier: "compile/npm_fs/main.ts", compile_args: vec!["-A"], run_args: vec![], output_file: "compile/npm_fs/main.out", node_modules_dir: true, input_name: Some("binary"), expected_name: "binary", exit_code: 0, }); } #[test] fn compile_npm_bin_esm() { run_npm_bin_compile_test(RunNpmBinCompileOptions { input_specifier: "npm:@denotest/bin/cli-esm", compile_args: vec![], run_args: vec!["this", "is", "a", "test"], output_file: "npm/deno_run_esm.out", node_modules_dir: false, input_name: None, expected_name: "cli-esm", exit_code: 0, }); } #[test] fn compile_npm_bin_cjs() { run_npm_bin_compile_test(RunNpmBinCompileOptions { input_specifier: "npm:@denotest/bin/cli-cjs", compile_args: vec![], run_args: vec!["this", "is", "a", "test"], output_file: "npm/deno_run_cjs.out", node_modules_dir: false, input_name: None, expected_name: "cli-cjs", exit_code: 0, }); } #[test] fn compile_npm_cowsay_main() { run_npm_bin_compile_test(RunNpmBinCompileOptions { input_specifier: "npm:cowsay@1.5.0", compile_args: vec!["--allow-read"], run_args: vec!["Hello"], output_file: "npm/deno_run_cowsay.out", node_modules_dir: false, input_name: None, expected_name: "cowsay", exit_code: 0, }); } #[test] fn compile_npm_vfs_implicit_read_permissions() { run_npm_bin_compile_test(RunNpmBinCompileOptions { input_specifier: "compile/vfs_implicit_read_permission/main.ts", compile_args: vec![], run_args: vec![], output_file: "compile/vfs_implicit_read_permission/main.out", node_modules_dir: false, input_name: Some("binary"), expected_name: "binary", exit_code: 0, }); } #[test] fn compile_npm_no_permissions() { run_npm_bin_compile_test(RunNpmBinCompileOptions { input_specifier: "npm:cowsay@1.5.0", compile_args: vec![], run_args: vec!["Hello"], output_file: "npm/deno_run_cowsay_no_permissions.out", node_modules_dir: false, input_name: None, expected_name: "cowsay", exit_code: 1, }); } #[test] fn compile_npm_cowsay_explicit() { run_npm_bin_compile_test(RunNpmBinCompileOptions { input_specifier: "npm:cowsay@1.5.0/cowsay", compile_args: vec!["--allow-read"], run_args: vec!["Hello"], output_file: "npm/deno_run_cowsay.out", node_modules_dir: false, input_name: None, expected_name: "cowsay", exit_code: 0, }); } #[test] fn compile_npm_cowthink() { run_npm_bin_compile_test(RunNpmBinCompileOptions { input_specifier: "npm:cowsay@1.5.0/cowthink", compile_args: vec!["--allow-read"], run_args: vec!["Hello"], output_file: "npm/deno_run_cowthink.out", node_modules_dir: false, input_name: None, expected_name: "cowthink", exit_code: 0, }); } struct RunNpmBinCompileOptions<'a> { input_specifier: &'a str, node_modules_dir: bool, output_file: &'a str, input_name: Option<&'a str>, expected_name: &'a str, run_args: Vec<&'a str>, compile_args: Vec<&'a str>, exit_code: i32, } fn run_npm_bin_compile_test(opts: RunNpmBinCompileOptions) { let context = TestContextBuilder::for_npm().use_temp_cwd().build(); let temp_dir = context.temp_dir(); let main_specifier = if opts.input_specifier.starts_with("npm:") { opts.input_specifier.to_string() } else { testdata_path().join(opts.input_specifier).to_string() }; let mut args = vec!["compile".to_string()]; args.extend(opts.compile_args.iter().map(|s| s.to_string())); if opts.node_modules_dir { args.push("--node-modules-dir".to_string()); } if let Some(bin_name) = opts.input_name { args.push("--output".to_string()); args.push(bin_name.to_string()); } args.push(main_specifier); // compile let output = context.new_command().args_vec(args).run(); output.assert_exit_code(0); output.skip_output_check(); // delete the npm folder in the DENO_DIR to ensure it's not using it context.deno_dir().remove_dir_all("./npm"); // run let binary_path = if cfg!(windows) { temp_dir.path().join(format!("{}.exe", opts.expected_name)) } else { temp_dir.path().join(opts.expected_name) }; let output = context .new_command() .name(binary_path) .args_vec(opts.run_args) .run(); output.assert_matches_file(opts.output_file); output.assert_exit_code(opts.exit_code); } #[test] fn compile_node_modules_symlink_outside() { let context = TestContextBuilder::for_npm() .use_copy_temp_dir("compile/node_modules_symlink_outside") .cwd("compile/node_modules_symlink_outside") .build(); let temp_dir = context.temp_dir(); let project_dir = temp_dir .path() .join("compile") .join("node_modules_symlink_outside"); temp_dir.create_dir_all(project_dir.join("node_modules")); temp_dir.create_dir_all(project_dir.join("some_folder")); temp_dir.write(project_dir.join("test.txt"), "5"); // create a symlink in the node_modules directory that points to a folder in the cwd temp_dir.symlink_dir( project_dir.join("some_folder"), project_dir.join("node_modules").join("some_folder"), ); // compile folder let output = context .new_command() .args("compile --allow-read --node-modules-dir --output bin main.ts") .run(); output.assert_exit_code(0); output.assert_matches_file( "compile/node_modules_symlink_outside/main_compile_folder.out", ); assert!(project_dir.join("node_modules/some_folder").exists()); // Cleanup and remove the folder. The folder test is done separately from // the file symlink test because different systems would traverse // the directory items in different order. temp_dir.remove_dir_all(project_dir.join("node_modules/some_folder")); // create a symlink in the node_modules directory that points to a file in the cwd temp_dir.symlink_file( project_dir.join("test.txt"), project_dir.join("node_modules").join("test.txt"), ); assert!(project_dir.join("node_modules/test.txt").exists()); // compile let output = context .new_command() .args("compile --allow-read --node-modules-dir --output bin main.ts") .run(); output.assert_exit_code(0); output.assert_matches_file( "compile/node_modules_symlink_outside/main_compile_file.out", ); // run let binary_path = project_dir.join(if cfg!(windows) { "bin.exe" } else { "bin" }); let output = context.new_command().name(binary_path).run(); output.assert_matches_file("compile/node_modules_symlink_outside/main.out"); } #[test] fn compile_node_modules_symlink_non_existent() { let context = TestContextBuilder::for_npm().use_temp_cwd().build(); let temp_dir = context.temp_dir().path(); temp_dir.join("main.ts").write( r#"import { getValue, setValue } from "npm:@denotest/esm-basic"; setValue(4); console.log(getValue());"#, ); let node_modules_dir = temp_dir.join("node_modules"); node_modules_dir.create_dir_all(); // create a symlink that points to a non_existent file node_modules_dir.symlink_dir("non_existent", "folder"); // compile folder let output = context .new_command() .args("compile --allow-read --node-modules-dir --output bin main.ts") .run(); output.assert_exit_code(0); output.assert_matches_text( r#"Download http://localhost:4545/npm/registry/@denotest/esm-basic Download http://localhost:4545/npm/registry/@denotest/esm-basic/1.0.0.tgz Initialize @denotest/esm-basic@1.0.0 Check file:///[WILDCARD]/main.ts Compile file:///[WILDCARD]/main.ts to [WILDCARD] Warning Failed resolving symlink. Ignoring. Path: [WILDCARD] Message: [WILDCARD]) "#, ); // run let binary_path = temp_dir.join(if cfg!(windows) { "bin.exe" } else { "bin" }); let output = context.new_command().name(binary_path).run(); output.assert_matches_text("4\n"); } #[test] fn dynamic_imports_tmp_lit() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("app.exe") } else { dir.path().join("app") }; let output = context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "./compile/dynamic_imports_tmp_lit/main.js", ]) .run(); output.assert_exit_code(0); output.skip_output_check(); let output = context.new_command().name(&exe).run(); output.assert_matches_text("a\nb\n{ data: 5 }\n{ data: 1 }\n"); } #[test] fn granular_unstable_features() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("app.exe") } else { dir.path().join("app") }; let output = context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), "--unstable-kv", "./compile/unstable_features.ts", ]) .run(); output.assert_exit_code(0); output.skip_output_check(); let output = context.new_command().name(&exe).run(); output.assert_exit_code(0); output.assert_matches_text("Kv {}\n"); } #[test] fn dynamic_import_bad_data_uri() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("app.exe") } else { dir.path().join("app") }; let file = dir.path().join("bad_data_uri.ts"); file.write("await import('data:application/')"); let output = context .new_command() .args_vec([ "compile", "--output", &exe.to_string_lossy(), &file.to_string_lossy(), ]) .run(); output.assert_exit_code(0); output.skip_output_check(); let output = context.new_command().name(&exe).run(); output.assert_exit_code(1); output.assert_matches_text( "[WILDCARD]TypeError: Unable to decode data url.[WILDCARD]", ); } #[test] fn standalone_config_file_respects_compiler_options() { let context = TestContextBuilder::new().build(); let dir = context.temp_dir(); let exe = if cfg!(windows) { dir.path().join("compiler_options.exe") } else { dir.path().join("compiler_options") }; context .new_command() .args_vec([ "compile", "--allow-read", "--config", "compile/compiler_options/deno.json", "--output", &exe.to_string_lossy(), "./compile/compiler_options/main.ts", ]) .run() .skip_output_check() .assert_exit_code(0); let output = context.new_command().name(&exe).run(); output.assert_exit_code(0); output.assert_matches_text("[WILDCARD]C.test() called[WILDCARD]"); }