Blocktree/crates/btproto/tests/protocol_tests.rs

#![feature(impl_trait_in_assoc_type)]

use std::future::{ready, Ready};

use btlib::Result;
use btproto::protocol;
use btrun::{CallMsg, End};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct Ping;

impl CallMsg for Ping {
    type Reply = ();
}

/// Tests that the given variable is of the given type _at compile time_.
macro_rules! assert_type {
    ($var:expr, $ty:ty) => {{
        let _: $ty = $var;
    }};
}

#[test]
fn minimal_syntax() {
    #[derive(Serialize, Deserialize)]
    pub struct Msg;

    protocol! {
        named MinimalTest;
        let states = [Server];
        let client = [Client];
        Client -> End, >service(Server)!Msg;
        Server?Msg -> End;
    }

    let msg: Option<MinimalTestMsgs> = None;
    match msg {
        Some(MinimalTestMsgs::Msg(act)) => assert_type!(act, Msg),
        None => (),
    }

    struct ServerState;

    impl Server for ServerState {
        type HandleMsgFut = Ready<Result<End>>;
        fn handle_msg(self, _msg: Msg) -> Self::HandleMsgFut {
            ready(Ok(End))
        }
    }

    struct ClientState;

    impl Client for ClientState {
        type OnSendMsgFut = Ready<Result<End>>;
        fn on_send_msg(self, _msg: &mut Msg) -> Self::OnSendMsgFut {
            ready(Ok(End))
        }
    }
}

#[test]
fn reply() {
    protocol! {
        named ReplyTest;
        let server = [Listening];
        let client = [Client];
        Client -> Client, >service(Listening)!Ping;
        Listening?Ping -> Listening, >Client!Ping::Reply;
    }

    let msg: Option<ReplyTestMsgs> = None;
    match msg {
        Some(ReplyTestMsgs::Ping(ping)) => assert_type!(ping, Ping),
        Some(ReplyTestMsgs::PingReply(reply)) => assert_type!(reply, <Ping as CallMsg>::Reply),
        None => (),
    }

    struct ListeningState;

    impl Listening for ListeningState {
        type HandlePingListening = Self;
        type HandlePingFut = Ready<Result<(Self, <Ping as CallMsg>::Reply)>>;
        fn handle_ping(self, _msg: Ping) -> Self::HandlePingFut {
            ready(Ok((self, ())))
        }
    }

    struct ClientState;

    impl Client for ClientState {
        type OnSendPingClient = Self;
        type OnSendPingFut = Ready<Result<(Self, <Ping as CallMsg>::Reply)>>;
        fn on_send_ping(self, _ping: &mut Ping) -> Self::OnSendPingFut {
            ready(Ok((self, ())))
        }
    }
}

#[test]
fn client_callback() {
    #[derive(Serialize, Deserialize)]
    pub struct Register;
    #[derive(Serialize, Deserialize)]
    pub struct Completed;

    protocol! {
        named ClientCallback;
        let server = [Listening];
        let worker = [Working];
        let client = [Unregistered, Registered];
        Unregistered -> Registered, >service(Listening)!Register[Registered];
        Listening?Register[Registered] -> Listening, Working[Registered];
        Working[Registered] -> End, >Registered!Completed;
        Registered?Completed -> End;
    }

    let msg: Option<ClientCallbackMsgs> = None;
    match msg {
        Some(ClientCallbackMsgs::Register(msg)) => assert_type!(msg, Register),
        Some(ClientCallbackMsgs::Completed(msg)) => assert_type!(msg, Completed),
        _ => (),
    }

    struct UnregisteredState;

    impl Unregistered for UnregisteredState {
        type OnSendRegisterRegistered = RegisteredState;
        type OnSendRegisterFut = Ready<Result<Self::OnSendRegisterRegistered>>;
        fn on_send_register(self, _arg: &mut Register) -> Self::OnSendRegisterFut {
            ready(Ok(RegisteredState))
        }
    }

    struct RegisteredState;

    impl Registered for RegisteredState {
        type HandleCompletedFut = Ready<Result<End>>;
        fn handle_completed(self, _arg: Completed) -> Self::HandleCompletedFut {
            ready(Ok(End))
        }
    }

    struct ListeningState;

    impl Listening for ListeningState {
        type HandleRegisterListening = ListeningState;
        type HandleRegisterWorking = WorkingState;
        type HandleRegisterFut = Ready<Result<(ListeningState, WorkingState)>>;
        fn handle_register(self, _arg: Register) -> Self::HandleRegisterFut {
            ready(Ok((self, WorkingState)))
        }
    }

    struct WorkingState;

    impl Working for WorkingState {
        type OnSendCompletedFut = Ready<Result<(End, Completed)>>;
        fn on_send_completed(self) -> Self::OnSendCompletedFut {
            ready(Ok((End, Completed)))
        }
    }
}