use wabot_core::injection::Container;
use crate::{AckSink, SocketControllerRegistration, SocketEventEntry};
pub struct SocketHarness {
registration: SocketControllerRegistration,
container: Container,
}
impl SocketHarness {
pub fn new(registration: SocketControllerRegistration, container: Container) -> Self {
Self {
registration,
container,
}
}
pub fn namespace(&self) -> &str {
&self.registration.namespace
}
pub fn event_names(&self) -> Vec<&'static str> {
self.registration.event_names()
}
pub fn handshake_names(&self) -> Vec<&'static str> {
self.registration.handshake_names()
}
pub fn container(&self) -> &Container {
&self.container
}
fn entry(&self, event: &str) -> &SocketEventEntry {
self.registration
.events
.iter()
.find(|entry| entry.event == event)
.unwrap_or_else(|| {
panic!(
"no handler for the '{event}' event. This controller handles: {:?}",
self.registration.event_names()
)
})
}
pub async fn emit(&self, event: &str, payload: serde_json::Value) -> EmittedEvent {
let entry = self.entry(event);
let (sink, captured) = AckSink::capture();
(entry.invoke)(self.container.clone(), None, payload, sink).await;
let ack = captured.lock().clone();
EmittedEvent {
event: event.to_string(),
ack,
}
}
}
pub struct EmittedEvent {
pub event: String,
pub ack: Option<serde_json::Value>,
}
impl EmittedEvent {
pub fn value(&self) -> serde_json::Value {
self.ack.clone().unwrap_or_else(|| {
panic!(
"the '{}' event answered nothing. A handler that takes a SocketRef cannot be \
driven without a connection — check needs_socket().",
self.event
)
})
}
pub fn error_code(&self) -> Option<&str> {
self.ack.as_ref()?.get("error")?.get("code")?.as_str()
}
pub fn error_message(&self) -> Option<&str> {
self.ack.as_ref()?.get("error")?.get("message")?.as_str()
}
pub fn is_error(&self) -> bool {
self.error_code().is_some()
}
pub fn needs_socket(&self) -> bool {
self.error_message()
.is_some_and(|message| message.contains("needs a live socket"))
}
pub fn json<T: serde::de::DeserializeOwned>(&self) -> T {
serde_json::from_value(self.value()).unwrap_or_else(|error| {
panic!(
"the '{}' event answered {:?}, which is not a {} ({error})",
self.event,
self.ack,
std::any::type_name::<T>()
)
})
}
}