add tests for proto impl

slowtec · Jan 21, 2018 · c1ccb92 · c1ccb92
1 parent b0023eb
commit c1ccb92
Show file tree

Hide file tree

Showing 5 changed files with 79 additions and 10 deletions.
diff --git a/src/codec/common.rs b/src/codec/common.rs
@@ -3,6 +3,7 @@ use std::io::{self, Cursor, Error, ErrorKind};
 use bytes::{BigEndian, BufMut, Bytes, BytesMut};
 use byteorder::ReadBytesExt;
 
+#[derive(Debug, PartialEq)]
 pub enum CodecType {
     Client,
     Server,

diff --git a/src/codec/mod.rs b/src/codec/mod.rs
@@ -1,3 +1,3 @@
-mod common;
+pub mod common;
 pub mod tcp;
 pub mod rtu;
diff --git a/src/codec/rtu.rs b/src/codec/rtu.rs
@@ -5,12 +5,13 @@ use bytes::{BigEndian, BufMut, Bytes, BytesMut};
 use byteorder::ReadBytesExt;
 use super::common::*;
 
+#[derive(Debug, PartialEq)]
 pub(crate) struct Codec {
-    decoder: RtuDecoder,
-    codec_type: CodecType,
+    pub(crate) decoder: RtuDecoder,
 }
 
-struct RtuDecoder {
+#[derive(Debug, PartialEq)]
+pub(crate) struct RtuDecoder {
     codec_type: CodecType,
 }
 
@@ -22,15 +23,13 @@ impl Codec {
             decoder: RtuDecoder {
                 codec_type: CodecType::Client,
             },
-            codec_type: CodecType::Client,
         }
     }
     pub fn server() -> Codec {
         Codec {
             decoder: RtuDecoder {
                 codec_type: CodecType::Server,
             },
-            codec_type: CodecType::Server,
         }
     }
 }
@@ -125,7 +124,7 @@ impl Decoder for Codec {
 
     fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<RtuAdu>> {
         if let Some((address, data)) = self.decoder.decode(buf)? {
-            let pdu = match self.codec_type {
+            let pdu = match self.decoder.codec_type {
                 CodecType::Client => {
                     let res = if data[0] > 0x80 {
                         Err(ExceptionResponse::try_from(data)?)

diff --git a/src/codec/tcp.rs b/src/codec/tcp.rs
@@ -8,11 +8,13 @@ use super::common::*;
 const HEADER_SIZE: usize = 7;
 const PROTOCOL_ID: u16 = 0x0;
 
-struct TcpDecoder;
+#[derive(Debug, PartialEq)]
+pub(crate) struct TcpDecoder;
 
+#[derive(Debug, PartialEq)]
 pub(crate) struct Codec {
-    decoder: TcpDecoder,
-    codec_type: CodecType,
+    pub(crate) decoder: TcpDecoder,
+    pub(crate) codec_type: CodecType,
 }
 
 impl Codec {

diff --git a/src/proto.rs b/src/proto.rs
@@ -30,6 +30,24 @@ pub mod tcp {
             Ok(io.framed(Codec::server()))
         }
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::Proto;
+        use codec::tcp::Codec;
+        use codec::common::CodecType;
+        use super::super::dummy_io::DummyIo;
+
+        #[test]
+        fn bind_transport() {
+            use tokio_proto::pipeline::ClientProto;
+            let proto = Proto;
+            let io = DummyIo;
+            let (_, codec) = proto.bind_transport(io).unwrap().into_parts_and_codec();
+            assert_eq!(codec.codec_type, CodecType::Client);
+            assert_eq!(codec, Codec::client());
+        }
+    }
 }
 
 pub mod rtu {
@@ -64,4 +82,53 @@ pub mod rtu {
             Ok(io.framed(Codec::server()))
         }
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::Proto;
+        use codec::rtu::Codec;
+        use super::super::dummy_io::DummyIo;
+
+        #[test]
+        fn bind_transport() {
+            use tokio_proto::pipeline::ClientProto;
+            let proto = Proto;
+            let io = DummyIo;
+            let (_, codec) = proto.bind_transport(io).unwrap().into_parts_and_codec();
+            assert_eq!(codec, Codec::client());
+        }
+    }
+}
+
+#[cfg(test)]
+mod dummy_io {
+    use std::io::Error;
+    use std::io::{Read, Write};
+    use tokio_io::{AsyncRead, AsyncWrite};
+    use futures::Async;
+
+    pub struct DummyIo;
+
+    impl Read for DummyIo {
+        fn read(&mut self, _: &mut [u8]) -> Result<usize, Error> {
+            unimplemented!();
+        }
+    }
+
+    impl Write for DummyIo {
+        fn write(&mut self, _: &[u8]) -> Result<usize, Error> {
+            unimplemented!();
+        }
+        fn flush(&mut self) -> Result<(), Error> {
+            unimplemented!();
+        }
+    }
+
+    impl AsyncRead for DummyIo {}
+
+    impl AsyncWrite for DummyIo {
+        fn shutdown(&mut self) -> Result<Async<()>, Error> {
+            unimplemented!();
+        }
+    }
 }