0
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-10-29 08:58:01 -04:00

chore(cli/tests): use test builder in more integration tests (#18031)

This commit is contained in:
Geert-Jan Zwiers 2023-03-13 14:40:46 +01:00 committed by GitHub
parent 224cff7a2f
commit 983447e860
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 442 additions and 513 deletions

View file

@ -1,11 +1,10 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
use std::process::Command;
use std::process::Stdio;
use test_util as util;
use util::env_vars_for_npm_tests;
use util::env_vars_for_npm_tests_no_sync_download;
use util::TempDir;
use util::TestContext;
itest!(_095_check_with_bare_import {
args: "check cache/095_cache_with_bare_import.ts",
@ -87,31 +86,34 @@ itest!(check_no_error_truncation {
#[test]
fn cache_switching_config_then_no_config() {
let deno_dir = util::new_deno_dir();
assert!(does_type_checking(&deno_dir, true));
assert!(does_type_checking(&deno_dir, false));
let context = TestContext::default();
assert!(does_type_checking(&context, true));
assert!(does_type_checking(&context, false));
// should now not do type checking even when it changes
// configs because it previously did
assert!(!does_type_checking(&deno_dir, true));
assert!(!does_type_checking(&deno_dir, false));
assert!(!does_type_checking(&context, true));
assert!(!does_type_checking(&context, false));
fn does_type_checking(deno_dir: &util::TempDir, with_config: bool) -> bool {
let mut cmd = util::deno_cmd_with_deno_dir(deno_dir);
cmd
.current_dir(util::testdata_path())
.stderr(Stdio::piped())
.arg("check")
.arg("check/cache_config_on_off/main.ts");
fn does_type_checking(context: &TestContext, with_config: bool) -> bool {
let mut args = vec![
"check".to_string(),
"check/cache_config_on_off/main.ts".to_string(),
];
if with_config {
cmd
.arg("--config")
.arg("check/cache_config_on_off/deno.json");
let mut slice = vec![
"--config".to_string(),
"check/cache_config_on_off/deno.json".to_string(),
];
args.append(&mut slice);
}
let output = cmd.spawn().unwrap().wait_with_output().unwrap();
assert!(output.status.success());
let stderr = std::str::from_utf8(&output.stderr).unwrap();
let output = context.new_command().args_vec(args).split_output().run();
output.assert_exit_code(0);
let stderr = output.stderr();
stderr.contains("Check")
}
}
@ -119,61 +121,72 @@ fn cache_switching_config_then_no_config() {
#[test]
fn reload_flag() {
// should do type checking whenever someone specifies --reload
let deno_dir = util::new_deno_dir();
assert!(does_type_checking(&deno_dir, false));
assert!(!does_type_checking(&deno_dir, false));
assert!(does_type_checking(&deno_dir, true));
assert!(does_type_checking(&deno_dir, true));
assert!(!does_type_checking(&deno_dir, false));
let context = TestContext::default();
fn does_type_checking(deno_dir: &util::TempDir, reload: bool) -> bool {
let mut cmd = util::deno_cmd_with_deno_dir(deno_dir);
cmd
.current_dir(util::testdata_path())
.stderr(Stdio::piped())
.arg("check")
.arg("check/cache_config_on_off/main.ts");
assert!(does_type_checking(&context, false));
assert!(!does_type_checking(&context, false));
assert!(does_type_checking(&context, true));
assert!(does_type_checking(&context, true));
assert!(!does_type_checking(&context, false));
fn does_type_checking(context: &TestContext, reload: bool) -> bool {
let mut args = vec![
"check".to_string(),
"check/cache_config_on_off/main.ts".to_string(),
];
if reload {
cmd.arg("--reload");
let mut slice = vec!["--reload".to_string()];
args.append(&mut slice);
}
let output = cmd.spawn().unwrap().wait_with_output().unwrap();
assert!(output.status.success());
let output = context.new_command().args_vec(args).split_output().run();
output.assert_exit_code(0);
let stderr = std::str::from_utf8(&output.stderr).unwrap();
let stderr = output.stderr();
stderr.contains("Check")
}
}
#[test]
fn typecheck_declarations_ns() {
let output = util::deno_cmd()
.arg("test")
.arg("--doc")
.arg(util::root_path().join("cli/tsc/dts/lib.deno.ns.d.ts"))
.output()
.unwrap();
println!("stdout: {}", String::from_utf8(output.stdout).unwrap());
println!("stderr: {}", String::from_utf8(output.stderr).unwrap());
assert!(output.status.success());
let context = TestContext::default();
let args = vec![
"test".to_string(),
"--doc".to_string(),
util::root_path()
.join("cli/tsc/dts/lib.deno.ns.d.ts")
.to_string_lossy()
.into_owned(),
];
let output = context.new_command().args_vec(args).split_output().run();
println!("stdout: {}", output.stdout());
println!("stderr: {}", output.stderr());
output.assert_exit_code(0);
}
#[test]
fn typecheck_declarations_unstable() {
let output = util::deno_cmd()
.arg("test")
.arg("--doc")
.arg("--unstable")
.arg(util::root_path().join("cli/tsc/dts/lib.deno.unstable.d.ts"))
.output()
.unwrap();
println!("stdout: {}", String::from_utf8(output.stdout).unwrap());
println!("stderr: {}", String::from_utf8(output.stderr).unwrap());
assert!(output.status.success());
let context = TestContext::default();
let args = vec![
"test".to_string(),
"--doc".to_string(),
"--unstable".to_string(),
util::root_path()
.join("cli/tsc/dts/lib.deno.unstable.d.ts")
.to_string_lossy()
.into_owned(),
];
let output = context.new_command().args_vec(args).split_output().run();
println!("stdout: {}", output.stdout());
println!("stderr: {}", output.stderr());
output.assert_exit_code(0);
}
#[test]
fn typecheck_core() {
let deno_dir = TempDir::new();
let context = TestContext::default();
let deno_dir = context.deno_dir();
let test_file = deno_dir.path().join("test_deno_core_types.ts");
std::fs::write(
&test_file,
@ -189,18 +202,18 @@ fn typecheck_core() {
),
)
.unwrap();
let output = util::deno_cmd_with_deno_dir(&deno_dir)
.arg("run")
.arg(test_file.to_str().unwrap())
.output()
.unwrap();
println!("stdout: {}", String::from_utf8(output.stdout).unwrap());
println!("stderr: {}", String::from_utf8(output.stderr).unwrap());
assert!(output.status.success());
let args = vec!["run".to_string(), test_file.to_string_lossy().into_owned()];
let output = context.new_command().args_vec(args).split_output().run();
println!("stdout: {}", output.stdout());
println!("stderr: {}", output.stderr());
output.assert_exit_code(0);
}
#[test]
fn ts_no_recheck_on_redirect() {
// TODO: port to test builder
let deno_dir = util::new_deno_dir();
let e = util::deno_exe_path();

View file

@ -3,6 +3,8 @@
use std::fs;
use test_util as util;
use test_util::TempDir;
use util::TestContext;
use util::TestContextBuilder;
#[test]
fn branch() {
@ -26,7 +28,8 @@ fn no_snaps() {
#[test]
fn error_if_invalid_cache() {
let deno_dir = TempDir::new();
let context = TestContextBuilder::new().use_temp_cwd().build();
let deno_dir = context.deno_dir();
let deno_dir_path = deno_dir.path();
let tempdir = TempDir::new();
let tempdir = tempdir.path().join("cov");
@ -51,76 +54,70 @@ fn error_if_invalid_cache() {
std::fs::copy(mod_test_path, mod_test_temp_path).unwrap();
// Generate coverage
let status = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(deno_dir_path)
.arg("test")
.arg("--quiet")
.arg(format!("--coverage={}", tempdir.to_str().unwrap()))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::inherit())
.status()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"test".to_string(),
"--quiet".to_string(),
format!("--coverage={}", tempdir.to_str().unwrap()),
])
.run();
assert!(status.success());
output.assert_exit_code(0);
output.skip_output_check();
// Modify the file between deno test and deno coverage, thus invalidating the cache
std::fs::copy(mod_after_path, mod_temp_path).unwrap();
let output = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(deno_dir_path)
.arg("coverage")
.arg(format!("{}/", tempdir.to_str().unwrap()))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.output()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"coverage".to_string(),
format!("{}/", tempdir.to_str().unwrap()),
])
.run();
assert!(output.stdout.is_empty());
output.assert_exit_code(1);
let out = output.combined_output();
// Expect error
let error =
util::strip_ansi_codes(std::str::from_utf8(&output.stderr).unwrap())
.to_string();
let error = util::strip_ansi_codes(out).to_string();
assert!(error.contains("error: Missing transpiled source code"));
assert!(error.contains("Before generating coverage report, run `deno test --coverage` to ensure consistent state."));
}
fn run_coverage_text(test_name: &str, extension: &str) {
let deno_dir = TempDir::new();
let tempdir = TempDir::new();
let context = TestContext::default();
let tempdir = context.deno_dir();
let tempdir = tempdir.path().join("cov");
let status = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("test")
.arg("-A")
.arg("--quiet")
.arg("--unstable")
.arg(format!("--coverage={}", tempdir.to_str().unwrap()))
.arg(format!("coverage/{test_name}_test.{extension}"))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::inherit())
.status()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"test".to_string(),
"-A".to_string(),
"--quiet".to_string(),
format!("--coverage={}", tempdir.to_str().unwrap()),
format!("coverage/{test_name}_test.{extension}"),
])
.run();
assert!(status.success());
output.assert_exit_code(0);
output.skip_output_check();
let output = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("coverage")
.arg("--unstable")
.arg(format!("{}/", tempdir.to_str().unwrap()))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.output()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"coverage".to_string(),
format!("{}/", tempdir.to_str().unwrap()),
])
.split_output()
.run();
// Verify there's no "Check" being printed
assert!(output.stderr.is_empty());
assert!(output.stderr().is_empty());
let actual =
util::strip_ansi_codes(std::str::from_utf8(&output.stdout).unwrap())
.to_string();
let actual = util::strip_ansi_codes(output.stdout()).to_string();
let expected = fs::read_to_string(
util::testdata_path().join(format!("coverage/{test_name}_expected.out")),
@ -133,23 +130,19 @@ fn run_coverage_text(test_name: &str, extension: &str) {
panic!("pattern match failed");
}
assert!(output.status.success());
output.assert_exit_code(0);
let output = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("coverage")
.arg("--quiet")
.arg("--unstable")
.arg("--lcov")
.arg(format!("{}/", tempdir.to_str().unwrap()))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::inherit())
.output()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"coverage".to_string(),
"--quiet".to_string(),
"--lcov".to_string(),
format!("{}/", tempdir.to_str().unwrap()),
])
.run();
let actual =
util::strip_ansi_codes(std::str::from_utf8(&output.stdout).unwrap())
.to_string();
let actual = util::strip_ansi_codes(output.combined_output()).to_string();
let expected = fs::read_to_string(
util::testdata_path().join(format!("coverage/{test_name}_expected.lcov")),
@ -162,45 +155,41 @@ fn run_coverage_text(test_name: &str, extension: &str) {
panic!("pattern match failed");
}
assert!(output.status.success());
output.assert_exit_code(0);
}
#[test]
fn multifile_coverage() {
let deno_dir = TempDir::new();
let tempdir = TempDir::new();
let context = TestContext::default();
let tempdir = context.deno_dir();
let tempdir = tempdir.path().join("cov");
let status = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("test")
.arg("--quiet")
.arg("--unstable")
.arg(format!("--coverage={}", tempdir.to_str().unwrap()))
.arg("coverage/multifile/")
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::inherit())
.status()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"test".to_string(),
"--quiet".to_string(),
format!("--coverage={}", tempdir.to_str().unwrap()),
format!("coverage/multifile/"),
])
.run();
assert!(status.success());
output.assert_exit_code(0);
output.skip_output_check();
let output = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("coverage")
.arg("--unstable")
.arg(format!("{}/", tempdir.to_str().unwrap()))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.output()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"coverage".to_string(),
format!("{}/", tempdir.to_str().unwrap()),
])
.split_output()
.run();
// Verify there's no "Check" being printed
assert!(output.stderr.is_empty());
assert!(output.stderr().is_empty());
let actual =
util::strip_ansi_codes(std::str::from_utf8(&output.stdout).unwrap())
.to_string();
let actual = util::strip_ansi_codes(output.stdout()).to_string();
let expected = fs::read_to_string(
util::testdata_path().join("coverage/multifile/expected.out"),
@ -212,24 +201,19 @@ fn multifile_coverage() {
println!("EXPECTED\n{expected}\nEXPECTED");
panic!("pattern match failed");
}
output.assert_exit_code(0);
assert!(output.status.success());
let output = context
.new_command()
.args_vec(vec![
"coverage".to_string(),
"--quiet".to_string(),
"--lcov".to_string(),
format!("{}/", tempdir.to_str().unwrap()),
])
.run();
let output = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("coverage")
.arg("--quiet")
.arg("--unstable")
.arg("--lcov")
.arg(format!("{}/", tempdir.to_str().unwrap()))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::inherit())
.output()
.unwrap();
let actual =
util::strip_ansi_codes(std::str::from_utf8(&output.stdout).unwrap())
.to_string();
let actual = util::strip_ansi_codes(output.combined_output()).to_string();
let expected = fs::read_to_string(
util::testdata_path().join("coverage/multifile/expected.lcov"),
@ -242,48 +226,42 @@ fn multifile_coverage() {
panic!("pattern match failed");
}
assert!(output.status.success());
output.assert_exit_code(0);
}
fn no_snaps_included(test_name: &str, extension: &str) {
let deno_dir = TempDir::new();
let tempdir = TempDir::new();
let context = TestContext::default();
let tempdir = context.deno_dir();
let tempdir = tempdir.path().join("cov");
let status = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("test")
.arg("--quiet")
.arg("--unstable")
.arg("--allow-read")
.arg(format!("--coverage={}", tempdir.to_str().unwrap()))
.arg(format!(
"coverage/no_snaps_included/{test_name}_test.{extension}"
))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.status()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"test".to_string(),
"--quiet".to_string(),
"--allow-read".to_string(),
format!("--coverage={}", tempdir.to_str().unwrap()),
format!("coverage/no_snaps_included/{test_name}_test.{extension}"),
])
.run();
assert!(status.success());
output.assert_exit_code(0);
output.skip_output_check();
let output = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("coverage")
.arg("--unstable")
.arg("--include=no_snaps_included.ts")
.arg(format!("{}/", tempdir.to_str().unwrap()))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.output()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"coverage".to_string(),
"--include=no_snaps_included.ts".to_string(),
format!("{}/", tempdir.to_str().unwrap()),
])
.split_output()
.run();
// Verify there's no "Check" being printed
assert!(output.stderr.is_empty());
assert!(output.stderr().is_empty());
let actual =
util::strip_ansi_codes(std::str::from_utf8(&output.stdout).unwrap())
.to_string();
let actual = util::strip_ansi_codes(output.stdout()).to_string();
let expected = fs::read_to_string(
util::testdata_path().join("coverage/no_snaps_included/expected.out"),
@ -296,41 +274,38 @@ fn no_snaps_included(test_name: &str, extension: &str) {
panic!("pattern match failed");
}
assert!(output.status.success());
output.assert_exit_code(0);
}
#[test]
fn no_transpiled_lines() {
let deno_dir = TempDir::new();
let tempdir = TempDir::new();
let context = TestContext::default();
let tempdir = context.deno_dir();
let tempdir = tempdir.path().join("cov");
let status = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("test")
.arg("--quiet")
.arg(format!("--coverage={}", tempdir.to_str().unwrap()))
.arg("coverage/no_transpiled_lines/")
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::inherit())
.status()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"test".to_string(),
"--quiet".to_string(),
format!("--coverage={}", tempdir.to_str().unwrap()),
"coverage/no_transpiled_lines/".to_string(),
])
.run();
assert!(status.success());
output.assert_exit_code(0);
output.skip_output_check();
let output = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("coverage")
.arg("--include=no_transpiled_lines/index.ts")
.arg(format!("{}/", tempdir.to_str().unwrap()))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.output()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"coverage".to_string(),
"--include=no_transpiled_lines/index.ts".to_string(),
format!("{}/", tempdir.to_str().unwrap()),
])
.run();
let actual =
util::strip_ansi_codes(std::str::from_utf8(&output.stdout).unwrap())
.to_string();
let actual = util::strip_ansi_codes(output.combined_output()).to_string();
let expected = fs::read_to_string(
util::testdata_path().join("coverage/no_transpiled_lines/expected.out"),
@ -343,22 +318,19 @@ fn no_transpiled_lines() {
panic!("pattern match failed");
}
assert!(output.status.success());
output.assert_exit_code(0);
let output = util::deno_cmd_with_deno_dir(&deno_dir)
.current_dir(util::testdata_path())
.arg("coverage")
.arg("--lcov")
.arg("--include=no_transpiled_lines/index.ts")
.arg(format!("{}/", tempdir.to_str().unwrap()))
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::inherit())
.output()
.unwrap();
let output = context
.new_command()
.args_vec(vec![
"coverage".to_string(),
"--lcov".to_string(),
"--include=no_transpiled_lines/index.ts".to_string(),
format!("{}/", tempdir.to_str().unwrap()),
])
.run();
let actual =
util::strip_ansi_codes(std::str::from_utf8(&output.stdout).unwrap())
.to_string();
let actual = util::strip_ansi_codes(output.combined_output()).to_string();
let expected = fs::read_to_string(
util::testdata_path().join("coverage/no_transpiled_lines/expected.lcov"),
@ -371,5 +343,5 @@ fn no_transpiled_lines() {
panic!("pattern match failed");
}
assert!(output.status.success());
output.assert_exit_code(0);
}

