ftswarm_proto 0.2.4

Protocol definitions for the ftswarm serial communication protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

pub mod command;
pub mod message_parser;

pub trait IdOf {
    /// Some objects have an ID, this function returns it
    fn id(&self) -> u32;
}

pub trait NameOf {
    fn name(&self) -> String;
}

pub trait Serialized {
    /// Serialize the object to a string to be sent over the bus
    fn serialize(&self) -> String;
}

pub trait Deserialized {
    /// Deserialize the string into the object
    fn deserialize(value: &String) -> Result<Self, String> where Self: Sized;
}

#[cfg(test)]
mod tests {
    use crate::command::argument::Argument;
    use crate::command::direct::FtSwarmDirectCommand::Help;
    use crate::command::FtSwarmCommand;
    use crate::command::rpc::FtSwarmRPCCommand;
    use crate::command::rpc::RpcFunction::GetResistance;
    use crate::{Deserialized, Serialized};

    fn test_serialize<T: Serialized>(obj: T, expected: &str) {
        assert_eq!(obj.serialize(), expected);
    }

    #[test]
    fn test_serialize_rpc() {
        test_serialize(FtSwarmCommand::RPC(FtSwarmRPCCommand {
            target: "hello".to_string(),
            function: GetResistance,
            args: vec![Argument::Int(42)]
        }), "hello.getResistance(42)");
    }

    #[test]
    fn test_serialize_direct() {
        test_serialize(FtSwarmCommand::Direct(Help), "help");
    }

    #[test]
    fn test_deserialize_rpc() {
        let cmd = FtSwarmCommand::deserialize(&"hello.getResistance(42)".to_string()).unwrap();
        match cmd {
            FtSwarmCommand::RPC(rpc) => {
                assert_eq!(rpc.target, "hello");
                assert_eq!(rpc.function, GetResistance);
                assert_eq!(rpc.args.len(), 1);
                match &rpc.args[0] {
                    Argument::Int(i) => assert_eq!(*i, 42),
                    _ => panic!("Expected int argument")
                }
            },
            _ => panic!("Expected RPC command")
        }
    }

    #[test]
    fn test_deserialize_direct() {
        let cmd = FtSwarmCommand::deserialize(&"help".to_string()).unwrap();
        match cmd {
            FtSwarmCommand::Direct(Help) => {},
            _ => panic!("Expected Direct command")
        }
    }
}