2 files changed, 77 insertions, 6 deletions

diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs
index a1e741dfd..c25dc00c6 100644
--- a/cli/tools/repl/mod.rs
+++ b/cli/tools/repl/mod.rs
@@ -12,6 +12,7 @@ use deno_core::unsync::spawn_blocking;
 use deno_runtime::permissions::Permissions;
 use deno_runtime::permissions::PermissionsContainer;
 use rustyline::error::ReadlineError;
+use tokio::sync::mpsc::unbounded_channel;
 
 pub(crate) mod cdp;
 mod channel;
@@ -28,6 +29,9 @@ pub use session::EvaluationOutput;
 pub use session::ReplSession;
 pub use session::REPL_INTERNALS_NAME;
 
+use super::test::TestEvent;
+use super::test::TestEventSender;
+
 #[allow(clippy::await_holding_refcell_ref)]
 async fn read_line_and_poll(
   repl_session: &mut ReplSession,
@@ -114,15 +118,31 @@ pub async fn run(flags: Flags, repl_flags: ReplFlags) -> Result<i32, AnyError> {
     .deno_dir()
     .ok()
     .and_then(|dir| dir.repl_history_file_path());
-
+  let (test_event_sender, test_event_receiver) =
+    unbounded_channel::<TestEvent>();
+  let test_event_sender = TestEventSender::new(test_event_sender);
   let mut worker = worker_factory
-    .create_main_worker(main_module, permissions)
+    .create_custom_worker(
+      main_module.clone(),
+      permissions,
+      vec![crate::ops::testing::deno_test::init_ops(
+        test_event_sender.clone(),
+      )],
+      Default::default(),
+    )
     .await?;
   worker.setup_repl().await?;
   let worker = worker.into_main_worker();
-  let mut repl_session =
-    ReplSession::initialize(cli_options, npm_resolver, resolver, worker)
-      .await?;
+  let mut repl_session = ReplSession::initialize(
+    cli_options,
+    npm_resolver,
+    resolver,
+    worker,
+    main_module,
+    test_event_sender,
+    test_event_receiver,
+  )
+  .await?;
   let mut rustyline_channel = rustyline_channel();
 
   let helper = EditorHelper {
diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs
index f833fbf5d..338a253d2 100644
--- a/cli/tools/repl/session.rs
+++ b/cli/tools/repl/session.rs
@@ -9,6 +9,13 @@ use crate::colors;
 use crate::lsp::ReplLanguageServer;
 use crate::npm::CliNpmResolver;
 use crate::resolver::CliGraphResolver;
+use crate::tools::test::report_tests;
+use crate::tools::test::reporters::PrettyTestReporter;
+use crate::tools::test::reporters::TestReporter;
+use crate::tools::test::run_tests_for_worker;
+use crate::tools::test::worker_has_tests;
+use crate::tools::test::TestEvent;
+use crate::tools::test::TestEventSender;
 
 use deno_ast::swc::ast as swc_ast;
 use deno_ast::swc::visit::noop_visit_type;
@@ -23,6 +30,7 @@ use deno_core::futures::FutureExt;
 use deno_core::futures::StreamExt;
 use deno_core::serde_json;
 use deno_core::serde_json::Value;
+use deno_core::unsync::spawn;
 use deno_core::LocalInspectorSession;
 use deno_graph::source::Resolver;
 use deno_runtime::worker::MainWorker;
@@ -131,6 +139,11 @@ pub struct ReplSession {
   pub language_server: ReplLanguageServer,
   pub notifications: Rc<RefCell<UnboundedReceiver<Value>>>,
   referrer: ModuleSpecifier,
+  main_module: ModuleSpecifier,
+  test_reporter_factory: Box<dyn Fn() -> Box<dyn TestReporter>>,
+  test_event_sender: TestEventSender,
+  /// This is only optional because it's temporarily taken when evaluating.
+  test_event_receiver: Option<tokio::sync::mpsc::UnboundedReceiver<TestEvent>>,
 }
 
 impl ReplSession {
@@ -139,6 +152,9 @@ impl ReplSession {
     npm_resolver: Arc<dyn CliNpmResolver>,
     resolver: Arc<CliGraphResolver>,
     mut worker: MainWorker,
+    main_module: ModuleSpecifier,
+    test_event_sender: TestEventSender,
+    test_event_receiver: tokio::sync::mpsc::UnboundedReceiver<TestEvent>,
   ) -> Result<Self, AnyError> {
     let language_server = ReplLanguageServer::new_initialized().await?;
     let mut session = worker.create_inspector_session().await;
@@ -189,6 +205,12 @@ impl ReplSession {
       language_server,
       referrer,
       notifications: Rc::new(RefCell::new(notification_rx)),
+      test_reporter_factory: Box::new(|| {
+        Box::new(PrettyTestReporter::new(false, true, false, true))
+      }),
+      main_module,
+      test_event_sender,
+      test_event_receiver: Some(test_event_receiver),
     };
 
     // inject prelude
@@ -197,6 +219,13 @@ impl ReplSession {
     Ok(repl_session)
   }
 
+  pub fn set_test_reporter_factory(
+    &mut self,
+    f: Box<dyn Fn() -> Box<dyn TestReporter>>,
+  ) {
+    self.test_reporter_factory = f;
+  }
+
   pub async fn closing(&mut self) -> Result<bool, AnyError> {
     let closed = self
       .evaluate_expression("(this.closed)")
@@ -325,7 +354,7 @@ impl ReplSession {
 
     // If that fails, we retry it without wrapping in parens letting the error bubble up to the
     // user if it is still an error.
-    if wrapped_line != line
+    let result = if wrapped_line != line
       && (evaluate_response.is_err()
         || evaluate_response
           .as_ref()
@@ -337,7 +366,29 @@ impl ReplSession {
       self.evaluate_ts_expression(line).await
     } else {
       evaluate_response
+    };
+
+    if worker_has_tests(&mut self.worker) {
+      let report_tests_handle = spawn(report_tests(
+        self.test_event_receiver.take().unwrap(),
+        (self.test_reporter_factory)(),
+      ));
+      run_tests_for_worker(
+        &mut self.worker,
+        &self.main_module,
+        &Default::default(),
+        &Default::default(),
+      )
+      .await
+      .unwrap();
+      self
+        .test_event_sender
+        .send(TestEvent::ForceEndReport)
+        .unwrap();
+      self.test_event_receiver = Some(report_tests_handle.await.unwrap().1);
     }
+
+    result
   }
 
   async fn set_last_thrown_error(