folk-runtime-embed 0.1.11

Embedded PHP runtime for Folk — PHP interpreter runs in-process via FFI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Integration tests for the EmbedRuntime worker thread pool.
//!
//! Tests verify:
//! - Workers boot and send control.ready
//! - Task dispatch works (echo via fallback)
//! - Worker termination is clean
//! - Multiple workers can run concurrently
//!
//! IMPORTANT: These tests require PHP with embed SAPI (--enable-embed).
//! They will fail on systems without libphp.

use folk_core::runtime::{Runtime, WorkerHandle};
use folk_protocol::RpcMessage;
use folk_runtime_embed::{EmbedConfig, EmbedRuntime};
use rmpv::Value;

fn make_runtime(script: Option<&str>) -> EmbedRuntime {
    EmbedRuntime::new(EmbedConfig {
        script: script.map(String::from),
    })
    .expect("failed to init embed runtime")
}

#[tokio::test]
async fn worker_boots_and_sends_ready() {
    let runtime = make_runtime(None);
    let mut handle = runtime.spawn().await.expect("spawn failed");

    let msg = handle
        .recv_control()
        .await
        .expect("recv_control failed")
        .expect("expected control.ready");

    match &msg {
        RpcMessage::Notify { method, .. } => {
            assert_eq!(method, "control.ready");
        },
        _ => panic!("expected Notify, got {msg:?}"),
    }

    handle.terminate().await.expect("terminate failed");
}

#[tokio::test]
async fn worker_echo_dispatch() {
    let runtime = make_runtime(None);
    let mut handle = runtime.spawn().await.expect("spawn failed");

    // Wait for ready
    let _ = handle.recv_control().await.unwrap().unwrap();

    // Send a request — without folk_embed_dispatch defined, worker echoes params
    let params = Value::Map(vec![(
        Value::String("key".into()),
        Value::String("value".into()),
    )]);
    let request = RpcMessage::request(1, "test.echo", params.clone());
    handle.send_task(request).await.expect("send failed");

    let response = handle
        .recv_task()
        .await
        .expect("recv failed")
        .expect("expected response");

    match response {
        RpcMessage::Response {
            msgid,
            error,
            result,
        } => {
            assert_eq!(msgid, 1);
            assert!(error.is_nil(), "unexpected error: {error:?}");
            assert_eq!(result, params);
        },
        _ => panic!("expected Response, got {response:?}"),
    }

    handle.terminate().await.expect("terminate failed");
}

#[tokio::test]
async fn multiple_workers_concurrent() {
    let runtime = make_runtime(None);

    let mut handles: Vec<Box<dyn WorkerHandle>> = Vec::new();
    for _ in 0..4 {
        let mut h = runtime.spawn().await.expect("spawn failed");
        let _ = h.recv_control().await.unwrap().unwrap();
        handles.push(h);
    }

    // Send requests to all workers
    for (i, h) in handles.iter_mut().enumerate() {
        let request = RpcMessage::request(
            i as u32 + 1,
            "test",
            Value::String(format!("worker-{i}").into()),
        );
        h.send_task(request).await.expect("send failed");
    }

    // Receive responses
    for (i, h) in handles.iter_mut().enumerate() {
        let resp = h.recv_task().await.unwrap().unwrap();
        match resp {
            RpcMessage::Response { msgid, .. } => {
                assert_eq!(msgid, i as u32 + 1);
            },
            _ => panic!("expected Response"),
        }
    }

    // Clean termination
    for h in &mut handles {
        h.terminate().await.expect("terminate failed");
    }
}

#[tokio::test]
async fn worker_handles_multiple_requests() {
    let runtime = make_runtime(None);
    let mut handle = runtime.spawn().await.expect("spawn failed");
    let _ = handle.recv_control().await.unwrap().unwrap();

    for i in 0..100 {
        let request = RpcMessage::request(i, "test", Value::Integer(i.into()));
        handle.send_task(request).await.expect("send failed");

        let resp = handle.recv_task().await.unwrap().unwrap();
        match resp {
            RpcMessage::Response { msgid, .. } => assert_eq!(msgid, i),
            _ => panic!("expected Response"),
        }
    }

    handle.terminate().await.expect("terminate failed");
}