View file

@ -1,8 +1,8 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
use test_util as util;
use test_util::TempDir;
use util::assert_contains;
use util::TestContext;
itest!(deno_doc_builtin {
args: "doc",
@ -11,24 +11,18 @@ itest!(deno_doc_builtin {
#[test]
fn deno_doc() {
let dir = TempDir::new();
let context = TestContext::default();
// try this twice to ensure it works with the cache
for _ in 0..2 {
let output = util::deno_cmd_with_deno_dir(&dir)
.current_dir(util::testdata_path())
.arg("doc")
.arg("doc/deno_doc.ts")
let output = context
.new_command()
.env("NO_COLOR", "1")
.stdout(std::process::Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
assert_contains!(
std::str::from_utf8(&output.stdout).unwrap(),
"function foo"
);
.args("doc doc/deno_doc.ts")
.split_output()
.run();
output.assert_exit_code(0);
assert_contains!(output.stdout(), "function foo");
}
}

View file

@ -2,10 +2,12 @@
use test_util as util;
use test_util::TempDir;
use util::TestContext;
#[test]
fn fmt_test() {
let t = TempDir::new();
let context = TestContext::default();
let t = context.deno_dir();
let testdata_fmt_dir = util::testdata_path().join("fmt");
let fixed_js = testdata_fmt_dir.join("badly_formatted_fixed.js");
let badly_formatted_original_js =
@ -27,49 +29,57 @@ fn fmt_test() {
let badly_formatted_json_str = badly_formatted_json.to_str().unwrap();
std::fs::copy(badly_formatted_original_json, &badly_formatted_json).unwrap();
// First, check formatting by ignoring the badly formatted file.
let status = util::deno_cmd()
.current_dir(&testdata_fmt_dir)
.arg("fmt")
.arg(format!(
"--ignore={badly_formatted_js_str},{badly_formatted_md_str},{badly_formatted_json_str}"
))
.arg("--check")
.arg(badly_formatted_js_str)
.arg(badly_formatted_md_str)
.arg(badly_formatted_json_str)
.spawn()
.unwrap()
.wait()
.unwrap();
let s = testdata_fmt_dir.as_os_str().to_str().unwrap();
let output = context
.new_command()
.cwd(s)
.args_vec(vec![
"fmt".to_string(),
format!(
"--ignore={badly_formatted_js_str},{badly_formatted_md_str},{badly_formatted_json_str}",
),
format!(
"--check {badly_formatted_js_str} {badly_formatted_md_str} {badly_formatted_json_str}",
),
])
.run();
// No target files found
assert!(!status.success());
output.assert_exit_code(1);
output.skip_output_check();
// Check without ignore.
let status = util::deno_cmd()
.current_dir(&testdata_fmt_dir)
.arg("fmt")
.arg("--check")
.arg(badly_formatted_js_str)
.arg(badly_formatted_md_str)
.arg(badly_formatted_json_str)
.spawn()
.unwrap()
.wait()
.unwrap();
assert!(!status.success());
let output = context
.new_command()
.cwd(s)
.args_vec(vec![
"fmt".to_string(),
"--check".to_string(),
badly_formatted_js_str.to_string(),
badly_formatted_md_str.to_string(),
badly_formatted_json_str.to_string(),
])
.run();
output.assert_exit_code(1);
output.skip_output_check();
// Format the source file.
let status = util::deno_cmd()
.current_dir(&testdata_fmt_dir)
.arg("fmt")
.arg(badly_formatted_js_str)
.arg(badly_formatted_md_str)
.arg(badly_formatted_json_str)
.spawn()
.unwrap()
.wait()
.unwrap();
assert!(status.success());
let output = context
.new_command()
.cwd(s)
.args_vec(vec![
"fmt".to_string(),
badly_formatted_js_str.to_string(),
badly_formatted_md_str.to_string(),
badly_formatted_json_str.to_string(),
])
.run();
output.assert_exit_code(0);
output.skip_output_check();
let expected_js = std::fs::read_to_string(fixed_js).unwrap();
let expected_md = std::fs::read_to_string(fixed_md).unwrap();
let expected_json = std::fs::read_to_string(fixed_json).unwrap();
@ -105,22 +115,15 @@ fn fmt_stdin_error() {
#[test]
fn fmt_ignore_unexplicit_files() {
let output = util::deno_cmd()
.current_dir(util::testdata_path())
let context = TestContext::default();
let output = context
.new_command()
.env("NO_COLOR", "1")
.arg("fmt")
.arg("--check")
.arg("--ignore=./")
.stderr(std::process::Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(!output.status.success());
assert_eq!(
String::from_utf8_lossy(&output.stderr),
"error: No target files found.\n"
);
.args("fmt --check --ignore=./")
.run();
output.assert_exit_code(1);
assert_eq!(output.combined_output(), "error: No target files found.\n");
}
#[test]
@ -148,20 +151,17 @@ fn fmt_auto_ignore_git_and_node_modules() {
create_bad_json(git_dir);
create_bad_json(nest_node_modules);
create_bad_json(node_modules_dir);
let output = util::deno_cmd()
.current_dir(t)
let context = TestContext::default();
let output = context
.new_command()
.cwd(t.as_os_str().to_str().unwrap())
.env("NO_COLOR", "1")
.arg("fmt")
.stderr(std::process::Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(!output.status.success());
assert_eq!(
String::from_utf8_lossy(&output.stderr),
"error: No target files found.\n"
);
.args("fmt")
.run();
output.assert_exit_code(1);
assert_eq!(output.combined_output(), "error: No target files found.\n");
}
itest!(fmt_quiet_check_fmt_dir {

View file

@ -1,27 +1,21 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
use std::process::Stdio;
use test_util as util;
use test_util::TempDir;
use util::assert_contains;
use util::TestContextBuilder;
#[test]
fn init_subcommand_without_dir() {
let temp_dir = TempDir::new();
let cwd = temp_dir.path();
let deno_dir = util::new_deno_dir();
let context = TestContextBuilder::new().use_temp_cwd().build();
let deno_dir = context.deno_dir();
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
.arg("init")
.stderr(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
let stderr = String::from_utf8(output.stderr).unwrap();
let cwd = deno_dir.path();
let output = context.new_command().args("init").split_output().run();
output.assert_exit_code(0);
let stderr = output.stderr();
assert_contains!(stderr, "Project initialized");
assert!(!stderr.contains("cd"));
assert_contains!(stderr, "deno run main.ts");
@ -31,65 +25,52 @@ fn init_subcommand_without_dir() {
assert!(cwd.join("deno.jsonc").exists());
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
let output = context
.new_command()
.env("NO_COLOR", "1")
.arg("run")
.arg("main.ts")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
assert_eq!(output.stdout, b"Add 2 + 3 = 5\n");
.args("run main.ts")
.split_output()
.run();
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
.env("NO_COLOR", "1")
.arg("test")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
let stdout = String::from_utf8(output.stdout).unwrap();
assert_contains!(stdout, "1 passed");
output.assert_exit_code(0);
assert_eq!(output.stdout().as_bytes(), b"Add 2 + 3 = 5\n");
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
let output = context
.new_command()
.env("NO_COLOR", "1")
.arg("bench")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
.args("test")
.split_output()
.run();
output.assert_exit_code(0);
assert_contains!(output.stdout(), "1 passed");
output.skip_output_check();
let output = context
.new_command()
.env("NO_COLOR", "1")
.args("bench")
.run();
output.assert_exit_code(0);
output.skip_output_check();
}
#[test]
fn init_subcommand_with_dir_arg() {
let temp_dir = TempDir::new();
let cwd = temp_dir.path();
let deno_dir = util::new_deno_dir();
let context = TestContextBuilder::new().use_temp_cwd().build();
let deno_dir = context.deno_dir();
let cwd = deno_dir.path();
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
.arg("init")
.arg("my_dir")
.stderr(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
let stderr = String::from_utf8(output.stderr).unwrap();
let output = context
.new_command()
.args("init my_dir")
.split_output()
.run();
output.assert_exit_code(0);
let stderr = output.stderr();
assert_contains!(stderr, "Project initialized");
assert_contains!(stderr, "cd my_dir");
assert_contains!(stderr, "deno run main.ts");
@ -99,107 +80,86 @@ fn init_subcommand_with_dir_arg() {
assert!(cwd.join("my_dir/deno.jsonc").exists());
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
let output = context
.new_command()
.env("NO_COLOR", "1")
.arg("run")
.arg("my_dir/main.ts")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
assert_eq!(output.stdout, b"Add 2 + 3 = 5\n");
.args("run my_dir/main.ts")
.split_output()
.run();
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
.env("NO_COLOR", "1")
.arg("test")
.arg("my_dir/main_test.ts")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
let stdout = String::from_utf8(output.stdout).unwrap();
assert_contains!(stdout, "1 passed");
output.assert_exit_code(0);
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
assert_eq!(output.stdout().as_bytes(), b"Add 2 + 3 = 5\n");
output.skip_output_check();
let output = context
.new_command()
.env("NO_COLOR", "1")
.arg("bench")
.arg("my_dir/main_bench.ts")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
.args("test my_dir/main_test.ts")
.split_output()
.run();
output.assert_exit_code(0);
assert_contains!(output.stdout(), "1 passed");
output.skip_output_check();
let output = context
.new_command()
.env("NO_COLOR", "1")
.args("bench my_dir/main_bench.ts")
.split_output()
.run();
output.assert_exit_code(0);
output.skip_output_check();
}
#[test]
fn init_subcommand_with_quiet_arg() {
let temp_dir = TempDir::new();
let cwd = temp_dir.path();
let deno_dir = util::new_deno_dir();
let context = TestContextBuilder::new().use_temp_cwd().build();
let deno_dir = context.deno_dir();
let cwd = deno_dir.path();
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
.arg("init")
.arg("--quiet")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
let stdout = String::from_utf8(output.stdout).unwrap();
assert_eq!(stdout, "");
let output = context
.new_command()
.args("init --quiet")
.split_output()
.run();
output.assert_exit_code(0);
assert_eq!(output.stdout(), "");
assert!(cwd.join("deno.jsonc").exists());
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
let output = context
.new_command()
.env("NO_COLOR", "1")
.arg("run")
.arg("main.ts")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
assert_eq!(output.stdout, b"Add 2 + 3 = 5\n");
.args("run main.ts")
.split_output()
.run();
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
.env("NO_COLOR", "1")
.arg("test")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
let stdout = String::from_utf8(output.stdout).unwrap();
assert_contains!(stdout, "1 passed");
output.assert_exit_code(0);
assert_eq!(output.stdout().as_bytes(), b"Add 2 + 3 = 5\n");
output.skip_output_check();
let mut deno_cmd = util::deno_cmd_with_deno_dir(&deno_dir);
let output = deno_cmd
.current_dir(cwd)
let output = context
.new_command()
.env("NO_COLOR", "1")
.arg("bench")
.stdout(Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(output.status.success());
.args("test")
.split_output()
.run();
output.assert_exit_code(0);
assert_contains!(output.stdout(), "1 passed");
output.skip_output_check();
let output = context
.new_command()
.env("NO_COLOR", "1")
.args("bench")
.split_output()
.run();
output.assert_exit_code(0);
output.skip_output_check();
}

View file

@ -2,6 +2,7 @@
use deno_core::url::Url;
use test_util as util;
use util::assert_contains;
use util::env_vars_for_npm_tests;
use util::TestContext;
@ -355,24 +356,17 @@ itest!(test_with_custom_jsx {
#[test]
fn captured_output() {
let output = util::deno_cmd()
.current_dir(util::testdata_path())
.arg("test")
.arg("--allow-run")
.arg("--allow-read")
.arg("--unstable")
.arg("test/captured_output.ts")
let context = TestContext::default();
let output = context
.new_command()
.args("test --allow-run --allow-read --unstable test/captured_output.ts")
.env("NO_COLOR", "1")
.stdout(std::process::Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
.run();
let output_start = "------- output -------";
let output_end = "----- output end -----";
assert!(output.status.success());
let output_text = String::from_utf8(output.stdout).unwrap();
output.assert_exit_code(0);
let output_text = output.combined_output();
let start = output_text.find(output_start).unwrap() + output_start.len();
let end = output_text.find(output_end).unwrap();
// replace zero width space that may appear in test output due
@ -392,20 +386,16 @@ fn captured_output() {
#[test]
fn recursive_permissions_pledge() {
let output = util::deno_cmd()
.current_dir(util::testdata_path())
.arg("test")
.arg("test/recursive_permissions_pledge.js")
.stderr(std::process::Stdio::piped())
.stdout(std::process::Stdio::piped())
.spawn()
.unwrap()
.wait_with_output()
.unwrap();
assert!(!output.status.success());
assert!(String::from_utf8(output.stderr).unwrap().contains(
let context = TestContext::default();
let output = context
.new_command()
.args("test test/recursive_permissions_pledge.js")
.run();
output.assert_exit_code(1);
assert_contains!(
output.combined_output(),
"pledge test permissions called before restoring previous pledge"
));
);
}
#[test]
@ -418,7 +408,7 @@ fn file_protocol() {
let context = TestContext::default();
context
.new_command()
.args(format!("test {file_url}"))
.args_vec(vec!["test".to_string(), file_url])
.run()
.assert_matches_file("test/file_protocol.out");
}