use super::*;
use crate::{Client, ReconnectingClient};
use futures_util::StreamExt;
use shep_core::protocol::{
Envelope, HelloAck, Request, Response, RpcError, RpcErrorCode, codec, decode_frame,
};
use std::collections::VecDeque;
use std::path::Path;
use std::sync::atomic::AtomicU64;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
use tokio_util::codec::Framed;
pub async fn fake_client_on(path: &Path) -> (Client, FakeDaemon) {
fake_client_with_ack(path, sample_ack()).await
}
pub async fn fake_client_with_ack(path: &Path, ack: HelloAck) -> (Client, FakeDaemon) {
let daemon = fake_daemon_scripted_on(path, ack);
let client = Client::connect(path).await.unwrap();
(client, daemon)
}
pub async fn fake_reconnecting_client_on(path: &Path) -> (ReconnectingClient, FakeDaemon) {
let daemon = fake_daemon_scripted_on(path, sample_ack());
let client = ReconnectingClient::connect(path).await.unwrap();
(client, daemon)
}
#[must_use]
pub fn fake_daemon_scripted_on(path: &Path, ack: HelloAck) -> FakeDaemon {
let listener = bind(path);
let (script_tx, script_rx) = mpsc::channel(SCRIPT_CHANNEL_CAPACITY);
let armed_list = Arc::new(Mutex::new(None));
let armed_list_sequence = Arc::new(Mutex::new(VecDeque::new()));
let armed_describe = Arc::new(Mutex::new(None));
let armed_reply_then_event = Arc::new(Mutex::new(None));
let armed_shutdown_then_unlink = Arc::new(Mutex::new(None));
let armed_shutdown_never_unlink = Arc::new(Mutex::new(None));
let list_flock_count = Arc::new(AtomicU64::new(0));
let task = tokio::spawn(serve_scripted(
listener,
path.to_path_buf(),
ack,
script_rx,
Arc::clone(&armed_list),
Arc::clone(&armed_list_sequence),
Arc::clone(&armed_describe),
Arc::clone(&armed_reply_then_event),
Arc::clone(&armed_shutdown_then_unlink),
Arc::clone(&armed_shutdown_never_unlink),
Arc::clone(&list_flock_count),
));
FakeDaemon {
script: script_tx,
armed_list,
armed_list_sequence,
armed_describe,
armed_reply_then_event,
armed_shutdown_then_unlink,
armed_shutdown_never_unlink,
list_flock_count,
task,
}
}
pub async fn fake_client_with_push(path: &Path) -> (Client, FakeDaemon) {
fake_client_on(path).await
}
pub async fn fake_daemon_answering_with_ack(
path: &Path,
ack: HelloAck,
answer: impl Fn(&Request) -> Response + Send + Sync + Clone + 'static,
) -> mpsc::UnboundedReceiver<Envelope> {
let mut listener = bind(path);
let (tx, rx) = mpsc::unbounded_channel();
tokio::spawn(async move {
while let Ok(stream) = listener.accept().await {
let tx = tx.clone();
let ack = ack.clone();
let answer = answer.clone();
tokio::spawn(async move {
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, ack).await;
while let Some(Ok(frame)) = frames.next().await {
let Ok(envelope) = decode_frame::<Envelope>(&frame) else {
break;
};
let id = envelope.id;
let reply = answer(&envelope.body);
if tx.send(envelope).is_err() {
break;
}
write_reply(&mut frames, id, reply).await;
}
});
}
});
rx
}
pub async fn fake_client_answering(
path: &Path,
answer: impl Fn(&Request) -> Response + Send + 'static,
) -> (Client, mpsc::UnboundedReceiver<Envelope>) {
let mut listener = bind(path);
let (tx, rx) = mpsc::unbounded_channel();
tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
while let Some(Ok(frame)) = frames.next().await {
let Ok(envelope) = decode_frame::<Envelope>(&frame) else {
break;
};
let id = envelope.id;
let reply = answer(&envelope.body);
if tx.send(envelope).is_err() {
break;
}
write_reply(&mut frames, id, reply).await;
}
});
let client = Client::connect(path).await.unwrap();
(client, rx)
}
pub async fn fake_client_answering_refusals(
path: &Path,
answer: impl Fn(&Request) -> Result<Response, RpcError> + Send + 'static,
) -> (Client, mpsc::UnboundedReceiver<Envelope>) {
let mut listener = bind(path);
let (tx, rx) = mpsc::unbounded_channel();
tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
while let Some(Ok(frame)) = frames.next().await {
let Ok(envelope) = decode_frame::<Envelope>(&frame) else {
break;
};
let id = envelope.id;
let answer = answer(&envelope.body);
if tx.send(envelope).is_err() {
break;
}
match answer {
Ok(response) => write_reply(&mut frames, id, response).await,
Err(err) => write_err(&mut frames, id, err.code, err.message).await,
}
}
});
let client = Client::connect(path).await.unwrap();
(client, rx)
}
pub async fn fake_client_capturing_envelopes(path: &Path) -> (Client, mpsc::Receiver<Envelope>) {
let mut listener = bind(path);
let (tx, rx) = mpsc::channel(SCRIPT_CHANNEL_CAPACITY);
tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
loop {
let envelope = read_envelope(&mut frames).await;
let id = envelope.id;
if tx.send(envelope).await.is_err() {
break;
}
write_reply(&mut frames, id, Response::Pong).await;
}
});
let client = Client::connect(path).await.unwrap();
(client, rx)
}
pub async fn fake_client_replying_err(
path: &Path,
code: RpcErrorCode,
message: &str,
) -> (Client, FakeDaemon) {
let (client, daemon) = fake_client_on(path).await;
daemon
.script
.send(ScriptCommand::ReplyErr(code, message.to_string()))
.await
.unwrap();
(client, daemon)
}
pub async fn fake_client_out_of_order(path: &Path) -> (Client, FakeDaemon) {
let (client, daemon) = fake_client_on(path).await;
daemon
.script
.send(ScriptCommand::ArmOutOfOrder)
.await
.unwrap();
(client, daemon)
}
pub async fn fake_client_event_then_reply(path: &Path) -> (Client, FakeDaemon) {
let (client, daemon) = fake_client_on(path).await;
daemon
.script
.send(ScriptCommand::EventThenReply)
.await
.unwrap();
(client, daemon)
}
pub async fn fake_client_that_closes_after_handshake(path: &Path) -> (Client, JoinHandle<()>) {
let mut listener = bind(path);
let task = tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
});
let client = Client::connect(path).await.unwrap();
(client, task)
}
pub async fn fake_client_that_dies_mid_request(path: &Path) -> (Client, JoinHandle<()>) {
let mut listener = bind(path);
let task = tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
let _envelope = read_envelope(&mut frames).await;
});
let client = Client::connect(path).await.unwrap();
(client, task)
}
pub async fn fake_client_that_never_replies(path: &Path) -> (Client, JoinHandle<()>) {
let mut listener = bind(path);
let task = tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
core::future::pending::<()>().await;
});
let client = Client::connect(path).await.unwrap();
(client, task)
}
pub async fn fake_client_needing_budget(
path: &Path,
needs: Duration,
response: Response,
) -> (Client, JoinHandle<()>) {
let mut listener = bind(path);
let task = tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
loop {
let envelope = read_envelope(&mut frames).await;
let budget = Duration::from_millis(envelope.deadline_ms.unwrap_or(u64::MAX));
if budget < needs {
let message = format!("request deadline of {} ms expired", budget.as_millis());
write_err(
&mut frames,
envelope.id,
RpcErrorCode::DeadlineExceeded,
message,
)
.await;
} else {
write_reply(&mut frames, envelope.id, response.clone()).await;
}
}
});
let client = Client::connect(path).await.unwrap();
(client, task)
}