use crate::envelope::StreamItem;
use crate::error::TransportError;
use crate::transport::{ItemStream, MethodRef, Transport};
use futures_util::stream;
use serde::Serialize;
use serde_json::Value;
use std::collections::HashMap;
use std::sync::Mutex;
type Script = Vec<Result<StreamItem, TransportError>>;
#[derive(Debug, Default)]
pub struct MemoryTransport {
scripts: HashMap<String, Script>,
calls: Mutex<Vec<(String, Value)>>,
}
impl MemoryTransport {
pub fn new() -> Self {
Self::default()
}
pub fn script(mut self, method: MethodRef, items: Vec<StreamItem>) -> Self {
self.scripts
.insert(method.qualified(), items.into_iter().map(Ok).collect());
self
}
pub fn script_failure(mut self, method: MethodRef, error: TransportError) -> Self {
self.scripts.insert(method.qualified(), vec![Err(error)]);
self
}
pub fn script_events<E: Serialize>(self, method: MethodRef, events: &[E]) -> Self {
let content_type = method.qualified();
let mut items: Vec<StreamItem> = events
.iter()
.map(|e| StreamItem::Data {
metadata: None,
content_type: Some(content_type.clone()),
content: serde_json::to_value(e).expect("event serializes"),
})
.collect();
items.push(StreamItem::done());
self.script(method, items)
}
pub fn calls(&self) -> Vec<(String, Value)> {
self.calls.lock().expect("calls lock").clone()
}
pub fn params_of(&self, method: MethodRef) -> Option<Value> {
let q = method.qualified();
let calls = self.calls.lock().expect("calls lock");
let mut hits = calls.iter().filter(|(m, _)| *m == q);
let first = hits.next()?;
match hits.next() {
None => Some(first.1.clone()),
Some(_) => None,
}
}
}
impl Transport for MemoryTransport {
fn call(&self, method: MethodRef, params: Value) -> ItemStream<'_> {
let qualified = method.qualified();
self.calls
.lock()
.expect("calls lock")
.push((qualified.clone(), params));
let script = self.scripts.get(&qualified).cloned().unwrap_or_else(|| {
vec![Err(TransportError::protocol(format!(
"MemoryTransport has no script for `{qualified}`"
)))]
});
Box::pin(stream::iter(script))
}
}