golang_ipc_rs/
mock_client.rs1use crate::{ClientConfig, Message, Status};
2use bytes::Bytes;
3use flume::{Receiver, SendError, Sender};
4use std::sync::Arc;
5use tokio::sync::RwLock;
6
7#[derive(Debug, Clone)]
8pub struct MockClient {
9 ipc_tx: Sender<Message>,
10 ipc_rx: Receiver<Message>,
11 pub ipc_to_send: Arc<RwLock<Vec<Message>>>,
12}
13
14impl MockClient {
15 pub fn new(_config: ClientConfig) -> Self {
16 let (ipc_tx, ipc_rx) = flume::bounded::<Message>(10);
17 MockClient {
18 ipc_tx,
19 ipc_rx,
20 ipc_to_send: Arc::new(RwLock::new(Vec::new())),
21 }
22 }
23
24 pub async fn run(&mut self) -> crate::Result<()> {
25 Ok(())
26 }
27
28 pub fn new_message(&self, msg_type: i32, data: Bytes) -> Message {
29 Message::new(msg_type, data, false)
30 }
31
32 pub async fn recv_message(&self) -> Option<Message> {
33 self.ipc_rx.recv_async().await.ok()
34 }
35
36 pub async fn send_message(&self, message: Message) -> Result<(), SendError<Message>> {
37 self.ipc_to_send.write().await.push(message);
38 Ok(())
39 }
40
41 pub async fn mock_tx_send(&self, message: Message) -> Result<(), SendError<Message>> {
42 self.ipc_tx.send_async(message).await
43 }
44
45 pub async fn send_status(&self, status: Status) {
46 let message = Message::from_status(status);
47 self.ipc_tx
48 .send_async(message)
49 .await
50 .expect("Send should not fail");
51 }
52
53 pub async fn get_status(&mut self) -> Status {
54 Status::Connected
55 }
56}
57
58#[cfg(test)]
59mod tests {
60 use super::*;
61 use tokio_test::*;
62
63 #[tokio::test]
64 async fn mock() {
65 let mut client = MockClient::new(ClientConfig::default());
66 client.run().await.expect("Expect to complete");
67
68 let mut rx_task = task::spawn(client.recv_message());
69 assert_pending!(rx_task.poll(), "Expected recv be pending");
70 }
71}