feat: deno test --filter (#4570)

cli/flags.rs

@@ -66,6 +66,7 @@ pub enum DenoSubcommand {
     fail_fast: bool,
     allow_none: bool,
     include: Option<Vec<String>>,
+    filter: Option<String>,
   },
   Types,
   Upgrade {
@@ -535,7 +536,7 @@ fn test_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
 
   let failfast = matches.is_present("failfast");
   let allow_none = matches.is_present("allow_none");
-
+  let filter = matches.value_of("filter").map(String::from);
   let include = if matches.is_present("files") {
     let files: Vec<String> = matches
       .values_of("files")
@@ -550,6 +551,7 @@ fn test_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
   flags.subcommand = DenoSubcommand::Test {
     fail_fast: failfast,
     include,
+    filter,
     allow_none,
   };
 }
@@ -564,11 +566,7 @@ fn doc_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
   reload_arg_parse(flags, matches);
   let source_file = matches.value_of("source_file").map(String::from).unwrap();
   let json = matches.is_present("json");
-  let filter = if matches.is_present("filter") {
-    Some(matches.value_of("filter").unwrap().to_string())
-  } else {
-    None
-  };
+  let filter = matches.value_of("filter").map(String::from);
   flags.subcommand = DenoSubcommand::Doc {
     source_file,
     json,
@@ -945,7 +943,6 @@ fn test_subcommand<'a, 'b>() -> App<'a, 'b> {
   run_test_args(SubCommand::with_name("test"))
     .arg(
       Arg::with_name("failfast")
-        .short("f")
         .long("failfast")
         .help("Stop on first error")
         .takes_value(false),
@@ -956,6 +953,12 @@ fn test_subcommand<'a, 'b>() -> App<'a, 'b> {
         .help("Don't return error code if no test files are found")
         .takes_value(false),
     )
+    .arg(
+      Arg::with_name("filter")
+        .long("filter")
+        .takes_value(true)
+        .help("A pattern to filter the tests to run by"),
+    )
     .arg(
       Arg::with_name("files")
         .help("List of file names to run")
@@ -2271,6 +2274,7 @@ mod tests {
       Flags {
         subcommand: DenoSubcommand::Test {
           fail_fast: false,
+          filter: None,
           allow_none: true,
           include: Some(svec!["dir1/", "dir2/"]),
         },
@@ -2280,283 +2284,301 @@ mod tests {
       }
     );
   }
-}
 
-#[test]
-fn run_with_cafile() {
-  let r = flags_from_vec_safe(svec![
-    "deno",
-    "run",
-    "--cert",
-    "example.crt",
-    "script.ts"
-  ]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Run {
-        script: "script.ts".to_string(),
-      },
-      ca_file: Some("example.crt".to_owned()),
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn test_filter() {
+    let r = flags_from_vec_safe(svec!["deno", "test", "--filter=foo", "dir1"]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Test {
+          fail_fast: false,
+          allow_none: false,
+          filter: Some("foo".to_string()),
+          include: Some(svec!["dir1"]),
+        },
+        allow_read: true,
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn bundle_with_cafile() {
-  let r = flags_from_vec_safe(svec![
-    "deno",
-    "bundle",
-    "--cert",
-    "example.crt",
-    "source.ts"
-  ]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Bundle {
-        source_file: "source.ts".to_string(),
-        out_file: None,
-      },
-      ca_file: Some("example.crt".to_owned()),
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn run_with_cafile() {
+    let r = flags_from_vec_safe(svec![
+      "deno",
+      "run",
+      "--cert",
+      "example.crt",
+      "script.ts"
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Run {
+          script: "script.ts".to_string(),
+        },
+        ca_file: Some("example.crt".to_owned()),
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn eval_with_cafile() {
-  let r = flags_from_vec_safe(svec![
-    "deno",
-    "eval",
-    "--cert",
-    "example.crt",
-    "console.log('hello world')"
-  ]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Eval {
-        code: "console.log('hello world')".to_string(),
-        as_typescript: false,
-      },
-      ca_file: Some("example.crt".to_owned()),
-      allow_net: true,
-      allow_env: true,
-      allow_run: true,
-      allow_read: true,
-      allow_write: true,
-      allow_plugin: true,
-      allow_hrtime: true,
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn bundle_with_cafile() {
+    let r = flags_from_vec_safe(svec![
+      "deno",
+      "bundle",
+      "--cert",
+      "example.crt",
+      "source.ts"
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Bundle {
+          source_file: "source.ts".to_string(),
+          out_file: None,
+        },
+        ca_file: Some("example.crt".to_owned()),
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn eval_with_inspect() {
-  let r = flags_from_vec_safe(svec![
-    "deno",
-    "eval",
-    "--inspect",
-    "const foo = 'bar'"
-  ]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Eval {
-        code: "const foo = 'bar'".to_string(),
-        as_typescript: false,
-      },
-      inspect: Some("127.0.0.1:9229".to_string()),
-      allow_net: true,
-      allow_env: true,
-      allow_run: true,
-      allow_read: true,
-      allow_write: true,
-      allow_plugin: true,
-      allow_hrtime: true,
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn eval_with_cafile() {
+    let r = flags_from_vec_safe(svec![
+      "deno",
+      "eval",
+      "--cert",
+      "example.crt",
+      "console.log('hello world')"
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Eval {
+          code: "console.log('hello world')".to_string(),
+          as_typescript: false,
+        },
+        ca_file: Some("example.crt".to_owned()),
+        allow_net: true,
+        allow_env: true,
+        allow_run: true,
+        allow_read: true,
+        allow_write: true,
+        allow_plugin: true,
+        allow_hrtime: true,
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn fetch_with_cafile() {
-  let r = flags_from_vec_safe(svec![
-    "deno",
-    "fetch",
-    "--cert",
-    "example.crt",
-    "script.ts",
-    "script_two.ts"
-  ]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Fetch {
-        files: svec!["script.ts", "script_two.ts"],
-      },
-      ca_file: Some("example.crt".to_owned()),
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn eval_with_inspect() {
+    let r = flags_from_vec_safe(svec![
+      "deno",
+      "eval",
+      "--inspect",
+      "const foo = 'bar'"
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Eval {
+          code: "const foo = 'bar'".to_string(),
+          as_typescript: false,
+        },
+        inspect: Some("127.0.0.1:9229".to_string()),
+        allow_net: true,
+        allow_env: true,
+        allow_run: true,
+        allow_read: true,
+        allow_write: true,
+        allow_plugin: true,
+        allow_hrtime: true,
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn info_with_cafile() {
-  let r = flags_from_vec_safe(svec![
-    "deno",
-    "info",
-    "--cert",
-    "example.crt",
-    "https://example.com"
-  ]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Info {
-        file: Some("https://example.com".to_string()),
-      },
-      ca_file: Some("example.crt".to_owned()),
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn fetch_with_cafile() {
+    let r = flags_from_vec_safe(svec![
+      "deno",
+      "fetch",
+      "--cert",
+      "example.crt",
+      "script.ts",
+      "script_two.ts"
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Fetch {
+          files: svec!["script.ts", "script_two.ts"],
+        },
+        ca_file: Some("example.crt".to_owned()),
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn install_with_cafile() {
-  let r = flags_from_vec_safe(svec![
-    "deno",
-    "install",
-    "--cert",
-    "example.crt",
-    "deno_colors",
-    "https://deno.land/std/examples/colors.ts"
-  ]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Install {
-        dir: None,
-        exe_name: "deno_colors".to_string(),
-        module_url: "https://deno.land/std/examples/colors.ts".to_string(),
-        args: vec![],
-        force: false,
-      },
-      ca_file: Some("example.crt".to_owned()),
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn info_with_cafile() {
+    let r = flags_from_vec_safe(svec![
+      "deno",
+      "info",
+      "--cert",
+      "example.crt",
+      "https://example.com"
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Info {
+          file: Some("https://example.com".to_string()),
+        },
+        ca_file: Some("example.crt".to_owned()),
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn repl_with_cafile() {
-  let r = flags_from_vec_safe(svec!["deno", "repl", "--cert", "example.crt"]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Repl {},
-      ca_file: Some("example.crt".to_owned()),
-      allow_read: true,
-      allow_write: true,
-      allow_net: true,
-      allow_env: true,
-      allow_run: true,
-      allow_plugin: true,
-      allow_hrtime: true,
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn install_with_cafile() {
+    let r = flags_from_vec_safe(svec![
+      "deno",
+      "install",
+      "--cert",
+      "example.crt",
+      "deno_colors",
+      "https://deno.land/std/examples/colors.ts"
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Install {
+          dir: None,
+          exe_name: "deno_colors".to_string(),
+          module_url: "https://deno.land/std/examples/colors.ts".to_string(),
+          args: vec![],
+          force: false,
+        },
+        ca_file: Some("example.crt".to_owned()),
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn repl_with_inspect() {
-  let r = flags_from_vec_safe(svec!["deno", "repl", "--inspect"]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Repl {},
-      inspect: Some("127.0.0.1:9229".to_string()),
-      allow_read: true,
-      allow_write: true,
-      allow_net: true,
-      allow_env: true,
-      allow_run: true,
-      allow_plugin: true,
-      allow_hrtime: true,
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn repl_with_cafile() {
+    let r = flags_from_vec_safe(svec!["deno", "repl", "--cert", "example.crt"]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Repl {},
+        ca_file: Some("example.crt".to_owned()),
+        allow_read: true,
+        allow_write: true,
+        allow_net: true,
+        allow_env: true,
+        allow_run: true,
+        allow_plugin: true,
+        allow_hrtime: true,
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn doc() {
-  let r =
-    flags_from_vec_safe(svec!["deno", "doc", "--json", "path/to/module.ts"]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Doc {
-        json: true,
-        source_file: "path/to/module.ts".to_string(),
-        filter: None,
-      },
-      ..Flags::default()
-    }
-  );
+  #[test]
+  fn repl_with_inspect() {
+    let r = flags_from_vec_safe(svec!["deno", "repl", "--inspect"]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Repl {},
+        inspect: Some("127.0.0.1:9229".to_string()),
+        allow_read: true,
+        allow_write: true,
+        allow_net: true,
+        allow_env: true,
+        allow_run: true,
+        allow_plugin: true,
+        allow_hrtime: true,
+        ..Flags::default()
+      }
+    );
+  }
 
-  let r = flags_from_vec_safe(svec![
-    "deno",
-    "doc",
-    "path/to/module.ts",
-    "SomeClass.someField"
-  ]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Doc {
-        json: false,
-        source_file: "path/to/module.ts".to_string(),
-        filter: Some("SomeClass.someField".to_string()),
-      },
-      ..Flags::default()
-    }
-  );
-}
+  #[test]
+  fn doc() {
+    let r =
+      flags_from_vec_safe(svec!["deno", "doc", "--json", "path/to/module.ts"]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Doc {
+          json: true,
+          source_file: "path/to/module.ts".to_string(),
+          filter: None,
+        },
+        ..Flags::default()
+      }
+    );
 
-#[test]
-fn inspect_default_host() {
-  let r = flags_from_vec_safe(svec!["deno", "run", "--inspect", "foo.js"]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Run {
-        script: "foo.js".to_string(),
-      },
-      inspect: Some("127.0.0.1:9229".to_string()),
-      ..Flags::default()
-    }
-  );
-}
+    let r = flags_from_vec_safe(svec![
+      "deno",
+      "doc",
+      "path/to/module.ts",
+      "SomeClass.someField"
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Doc {
+          json: false,
+          source_file: "path/to/module.ts".to_string(),
+          filter: Some("SomeClass.someField".to_string()),
+        },
+        ..Flags::default()
+      }
+    );
+  }
 
-#[test]
-fn inspect_custom_host() {
-  let r = flags_from_vec_safe(svec![
-    "deno",
-    "run",
-    "--inspect=deno.land:80",
-    "foo.js"
-  ]);
-  assert_eq!(
-    r.unwrap(),
-    Flags {
-      subcommand: DenoSubcommand::Run {
-        script: "foo.js".to_string(),
-      },
-      inspect: Some("deno.land:80".to_string()),
-      ..Flags::default()
-    }
-  );
+  #[test]
+  fn inspect_default_host() {
+    let r = flags_from_vec_safe(svec!["deno", "run", "--inspect", "foo.js"]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Run {
+          script: "foo.js".to_string(),
+        },
+        inspect: Some("127.0.0.1:9229".to_string()),
+        ..Flags::default()
+      }
+    );
+  }
+
+  #[test]
+  fn inspect_custom_host() {
+    let r = flags_from_vec_safe(svec![
+      "deno",
+      "run",
+      "--inspect=deno.land:80",
+      "foo.js"
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Run {
+          script: "foo.js".to_string(),
+        },
+        inspect: Some("deno.land:80".to_string()),
+        ..Flags::default()
+      }
+    );
+  }
 }

cli/js/lib.deno.ns.d.ts

@@ -120,7 +120,7 @@ declare namespace Deno {
     failFast?: boolean;
     /** String or RegExp used to filter test to run. Only test with names
      * matching provided `String` or `RegExp` will be run. */
-    only?: string | RegExp;
+    filter?: string | RegExp;
     /** String or RegExp used to skip tests to run. Tests with names
      * matching provided `String` or `RegExp` will not be run. */
     skip?: string | RegExp;

cli/js/testing.ts

@@ -270,17 +270,17 @@ class TestApi {
 }
 
 function createFilterFn(
-  only: undefined | string | RegExp,
+  filter: undefined | string | RegExp,
   skip: undefined | string | RegExp
 ): (def: TestDefinition) => boolean {
   return (def: TestDefinition): boolean => {
     let passes = true;
 
-    if (only) {
-      if (only instanceof RegExp) {
-        passes = passes && only.test(def.name);
+    if (filter) {
+      if (filter instanceof RegExp) {
+        passes = passes && filter.test(def.name);
       } else {
-        passes = passes && def.name.includes(only);
+        passes = passes && def.name.includes(filter);
       }
     }
 
@@ -299,7 +299,7 @@ function createFilterFn(
 export interface RunTestsOptions {
   exitOnFail?: boolean;
   failFast?: boolean;
-  only?: string | RegExp;
+  filter?: string | RegExp;
   skip?: string | RegExp;
   disableLog?: boolean;
   reportToConsole?: boolean;
@@ -309,13 +309,13 @@ export interface RunTestsOptions {
 export async function runTests({
   exitOnFail = true,
   failFast = false,
-  only = undefined,
+  filter = undefined,
   skip = undefined,
   disableLog = false,
   reportToConsole: reportToConsole_ = true,
   onMessage = undefined,
 }: RunTestsOptions = {}): Promise<TestMessage["end"] & {}> {
-  const filterFn = createFilterFn(only, skip);
+  const filterFn = createFilterFn(filter, skip);
   const testApi = new TestApi(TEST_REGISTRY, filterFn, failFast);
 
   // @ts-ignore

cli/js/tests/unit_test_runner.ts

@@ -68,7 +68,7 @@ async function workerRunnerMain(
   // Execute tests
   await Deno.runTests({
     exitOnFail: false,
-    only: filter,
+    filter,
     reportToConsole: false,
     onMessage: reportToConn.bind(null, conn),
   });
@@ -296,7 +296,7 @@ async function main(): Promise<void> {
 
   // Running tests matching current process permissions
   await registerUnitTests();
-  await Deno.runTests({ only: filter });
+  await Deno.runTests({ filter });
 }
 
 main();

cli/lib.rs

@@ -445,6 +445,7 @@ async fn test_command(
   include: Option<Vec<String>>,
   fail_fast: bool,
   allow_none: bool,
+  filter: Option<String>,
 ) -> Result<(), ErrBox> {
   let global_state = GlobalState::new(flags.clone())?;
   let cwd = std::env::current_dir().expect("No current directory");
@@ -462,7 +463,8 @@ async fn test_command(
   let test_file_path = cwd.join(".deno.test.ts");
   let test_file_url =
     Url::from_file_path(&test_file_path).expect("Should be valid file url");
-  let test_file = test_runner::render_test_file(test_modules, fail_fast);
+  let test_file =
+    test_runner::render_test_file(test_modules, fail_fast, filter);
   let main_module =
     ModuleSpecifier::resolve_url(&test_file_url.to_string()).unwrap();
   let mut worker =
@@ -545,7 +547,10 @@ pub fn main() {
       fail_fast,
       include,
       allow_none,
-    } => test_command(flags, include, fail_fast, allow_none).boxed_local(),
+      filter,
+    } => {
+      test_command(flags, include, fail_fast, allow_none, filter).boxed_local()
+    }
     DenoSubcommand::Completions { buf } => {
       if let Err(e) = write_to_stdout_ignore_sigpipe(&buf) {
         eprintln!("{}", e);

cli/test_runner.rs

@@ -61,15 +61,24 @@ pub fn prepare_test_modules_urls(
   Ok(prepared)
 }
 
-pub fn render_test_file(modules: Vec<Url>, fail_fast: bool) -> String {
+pub fn render_test_file(
+  modules: Vec<Url>,
+  fail_fast: bool,
+  filter: Option<String>,
+) -> String {
   let mut test_file = "".to_string();
 
   for module in modules {
     test_file.push_str(&format!("import \"{}\";\n", module.to_string()));
   }
 
-  let run_tests_cmd =
-    format!("Deno.runTests({{ failFast: {} }});\n", fail_fast);
+  let options = if let Some(filter) = filter {
+    json!({ "failFast": fail_fast, "filter": filter })
+  } else {
+    json!({ "failFast": fail_fast })
+  };
+
+  let run_tests_cmd = format!("Deno.runTests({});\n", options);
   test_file.push_str(&run_tests_cmd);
 
   test_file