protocol_tests.rs 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179
  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 ServerState;
  37. impl Server for ServerState {
  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 ClientState;
  45. impl Client for ClientState {
  46. actor_name!("minimal_client");
  47. type OnSendMsgFut = Ready<TransResult<Self, End>>;
  48. fn on_send_msg(self, _msg: &mut Msg) -> Self::OnSendMsgFut {
  49. ready(TransResult::Ok(End))
  50. }
  51. }
  52. }
  53. #[test]
  54. fn reply() {
  55. protocol! {
  56. named ReplyTest;
  57. let server = [Listening];
  58. let client = [Client];
  59. Client -> Client, >service(Listening)!Ping;
  60. Listening?Ping -> Listening, >Client!Ping::Reply;
  61. }
  62. let msg: Option<ReplyTestMsgs> = None;
  63. match msg {
  64. Some(ReplyTestMsgs::Ping(ping)) => assert_type!(ping, Ping),
  65. Some(ReplyTestMsgs::PingReply(reply)) => assert_type!(reply, <Ping as CallMsg>::Reply),
  66. None => (),
  67. }
  68. struct ListeningState;
  69. impl Listening for ListeningState {
  70. actor_name!("reply_server");
  71. type HandlePingListening = Self;
  72. type HandlePingFut = Ready<TransResult<Self, (Self, <Ping as CallMsg>::Reply)>>;
  73. fn handle_ping(self, _msg: Ping) -> Self::HandlePingFut {
  74. ready(TransResult::Ok((self, ())))
  75. }
  76. }
  77. struct ClientState;
  78. impl Client for ClientState {
  79. actor_name!("reply_client");
  80. type OnSendPingClient = Self;
  81. type OnSendPingFut = Ready<TransResult<Self, (Self, <Ping as CallMsg>::Reply)>>;
  82. fn on_send_ping(self, _ping: &mut Ping) -> Self::OnSendPingFut {
  83. ready(TransResult::Ok((self, ())))
  84. }
  85. }
  86. }
  87. #[test]
  88. fn client_callback() {
  89. #[derive(Serialize, Deserialize)]
  90. pub struct Register;
  91. #[derive(Serialize, Deserialize)]
  92. pub struct Completed;
  93. protocol! {
  94. named ClientCallback;
  95. let server = [Listening];
  96. let worker = [Working];
  97. let client = [Unregistered, Registered];
  98. Unregistered -> Registered, >service(Listening)!Register[Registered];
  99. Listening?Register[Registered] -> Listening, Working[Registered];
  100. Working[Registered] -> End, >Registered!Completed;
  101. Registered?Completed -> End;
  102. }
  103. let msg: Option<ClientCallbackMsgs> = None;
  104. match msg {
  105. Some(ClientCallbackMsgs::Register(msg)) => assert_type!(msg, Register),
  106. Some(ClientCallbackMsgs::Completed(msg)) => assert_type!(msg, Completed),
  107. _ => (),
  108. }
  109. struct UnregisteredState;
  110. impl Unregistered for UnregisteredState {
  111. actor_name!("callback_client");
  112. type OnSendRegisterRegistered = RegisteredState;
  113. type OnSendRegisterFut = Ready<TransResult<Self, Self::OnSendRegisterRegistered>>;
  114. fn on_send_register(self, _arg: &mut Register) -> Self::OnSendRegisterFut {
  115. ready(TransResult::Ok(RegisteredState))
  116. }
  117. }
  118. struct RegisteredState;
  119. impl Registered for RegisteredState {
  120. type HandleCompletedFut = Ready<TransResult<Self, End>>;
  121. fn handle_completed(self, _arg: Completed) -> Self::HandleCompletedFut {
  122. ready(TransResult::Ok(End))
  123. }
  124. }
  125. struct ListeningState;
  126. impl Listening for ListeningState {
  127. actor_name!("callback_server");
  128. type HandleRegisterListening = ListeningState;
  129. type HandleRegisterWorking = WorkingState;
  130. type HandleRegisterFut = Ready<TransResult<Self, (ListeningState, WorkingState)>>;
  131. fn handle_register(self, _arg: Register) -> Self::HandleRegisterFut {
  132. ready(TransResult::Ok((self, WorkingState)))
  133. }
  134. }
  135. struct WorkingState;
  136. impl Working for WorkingState {
  137. actor_name!("callback_worker");
  138. type OnSendCompletedFut = Ready<TransResult<Self, (End, Completed)>>;
  139. fn on_send_completed(self) -> Self::OnSendCompletedFut {
  140. ready(TransResult::Ok((End, Completed)))
  141. }
  142. }
  143. }