added test for JsExternal

Author: alshdavid

examples/src/background_tasks/background_tasks.test.ts

@@ -0,0 +1,11 @@
+import { executeExample } from '../../test-utils/run_test.ts'
+import { assertEquals } from "jsr:@std/assert@^1"
+
+Deno.test("background_tasks", async () => {
+    const result = await executeExample("background_tasks")
+    assertEquals(result, [
+        `Task [rs]: Started`,
+        `Task [js]: Message`,
+        `Task [rs]: Ended`,
+    ].join('\n'))
+});

examples/src/background_tasks/mod.rs

@@ -25,34 +25,34 @@ pub fn main() -> anyhow::Result<()> {
     let ctx = worker.create_context()?;
 
     // Execute some JavaScript in the context
-    ctx.exec(|env| {
+    ctx.exec_blocking(|env| {
+        // Tell the runtime that it must remain alive
+        // Safety: This must be manually incremented and decremented
+        //         if the ref count is greater than 0, the runtime
+        //         will remain alive until it's 0
         env.inc_ref();
 
         env.spawn_background({
             let env = env.as_async();
             async move {
-                println!("Background Task Started");
+                println!("Task [rs]: Started");
                 tokio::time::sleep(Duration::from_secs(1)).await;
-                println!("Background Task Ended");
 
                 env.exec_async(|env| {
-                    println!("hi");
+                    println!("Task [js]: Message");
+                    // Tell the runtime that this task will no longer require keeping it alive
                     env.dec_ref();
                     Ok(())
                 })
                 .await?;
+
+                println!("Task [rs]: Ended");
                 Ok(())
             }
         })?;
 
         Ok(())
     })?;
 
-    println!("Context Dropping");
-    drop(ctx);
-    drop(worker);
-
-    println!("Context Dropped");
-
     Ok(())
 }

examples/src/external_value/external_value.test.ts

@@ -0,0 +1,7 @@
+import { executeExample } from '../../test-utils/run_test.ts'
+import { assertEquals } from "jsr:@std/assert@^1"
+
+Deno.test("external_value", async () => {
+    const result = await executeExample("external_value")
+    assertEquals(result, "42")
+});

examples/src/external_value/mod.rs

@@ -0,0 +1,44 @@
+use ion::*;
+
+pub fn main() -> anyhow::Result<()> {
+    let runtime = JsRuntime::initialize_once(JsRuntimeOptions {
+        extensions: vec![
+            ion::extensions::console(),
+            ion::extensions::set_interval(),
+            ion::extensions::set_timeout(),
+        ],
+        transformers: vec![
+            ion::transformers::json(),
+            ion::transformers::ts(),
+            ion::transformers::tsx(),
+        ],
+        ..Default::default()
+    })?;
+
+    let worker = runtime.spawn_worker(JsWorkerOptions::default())?;
+    let ctx = worker.create_context()?;
+
+    // Set External Value
+    ctx.exec_blocking(|env| {
+        let external = 42;
+        let external_js = JsExternal::new(env, external)?;
+        env.global_this()?
+            .set_named_property("external", external_js)?;
+        Ok(())
+    })?;
+
+    // Use External Value
+    ctx.exec_blocking(|env| {
+        let Some(external_js) = env
+            .global_this()?
+            .get_named_property::<JsExternal<i32>>("external")?
+        else {
+            panic!("Could not revive external")
+        };
+        let external = external_js.as_inner()?;
+        println!("{}", external);
+        Ok(())
+    })?;
+
+    Ok(())
+}

examples/src/main.rs

@@ -7,6 +7,7 @@ mod custom_extension;
 mod custom_resolver;
 mod deferred;
 mod eval;
+mod external_value;
 mod http_server;
 mod memory_usage_context;
 mod memory_usage_module;
@@ -53,6 +54,7 @@ fn main() -> anyhow::Result<()> {
         "memory_usage_worker" => memory_usage_worker::main(),
         "memory_usage_module" => memory_usage_module::main(),
         "memory_usage_value" => memory_usage_value::main(),
+        "external_value" => external_value::main(),
         _ => Err(anyhow::anyhow!("No example for: \"{}\"", example)),
     }
 }