protocol_tests.rs 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190
  1. #![feature(impl_trait_in_assoc_type)]
  2. use std::future::{ready, Ready};
  3. use btproto::protocol;
  4. use btrun::{
  5. actor_name,
  6. model::{CallMsg, End, TransResult},
  7. };
  8. use serde::{Deserialize, Serialize};
  9. #[derive(Serialize, Deserialize)]
  10. pub struct Ping;
  11. impl CallMsg for Ping {
  12. type Reply = ();
  13. }
  14. /// Tests that the given variable is of the given type _at compile time_.
  15. macro_rules! assert_type {
  16. ($var:expr, $ty:ty) => {{
  17. let _: $ty = $var;
  18. }};
  19. }
  20. #[test]
  21. fn minimal_syntax() {
  22. #[derive(Serialize, Deserialize)]
  23. pub struct Msg;
  24. protocol! {
  25. named MinimalTest;
  26. let server = [Server];
  27. let client = [Client];
  28. Client -> End, >service(Server)!Msg;
  29. Server?Msg -> End;
  30. }
  31. let msg: Option<MinimalTestMsgs> = None;
  32. match msg {
  33. Some(MinimalTestMsgs::Msg(act)) => assert_type!(act, Msg),
  34. None => (),
  35. }
  36. struct ServerImpl;
  37. impl Server for ServerImpl {
  38. actor_name!("minimal_server");
  39. type HandleMsgFut = Ready<TransResult<Self, End>>;
  40. fn handle_msg(self, _msg: Msg) -> Self::HandleMsgFut {
  41. ready(TransResult::Ok(End))
  42. }
  43. }
  44. struct ClientImpl;
  45. impl Client for ClientImpl {
  46. actor_name!("minimal_client");
  47. type OnSendMsgReturn = usize;
  48. type OnSendMsgFut = Ready<TransResult<Self, (End, usize)>>;
  49. fn on_send_msg(self) -> Self::OnSendMsgFut {
  50. ready(TransResult::Ok((End, 42)))
  51. }
  52. }
  53. }
  54. #[test]
  55. fn reply() {
  56. protocol! {
  57. named ReplyTest;
  58. let server = [Listening];
  59. let client = [Client];
  60. Client -> Client, >service(Listening)!Ping;
  61. Listening?Ping -> Listening, >Client!Ping::Reply;
  62. }
  63. let msg: Option<ReplyTestMsgs> = None;
  64. match msg {
  65. Some(ReplyTestMsgs::Ping(ping)) => assert_type!(ping, Ping),
  66. Some(ReplyTestMsgs::PingReply(reply)) => assert_type!(reply, <Ping as CallMsg>::Reply),
  67. None => (),
  68. }
  69. struct ListeningImpl;
  70. impl Listening for ListeningImpl {
  71. actor_name!("reply_server");
  72. type HandlePingListening = Self;
  73. type HandlePingFut = Ready<TransResult<Self, (Self, <Ping as CallMsg>::Reply)>>;
  74. fn handle_ping(self, _msg: Ping) -> Self::HandlePingFut {
  75. ready(TransResult::Ok((self, ())))
  76. }
  77. }
  78. struct ClientImpl;
  79. impl Client for ClientImpl {
  80. actor_name!("reply_client");
  81. type OnSendPingReturn = ();
  82. type OnSendPingClient = Self;
  83. type OnSendPingFut = Ready<TransResult<Self, (Self, ())>>;
  84. fn on_send_ping(self, _ping: <Ping as CallMsg>::Reply) -> Self::OnSendPingFut {
  85. ready(TransResult::Ok((self, ())))
  86. }
  87. }
  88. }
  89. #[test]
  90. fn client_callback() {
  91. #[derive(Serialize, Deserialize)]
  92. pub struct Register;
  93. #[derive(Serialize, Deserialize)]
  94. pub struct Completed;
  95. protocol! {
  96. named ClientCallback;
  97. let server = [Listening];
  98. let worker = [Working];
  99. let client = [Unregistered, Registered];
  100. Unregistered -> Registered, >service(Listening)!Register[Registered];
  101. Listening?Register[Registered] -> Listening, Working[Registered];
  102. Working[Registered] -> End, >Registered!Completed;
  103. Registered?Completed -> End;
  104. }
  105. let msg: Option<ClientCallbackMsgs> = None;
  106. match msg {
  107. Some(ClientCallbackMsgs::Register(msg)) => assert_type!(msg, Register),
  108. Some(ClientCallbackMsgs::Completed(msg)) => assert_type!(msg, Completed),
  109. None => (),
  110. }
  111. let client_state: Option<ClientState<UnregisteredImpl>> = None;
  112. match client_state {
  113. Some(ClientState::Unregistered(state)) => assert_type!(state, UnregisteredImpl),
  114. Some(ClientState::Registered(state)) => assert_type!(state, RegisteredImpl),
  115. Some(ClientState::End(state)) => assert_type!(state, End),
  116. None => (),
  117. }
  118. struct UnregisteredImpl;
  119. impl Unregistered for UnregisteredImpl {
  120. actor_name!("callback_client");
  121. type OnSendRegisterReturn = ();
  122. type OnSendRegisterRegistered = RegisteredImpl;
  123. type OnSendRegisterFut = Ready<TransResult<Self, (Self::OnSendRegisterRegistered, ())>>;
  124. fn on_send_register(self) -> Self::OnSendRegisterFut {
  125. ready(TransResult::Ok((RegisteredImpl, ())))
  126. }
  127. }
  128. struct RegisteredImpl;
  129. impl Registered for RegisteredImpl {
  130. type HandleCompletedFut = Ready<TransResult<Self, End>>;
  131. fn handle_completed(self, _arg: Completed) -> Self::HandleCompletedFut {
  132. ready(TransResult::Ok(End))
  133. }
  134. }
  135. struct ListeningImpl;
  136. impl Listening for ListeningImpl {
  137. actor_name!("callback_server");
  138. type HandleRegisterListening = ListeningImpl;
  139. type HandleRegisterWorking = WorkingImpl;
  140. type HandleRegisterFut = Ready<TransResult<Self, (ListeningImpl, WorkingImpl)>>;
  141. fn handle_register(self, _arg: Register) -> Self::HandleRegisterFut {
  142. ready(TransResult::Ok((self, WorkingImpl)))
  143. }
  144. }
  145. struct WorkingImpl;
  146. impl Working for WorkingImpl {
  147. actor_name!("callback_worker");
  148. type OnSendCompletedFut = Ready<TransResult<Self, (End, Completed)>>;
  149. fn on_send_completed(self) -> Self::OnSendCompletedFut {
  150. ready(TransResult::Ok((End, Completed)))
  151. }
  152. }
  153. }