diff options
Diffstat (limited to 'cli/tests/util/mod.rs')
| -rw-r--r-- | cli/tests/util/mod.rs | 219 |
1 files changed, 0 insertions, 219 deletions
diff --git a/cli/tests/util/mod.rs b/cli/tests/util/mod.rs deleted file mode 100644 index 4ed26f1bb..000000000 --- a/cli/tests/util/mod.rs +++ /dev/null @@ -1,219 +0,0 @@ -//! Test utilites shared between integration_tests.rs and tty_tests.rs -use deno_cli::colors::strip_ansi_codes; -pub use deno_cli::test_util::*; -use os_pipe::pipe; -use std::io::Read; -use std::io::Write; -use std::process::Command; -use std::process::Stdio; -use tempfile::TempDir; - -lazy_static! { - static ref DENO_DIR: TempDir = { TempDir::new().expect("tempdir fail") }; -} - -#[allow(dead_code)] -pub fn deno_cmd() -> Command { - let mut c = Command::new(deno_exe_path()); - c.env("DENO_DIR", DENO_DIR.path()); - c -} - -#[allow(dead_code)] // tty_tests use this but are disabled. -pub fn run_python_script(script: &str) { - let output = Command::new("python") - .env("DENO_DIR", DENO_DIR.path()) - .current_dir(root_path()) - .arg(script) - .arg(format!("--executable={}", deno_exe_path().display())) - .env("DENO_BUILD_PATH", target_dir()) - .output() - .expect("failed to spawn script"); - if !output.status.success() { - let stdout = String::from_utf8(output.stdout).unwrap(); - let stderr = String::from_utf8(output.stderr).unwrap(); - panic!( - "{} executed with failing error code\n{}{}", - script, stdout, stderr - ); - } -} - -#[derive(Debug, Default)] -pub struct CheckOutputIntegrationTest { - pub args: &'static str, - pub output: &'static str, - pub input: Option<&'static str>, - pub exit_code: i32, - pub check_stderr: bool, - pub http_server: bool, -} - -impl CheckOutputIntegrationTest { - #[allow(dead_code)] - pub fn run(&self) { - let args = self.args.split_whitespace(); - let root = root_path(); - let deno_exe = deno_exe_path(); - println!("root path {}", root.display()); - println!("deno_exe path {}", deno_exe.display()); - - let http_server_guard = if self.http_server { - Some(http_server()) - } else { - None - }; - - let (mut reader, writer) = pipe().unwrap(); - let tests_dir = root.join("cli").join("tests"); - let mut command = deno_cmd(); - command.args(args); - command.current_dir(&tests_dir); - command.stdin(Stdio::piped()); - command.stderr(Stdio::null()); - - if self.check_stderr { - let writer_clone = writer.try_clone().unwrap(); - command.stderr(writer_clone); - } - - command.stdout(writer); - - let mut process = command.spawn().expect("failed to execute process"); - - if let Some(input) = self.input { - let mut p_stdin = process.stdin.take().unwrap(); - write!(p_stdin, "{}", input).unwrap(); - } - - // Very important when using pipes: This parent process is still - // holding its copies of the write ends, and we have to close them - // before we read, otherwise the read end will never report EOF. The - // Command object owns the writers now, and dropping it closes them. - drop(command); - - let mut actual = String::new(); - reader.read_to_string(&mut actual).unwrap(); - - let status = process.wait().expect("failed to finish process"); - let exit_code = status.code().unwrap(); - - drop(http_server_guard); - - actual = strip_ansi_codes(&actual).to_string(); - - if self.exit_code != exit_code { - println!("OUTPUT\n{}\nOUTPUT", actual); - panic!( - "bad exit code, expected: {:?}, actual: {:?}", - self.exit_code, exit_code - ); - } - - let output_path = tests_dir.join(self.output); - println!("output path {}", output_path.display()); - let expected = - std::fs::read_to_string(output_path).expect("cannot read output"); - - if !wildcard_match(&expected, &actual) { - println!("OUTPUT\n{}\nOUTPUT", actual); - println!("EXPECTED\n{}\nEXPECTED", expected); - panic!("pattern match failed"); - } - } -} - -fn wildcard_match(pattern: &str, s: &str) -> bool { - pattern_match(pattern, s, "[WILDCARD]") -} - -fn pattern_match(pattern: &str, s: &str, wildcard: &str) -> bool { - // Normalize line endings - let s = s.replace("\r\n", "\n"); - let pattern = pattern.replace("\r\n", "\n"); - - if pattern == wildcard { - return true; - } - - let parts = pattern.split(wildcard).collect::<Vec<&str>>(); - if parts.len() == 1 { - return pattern == s; - } - - if !s.starts_with(parts[0]) { - return false; - } - - let mut t = s.split_at(parts[0].len()); - - for (i, part) in parts.iter().enumerate() { - if i == 0 { - continue; - } - dbg!(part, i); - if i == parts.len() - 1 && (*part == "" || *part == "\n") { - dbg!("exit 1 true", i); - return true; - } - if let Some(found) = t.1.find(*part) { - dbg!("found ", found); - t = t.1.split_at(found + part.len()); - } else { - dbg!("exit false ", i); - return false; - } - } - - dbg!("end ", t.1.len()); - t.1.is_empty() -} - -#[test] -fn test_wildcard_match() { - let fixtures = vec![ - ("foobarbaz", "foobarbaz", true), - ("[WILDCARD]", "foobarbaz", true), - ("foobar", "foobarbaz", false), - ("foo[WILDCARD]baz", "foobarbaz", true), - ("foo[WILDCARD]baz", "foobazbar", false), - ("foo[WILDCARD]baz[WILDCARD]qux", "foobarbazqatqux", true), - ("foo[WILDCARD]", "foobar", true), - ("foo[WILDCARD]baz[WILDCARD]", "foobarbazqat", true), - // check with different line endings - ("foo[WILDCARD]\nbaz[WILDCARD]\n", "foobar\nbazqat\n", true), - ( - "foo[WILDCARD]\nbaz[WILDCARD]\n", - "foobar\r\nbazqat\r\n", - true, - ), - ( - "foo[WILDCARD]\r\nbaz[WILDCARD]\n", - "foobar\nbazqat\r\n", - true, - ), - ( - "foo[WILDCARD]\r\nbaz[WILDCARD]\r\n", - "foobar\nbazqat\n", - true, - ), - ( - "foo[WILDCARD]\r\nbaz[WILDCARD]\r\n", - "foobar\r\nbazqat\r\n", - true, - ), - ]; - - // Iterate through the fixture lists, testing each one - for (pattern, string, expected) in fixtures { - let actual = wildcard_match(pattern, string); - dbg!(pattern, string, expected); - assert_eq!(actual, expected); - } -} - -#[test] -fn test_pattern_match() { - assert!(pattern_match("foo[BAR]baz", "foobarbaz", "[BAR]")); - assert!(!pattern_match("foo[BAR]baz", "foobazbar", "[BAR]")); -} |