protocol_tests.rs 4.4 KB

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