1use async_trait::async_trait;
2use crate::exchange::Exchange;
3use crate::status::{HandlerExecutionError, HandlerStatus};
4
5#[async_trait]
6pub trait Handler<Input, Output, Metadata>: Send
7where
8 Input: Send,
9 Output: Send,
10 Metadata: Send,
11{
12 async fn exec(
13 &self,
14 exchange: & mut Exchange<Input, Output, Metadata>,
15 ) -> Result<HandlerStatus, HandlerExecutionError>;
16}
17
18#[cfg(test)]
19mod test {
20 use async_trait::async_trait;
21 use crate::exchange::Exchange;
22 use crate::handler::Handler;
23 use crate::status::{Code, HandlerExecutionError, HandlerStatus};
24
25 pub struct TestHandler;
26
27 #[derive(Default)]
28 pub struct TestInput
29 where
30 Self: Send,
31 {
32 pub test_input: String,
33 }
34
35 #[derive(Default)]
36 pub struct TestOutput
37 where
38 Self: Send,
39 {
40 pub test_output: String,
41 }
42
43 #[async_trait]
44 impl Handler<TestInput, TestOutput, ()> for TestHandler {
45 async fn exec(
46 &self,
47 exchange: &mut Exchange<TestInput, TestOutput, ()>,
48 ) -> Result<HandlerStatus, HandlerExecutionError>
49 {
50 let consumed_input = exchange.take_request().unwrap();
52 let mut output = TestOutput::default();
53 output.test_output = consumed_input.test_input;
54 exchange.save_output(output);
55 Ok(HandlerStatus::new(Code::OK))
56 }
57 }
58
59 #[tokio::test(flavor = "current_thread")]
60 async fn test_handler() {
61 let handler = TestHandler;
62 let mut exchange: Exchange<TestInput, TestOutput, ()> = Exchange::new();
63 let mut input = TestInput::default();
64 input.test_input = "test".to_string();
65 exchange.save_input(input);
66 handler.exec(&mut exchange).await.expect("Failed to execute test");
67 let output = exchange.take_output().unwrap();
68 assert_eq!(output.test_output, "test");
69 }
70}