refactor: isomorphic snapshot for CLI (#3728)

1 files changed, 112 insertions, 0 deletions

diff --git a/cli/web_worker.rs b/cli/web_worker.rs
index 7b21d4937..a3f7eb685 100644
--- a/cli/web_worker.rs
+++ b/cli/web_worker.rs
@@ -35,8 +35,12 @@ impl WebWorker {
     let worker = Worker::new(name, startup_data, state_, external_channels);
     {
       let mut isolate = worker.isolate.try_lock().unwrap();
+      ops::runtime::init(&mut isolate, &state);
       ops::web_worker::init(&mut isolate, &state);
       ops::worker_host::init(&mut isolate, &state);
+      ops::errors::init(&mut isolate, &state);
+      ops::timers::init(&mut isolate, &state);
+      ops::fetch::init(&mut isolate, &state);
     }
 
     Self(worker)
@@ -64,3 +68,111 @@ impl Future for WebWorker {
     inner.0.poll_unpin(cx)
   }
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::startup_data;
+  use crate::state::ThreadSafeState;
+  use crate::tokio_util;
+  use futures::executor::block_on;
+
+  pub fn run_in_task<F>(f: F)
+  where
+    F: FnOnce() + Send + 'static,
+  {
+    let fut = futures::future::lazy(move |_cx| f());
+    tokio_util::run(fut)
+  }
+
+  fn create_test_worker() -> WebWorker {
+    let (int, ext) = ThreadSafeState::create_channels();
+    let state = ThreadSafeState::mock(
+      vec![String::from("./deno"), String::from("hello.js")],
+      int,
+    );
+    let mut worker = WebWorker::new(
+      "TEST".to_string(),
+      startup_data::deno_isolate_init(),
+      state,
+      ext,
+    );
+    worker.execute("bootstrapWorkerRuntime(\"TEST\")").unwrap();
+    worker.execute("runWorkerMessageLoop()").unwrap();
+    worker
+  }
+
+  #[test]
+  fn test_worker_messages() {
+    run_in_task(|| {
+      let mut worker = create_test_worker();
+      let source = r#"
+        onmessage = function(e) {
+          console.log("msg from main script", e.data);
+          if (e.data == "exit") {
+            delete self.onmessage;
+            return;
+          } else {
+            console.assert(e.data === "hi");
+          }
+          postMessage([1, 2, 3]);
+          console.log("after postMessage");
+        }
+        "#;
+      worker.execute(source).unwrap();
+
+      let worker_ = worker.clone();
+
+      let fut = async move {
+        let r = worker.await;
+        r.unwrap();
+      };
+
+      tokio::spawn(fut);
+
+      let msg = json!("hi").to_string().into_boxed_str().into_boxed_bytes();
+
+      let r = block_on(worker_.post_message(msg));
+      assert!(r.is_ok());
+
+      let maybe_msg = block_on(worker_.get_message());
+      assert!(maybe_msg.is_some());
+      // Check if message received is [1, 2, 3] in json
+      assert_eq!(*maybe_msg.unwrap(), *b"[1,2,3]");
+
+      let msg = json!("exit")
+        .to_string()
+        .into_boxed_str()
+        .into_boxed_bytes();
+      let r = block_on(worker_.post_message(msg));
+      assert!(r.is_ok());
+    })
+  }
+
+  #[test]
+  fn removed_from_resource_table_on_close() {
+    run_in_task(|| {
+      let mut worker = create_test_worker();
+      worker
+        .execute("onmessage = () => { delete self.onmessage; }")
+        .unwrap();
+
+      let worker_ = worker.clone();
+      let worker_future = async move {
+        let result = worker_.await;
+        println!("workers.rs after resource close");
+        result.unwrap();
+      }
+      .shared();
+
+      let worker_future_ = worker_future.clone();
+      tokio::spawn(worker_future_);
+
+      let msg = json!("hi").to_string().into_boxed_str().into_boxed_bytes();
+      let r = block_on(worker.post_message(msg));
+      assert!(r.is_ok());
+
+      block_on(worker_future)
+    })
+  }
+}