protocol_tests.rs 5.1 KB

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