108 lines
3.2 KiB
Rust
108 lines
3.2 KiB
Rust
use makepad_script_std::makepad_network::{
|
|
EventSink, HttpRequest, HttpResponse, NetworkBackend, NetworkResponse, NetworkRuntime, WsSend,
|
|
};
|
|
use makepad_script_std::makepad_script::{makepad_live_id::LiveId, script, ScriptArrayStorage, *};
|
|
use makepad_script_std::{pump_network_runtime, script_mod, with_vm, ScriptStd};
|
|
use std::collections::BTreeMap;
|
|
use std::sync::Arc;
|
|
|
|
struct TestBackend;
|
|
|
|
impl NetworkBackend for TestBackend {
|
|
fn http_start(
|
|
&self,
|
|
request_id: LiveId,
|
|
_request: HttpRequest,
|
|
sink: EventSink,
|
|
) -> Result<(), makepad_script_std::makepad_network::NetworkError> {
|
|
let response = HttpResponse::new(LiveId(42), 200, BTreeMap::new(), Some(b"ok".to_vec()));
|
|
sink.emit(NetworkResponse::HttpResponse {
|
|
request_id,
|
|
response,
|
|
})
|
|
}
|
|
|
|
fn http_cancel(
|
|
&self,
|
|
_request_id: LiveId,
|
|
) -> Result<(), makepad_script_std::makepad_network::NetworkError> {
|
|
Ok(())
|
|
}
|
|
|
|
fn ws_open(
|
|
&self,
|
|
_socket_id: LiveId,
|
|
_request: HttpRequest,
|
|
_sink: EventSink,
|
|
) -> Result<(), makepad_script_std::makepad_network::NetworkError> {
|
|
Ok(())
|
|
}
|
|
|
|
fn ws_send(
|
|
&self,
|
|
_socket_id: LiveId,
|
|
_message: WsSend,
|
|
) -> Result<(), makepad_script_std::makepad_network::NetworkError> {
|
|
Ok(())
|
|
}
|
|
|
|
fn ws_close(
|
|
&self,
|
|
_socket_id: LiveId,
|
|
) -> Result<(), makepad_script_std::makepad_network::NetworkError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn headless_http_request_resolves_promise_through_script_std() {
|
|
let runtime = Arc::new(NetworkRuntime::with_backend(Arc::new(TestBackend)));
|
|
let mut host = ();
|
|
let mut std = ScriptStd::with_network_runtime(runtime);
|
|
let mut script_vm = Some(Box::new(ScriptVmBase::new()));
|
|
|
|
let promise = with_vm(&mut host, &mut std, &mut script_vm, |vm| {
|
|
script_mod(vm);
|
|
vm.eval(script! {
|
|
use mod.std
|
|
use mod.net
|
|
let p = std.promise()
|
|
let req = net.HttpRequest{
|
|
url: "https://example.com"
|
|
method: net.HttpMethod.GET
|
|
}
|
|
net.http_request(req) do net.HttpEvents{
|
|
on_response: |res| p.resolve(res.status_code)
|
|
on_error: |_err| p.resolve(-1)
|
|
}
|
|
p
|
|
})
|
|
});
|
|
|
|
let promise = promise
|
|
.as_handle()
|
|
.expect("script should return a promise handle");
|
|
assert_eq!(std.data.http_requests.len(), 1);
|
|
|
|
let responses = pump_network_runtime(&mut host, &mut std, &mut script_vm);
|
|
assert_eq!(responses.len(), 1);
|
|
assert!(std.data.http_requests.is_empty());
|
|
|
|
let tasks = std.data.tasks.tasks.borrow();
|
|
let task = tasks
|
|
.iter()
|
|
.find(|task| task.handle == promise)
|
|
.expect("promise task should exist");
|
|
match script_vm
|
|
.as_ref()
|
|
.unwrap()
|
|
.heap
|
|
.array_storage(task.queue.as_array())
|
|
{
|
|
ScriptArrayStorage::ScriptValue(values) => {
|
|
assert_eq!(values.len(), 1);
|
|
assert_eq!(values[0].as_f64(), Some(200.0));
|
|
}
|
|
_ => panic!("unexpected promise queue storage kind"),
|
|
}
|
|
}
|