Merge pull request #56 from ethcore/p2p_tests

first p2p unit tests

p2p/src/io/read_any_message.rs

@@ -63,3 +63,35 @@ impl<A> Future for ReadAnyMessage<A> where A: io::Read {
 		}
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use futures::Future;
+	use bytes::Bytes;
+	use message::{Magic, Error};
+	use super::read_any_message;
+
+	#[test]
+	fn test_read_any_message() {
+		let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c00c765845303b6da97786".into();
+		let name = "ping".into();
+		let nonce = "5845303b6da97786".into();
+		let expected = (name, nonce);
+
+		assert_eq!(read_any_message(raw.as_ref(), Magic::Mainnet).wait().unwrap(), Ok(expected));
+		assert_eq!(read_any_message(raw.as_ref(), Magic::Testnet).wait().unwrap(), Err(Error::WrongMagic));
+	}
+
+	#[test]
+	fn test_read_too_short_any_message() {
+		let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c00c765845303b6da977".into();
+		assert!(read_any_message(raw.as_ref(), Magic::Mainnet).wait().is_err());
+	}
+
+
+	#[test]
+	fn test_read_any_message_with_invalid_checksum() {
+		let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c01c765845303b6da97786".into();
+		assert_eq!(read_any_message(raw.as_ref(), Magic::Mainnet).wait().unwrap(), Err(Error::InvalidChecksum));
+	}
+}

p2p/src/io/read_header.rs

@@ -30,8 +30,7 @@ impl<A> Future for ReadHeader<A> where A: io::Read {
 mod tests {
 	use futures::Future;
 	use bytes::Bytes;
-	use message::MessageHeader;
-	use message::common::Magic;
+	use message::{Magic, MessageHeader, Error};
 	use super::read_header;
 
 	#[test]
@@ -45,6 +44,18 @@ mod tests {
 		};
 
 		assert_eq!(read_header(raw.as_ref(), Magic::Mainnet).wait().unwrap().1, Ok(expected));
-		assert!(read_header(raw.as_ref(), Magic::Testnet).wait().unwrap().1.is_err());
+		assert_eq!(read_header(raw.as_ref(), Magic::Testnet).wait().unwrap().1, Err(Error::WrongMagic));
+	}
+
+	#[test]
+	fn test_read_header_with_invalid_magic() {
+		let raw: Bytes = "f9beb4d86164647200000000000000001f000000ed52399b".into();
+		assert_eq!(read_header(raw.as_ref(), Magic::Testnet).wait().unwrap().1, Err(Error::InvalidMagic));
+	}
+
+	#[test]
+	fn test_read_too_short_header() {
+		let raw: Bytes = "f9beb4d96164647200000000000000001f000000ed5239".into();
+		assert!(read_header(raw.as_ref(), Magic::Mainnet).wait().is_err());
 	}
 }

p2p/src/io/read_message.rs

@@ -69,3 +69,34 @@ impl<M, A> Future for ReadMessage<M, A> where A: io::Read, M: Payload {
 		}
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use futures::Future;
+	use bytes::Bytes;
+	use message::{Magic, Error};
+	use message::types::{Ping, Pong};
+	use super::read_message;
+
+	#[test]
+	fn test_read_message() {
+		let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c00c765845303b6da97786".into();
+		let ping = Ping::new(u64::from_str_radix("8677a96d3b304558", 16).unwrap());
+		assert_eq!(read_message(raw.as_ref(), Magic::Mainnet, 0).wait().unwrap().1, Ok(ping));
+		assert_eq!(read_message::<Ping, _>(raw.as_ref(), Magic::Testnet, 0).wait().unwrap().1, Err(Error::WrongMagic));
+		assert_eq!(read_message::<Pong, _>(raw.as_ref(), Magic::Mainnet, 0).wait().unwrap().1, Err(Error::InvalidCommand));
+	}
+
+	#[test]
+	fn test_read_too_short_message() {
+		let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c00c765845303b6da977".into();
+		assert!(read_message::<Ping, _>(raw.as_ref(), Magic::Mainnet, 0).wait().is_err());
+	}
+
+
+	#[test]
+	fn test_read_message_with_invalid_checksum() {
+		let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c01c765845303b6da97786".into();
+		assert_eq!(read_message::<Ping, _>(raw.as_ref(), Magic::Mainnet, 0).wait().unwrap().1, Err(Error::InvalidChecksum));
+	}
+}

p2p/src/io/read_payload.rs

@@ -37,3 +37,31 @@ impl<M, A> Future for ReadPayload<M, A> where A: io::Read, M: Payload {
 		Ok((read, payload).into())
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use futures::Future;
+	use bytes::Bytes;
+	use message::Error;
+	use message::types::Ping;
+	use super::read_payload;
+
+	#[test]
+	fn test_read_payload() {
+		let raw: Bytes = "5845303b6da97786".into();
+		let ping = Ping::new(u64::from_str_radix("8677a96d3b304558", 16).unwrap());
+		assert_eq!(read_payload(raw.as_ref(), 0, 8, "83c00c76".into()).wait().unwrap().1, Ok(ping));
+	}
+
+	#[test]
+	fn test_read_payload_with_invalid_checksum() {
+		let raw: Bytes = "5845303b6da97786".into();
+		assert_eq!(read_payload::<Ping, _>(raw.as_ref(), 0, 8, "83c00c75".into()).wait().unwrap().1, Err(Error::InvalidChecksum));
+	}
+
+	#[test]
+	fn test_read_too_short_payload() {
+		let raw: Bytes = "5845303b6da977".into();
+		assert!(read_payload::<Ping, _>(raw.as_ref(), 0, 8, "83c00c76".into()).wait().is_err());
+	}
+}