101 lines
3.2 KiB
Rust
101 lines
3.2 KiB
Rust
use std::io::{BufRead, BufReader, Write};
|
|
use std::net::{Shutdown, SocketAddr, TcpStream};
|
|
use std::process::{Child, Command as ProcessCommand, Stdio};
|
|
use std::time::Duration;
|
|
|
|
use runa_client::LocalClient;
|
|
use runa_protocol::{Command, MessageDto, PROTOCOL_VERSION, Reply, Request, Response};
|
|
|
|
struct ServerProcess(Child);
|
|
|
|
impl Drop for ServerProcess {
|
|
fn drop(&mut self) {
|
|
let _ = self.0.kill();
|
|
let _ = self.0.wait();
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn local_client_launches_server_and_operates_the_same_live_image() {
|
|
let mut client = LocalClient::spawn(env!("CARGO_BIN_EXE_runa-server"), &[] as &[&str]).unwrap();
|
|
|
|
let published = client
|
|
.request(Command::PublishBehavior {
|
|
name: "counter".to_owned(),
|
|
expected_revision: None,
|
|
source: "pub fn handle(state, kind, value) { (state + value, []) }".to_owned(),
|
|
})
|
|
.unwrap();
|
|
assert_eq!(published.request_id, "runa-client-1");
|
|
assert!(matches!(published.result, Ok(Reply::Behavior(_))));
|
|
|
|
let spawned = client
|
|
.request(Command::Spawn {
|
|
behavior_name: "counter".to_owned(),
|
|
state: 5,
|
|
mailbox_capacity: 2,
|
|
})
|
|
.unwrap();
|
|
assert_eq!(spawned.request_id, "runa-client-2");
|
|
assert_eq!(spawned.result, Ok(Reply::ActorSpawned { actor_id: 1 }));
|
|
|
|
client
|
|
.request(Command::Send {
|
|
actor_id: 1,
|
|
message: MessageDto { kind: 0, value: 7 },
|
|
})
|
|
.unwrap();
|
|
client
|
|
.request(Command::Tick {
|
|
ticks: 100,
|
|
instruction_budget: 10,
|
|
})
|
|
.unwrap();
|
|
let inspected = client
|
|
.request(Command::InspectActor { actor_id: 1 })
|
|
.unwrap();
|
|
assert!(matches!(
|
|
inspected.result,
|
|
Ok(Reply::Actor(actor)) if actor.state == 12
|
|
));
|
|
assert!(client.shutdown().unwrap().success());
|
|
}
|
|
|
|
#[test]
|
|
fn tcp_server_accepts_local_protocol_requests() {
|
|
let child = ProcessCommand::new(env!("CARGO_BIN_EXE_runa-server"))
|
|
.args(["--listen", "127.0.0.1:0"])
|
|
.stdout(Stdio::null())
|
|
.stderr(Stdio::piped())
|
|
.spawn()
|
|
.unwrap();
|
|
let mut server = ServerProcess(child);
|
|
let stderr = server.0.stderr.take().unwrap();
|
|
let mut stderr = BufReader::new(stderr);
|
|
let mut startup = String::new();
|
|
stderr.read_line(&mut startup).unwrap();
|
|
let address = startup
|
|
.strip_prefix("runa-server: listening on ")
|
|
.expect("server should report its bound address")
|
|
.trim()
|
|
.parse::<SocketAddr>()
|
|
.unwrap();
|
|
|
|
let mut client = TcpStream::connect_timeout(&address, Duration::from_secs(2)).unwrap();
|
|
let request = Request {
|
|
version: PROTOCOL_VERSION,
|
|
request_id: "tcp-process-test".to_owned(),
|
|
command: Command::ListActors,
|
|
};
|
|
writeln!(client, "{}", serde_json::to_string(&request).unwrap()).unwrap();
|
|
client.shutdown(Shutdown::Write).unwrap();
|
|
|
|
let mut response_line = String::new();
|
|
BufReader::new(client)
|
|
.read_line(&mut response_line)
|
|
.unwrap();
|
|
let response: Response = serde_json::from_str(&response_line).unwrap();
|
|
assert_eq!(response.request_id, "tcp-process-test");
|
|
assert_eq!(response.result, Ok(Reply::Actors(Vec::new())));
|
|
}
|