test: add integration tests for task executor

Tests cover:
- Basic task with payload
- Task without payload
- Error handling (thrown exceptions)
- ES modules style handler
- Return value (vs respondWith)
- Async task handlers
- waitUntil behavior

Update runtime-v8 to v0.9.1

Author: max-lt

Cargo.lock

@@ -14,7 +14,7 @@ v8 = ["dep:openworkers-runtime-v8"]
 openworkers-core = { git = "https://github.com/openworkers/openworkers-core", tag = "v0.9.0" }
 
 # Runtime backend (V8)
-openworkers-runtime-v8 = { git = "https://github.com/openworkers/openworkers-runtime-v8", tag = "v0.9.0", optional = true }
+openworkers-runtime-v8 = { git = "https://github.com/openworkers/openworkers-runtime-v8", tag = "v0.9.1", optional = true }
 
 # Async runtime
 tokio = { version = "1.49.0", features = ["full"] }

Cargo.toml

@@ -0,0 +1,10 @@
+// Async task handler
+addEventListener('task', async (event) => {
+    // Simulate async work
+    await new Promise(resolve => setTimeout(resolve, 10));
+
+    event.respondWith({
+        success: true,
+        data: { async: true }
+    });
+});

tests/fixtures/async_task.js

@@ -0,0 +1,10 @@
+// Basic task handler
+addEventListener('task', (event) => {
+    event.respondWith({
+        success: true,
+        data: {
+            taskId: event.taskId,
+            received: event.payload
+        }
+    });
+});

tests/fixtures/basic_task.js

@@ -0,0 +1,4 @@
+// Task that throws an error
+addEventListener('task', (event) => {
+    throw new Error('Intentional test error');
+});

tests/fixtures/error_task.js

@@ -0,0 +1,13 @@
+// ES modules style task handler
+// (transpiled from: export default { task(event, env, ctx) { ... } })
+globalThis.default = {
+    task(event, env, ctx) {
+        return {
+            success: true,
+            data: {
+                style: 'es-modules',
+                taskId: event.taskId
+            }
+        };
+    }
+};

tests/fixtures/es_modules_task.js

@@ -0,0 +1,10 @@
+// Task using return instead of respondWith
+addEventListener('task', (event) => {
+    return {
+        success: true,
+        data: {
+            method: 'return',
+            payload: event.payload
+        }
+    };
+});

tests/fixtures/return_task.js

@@ -0,0 +1,18 @@
+// Task with waitUntil
+globalThis.backgroundDone = false;
+
+addEventListener('task', (event) => {
+    // Respond immediately
+    event.respondWith({
+        success: true,
+        data: { immediate: true }
+    });
+
+    // Background work via waitUntil
+    event.waitUntil(new Promise(resolve => {
+        setTimeout(() => {
+            globalThis.backgroundDone = true;
+            resolve();
+        }, 20);
+    }));
+});

tests/fixtures/wait_until_task.js

@@ -0,0 +1,137 @@
+//! Integration tests for the task executor
+
+use openworkers_core::{Event, RuntimeLimits, Script, TaskSource, WorkerCode};
+use openworkers_task_executor::MinimalOps;
+use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::task::LocalSet;
+
+fn fixtures_path() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures")
+}
+
+async fn run_task_file(
+    filename: &str,
+    payload: Option<serde_json::Value>,
+) -> openworkers_core::TaskResult {
+    let script_path = fixtures_path().join(filename);
+    let script_content = std::fs::read_to_string(&script_path)
+        .unwrap_or_else(|_| panic!("Failed to read {}", filename));
+
+    let script = Script {
+        code: WorkerCode::JavaScript(script_content),
+        env: None,
+        bindings: vec![],
+    };
+
+    let ops: openworkers_core::OperationsHandle = Arc::new(MinimalOps::silent());
+
+    let limits = RuntimeLimits {
+        max_wall_clock_time_ms: 5000,
+        max_cpu_time_ms: 5000,
+        ..Default::default()
+    };
+
+    let task_id = format!("test-{}", uuid::Uuid::new_v4());
+    let source = TaskSource::Invoke {
+        origin: Some("test".to_string()),
+    };
+
+    let (event, rx) = Event::task(task_id, payload, Some(source), 1);
+
+    let local = LocalSet::new();
+
+    local
+        .run_until(async move {
+            use openworkers_runtime_v8::Worker;
+
+            let mut worker = Worker::new_with_ops(script, Some(limits), ops)
+                .await
+                .expect("Failed to create worker");
+
+            worker.exec(event).await.expect("Failed to execute task");
+
+            rx.await.expect("Failed to receive result")
+        })
+        .await
+}
+
+#[tokio::test]
+async fn test_basic_task() {
+    let payload = serde_json::json!({ "name": "test", "value": 42 });
+    let result = run_task_file("basic_task.js", Some(payload.clone())).await;
+
+    assert!(result.success, "Task should succeed");
+
+    let data = result.data.expect("Should have data");
+    assert_eq!(data["received"], payload);
+}
+
+#[tokio::test]
+async fn test_basic_task_no_payload() {
+    let result = run_task_file("basic_task.js", None).await;
+
+    assert!(result.success, "Task should succeed");
+
+    let data = result.data.expect("Should have data");
+    assert!(data["received"].is_null(), "Payload should be null");
+}
+
+#[tokio::test]
+async fn test_error_task() {
+    let result = run_task_file("error_task.js", None).await;
+
+    assert!(!result.success, "Task should fail");
+    assert!(
+        result
+            .error
+            .as_ref()
+            .unwrap()
+            .contains("Intentional test error"),
+        "Error message should contain 'Intentional test error', got: {:?}",
+        result.error
+    );
+}
+
+#[tokio::test]
+async fn test_es_modules_task() {
+    let result = run_task_file("es_modules_task.js", None).await;
+
+    assert!(result.success, "Task should succeed");
+
+    let data = result.data.expect("Should have data");
+    assert_eq!(data["style"], "es-modules");
+}
+
+#[tokio::test]
+async fn test_return_task() {
+    let payload = serde_json::json!({ "test": true });
+    let result = run_task_file("return_task.js", Some(payload.clone())).await;
+
+    assert!(result.success, "Task should succeed");
+
+    let data = result.data.expect("Should have data");
+    assert_eq!(data["method"], "return");
+    assert_eq!(data["payload"], payload);
+}
+
+#[tokio::test]
+async fn test_async_task() {
+    let result = run_task_file("async_task.js", None).await;
+
+    assert!(result.success, "Task should succeed");
+
+    let data = result.data.expect("Should have data");
+    assert_eq!(data["async"], true);
+}
+
+#[tokio::test]
+async fn test_wait_until_task() {
+    let result = run_task_file("wait_until_task.js", None).await;
+
+    assert!(result.success, "Task should succeed");
+
+    let data = result.data.expect("Should have data");
+    assert_eq!(data["immediate"], true);
+    // Note: waitUntil should complete before the worker returns
+}