Extracting bytes function into its own utility

src/commands/run.rs

@@ -3,6 +3,7 @@ use crate::clients::directory::presence::{MixNodePresence, Topology};
 use crate::clients::directory::requests::presence_topology_get::PresenceTopologyGetRequester;
 use crate::clients::directory::DirectoryClient;
 use crate::clients::mix::MixClient;
+use crate::utils::bytes;
 use base64;
 use clap::ArgMatches;
 use curve25519_dalek::montgomery::MontgomeryPoint;
@@ -71,9 +72,9 @@ fn route_from(topology: &Topology, route_len: usize) -> Vec<SphinxNode> {
     let mut route = vec![];
     let nodes = topology.mix_nodes.iter();
     for mix in nodes.take(route_len) {
-        let address_bytes = zero_pad_to_32_bytes(mix.host.as_bytes().to_vec());
+        let address_bytes = bytes::zero_pad_to_32(mix.host.as_bytes().to_vec());
         let decoded_key_bytes = base64::decode_config(&mix.pub_key, base64::URL_SAFE).unwrap();
-        let key_bytes = zero_pad_to_32_bytes(decoded_key_bytes);
+        let key_bytes = bytes::zero_pad_to_32(decoded_key_bytes);
         let key = MontgomeryPoint(key_bytes);
         let sphinx_node = SphinxNode {
             address: address_bytes,
@@ -84,17 +85,6 @@ fn route_from(topology: &Topology, route_len: usize) -> Vec<SphinxNode> {
     route
 }
 
-fn zero_pad_to_32_bytes(mut bytes: Vec<u8>) -> [u8; 32] {
-    assert!(bytes.len() <= 32);
-    if bytes.len() != 32 {
-        bytes.resize(32, 0);
-    }
-    let mut padded_bytes = [0; 32];
-    padded_bytes.copy_from_slice(&bytes[..]);
-    assert!(padded_bytes.len() == 32);
-    padded_bytes
-}
-
 // TODO: where do we retrieve this guy from?
 fn get_destination() -> Destination {
     Destination {

src/main.rs

@@ -3,6 +3,7 @@ use std::process;
 
 mod clients;
 mod commands;
+mod utils;
 
 fn main() {
     let arg_matches = App::new("Nym Client")

src/utils/bytes.rs

@@ -0,0 +1,64 @@
+pub fn zero_pad_to_32(mut bytes: Vec<u8>) -> [u8; 32] {
+    assert!(bytes.len() <= 32);
+    if bytes.len() != 32 {
+        bytes.resize(32, 0);
+    }
+    let mut padded_bytes = [0; 32];
+    padded_bytes.copy_from_slice(&bytes[..]);
+    assert!(padded_bytes.len() == 32);
+    padded_bytes
+}
+
+#[cfg(test)]
+mod zero_padding_to_32_bytes {
+    use super::*;
+
+    #[cfg(test)]
+    mod with_empty_input {
+        use super::*;
+
+        #[test]
+        fn it_returns_32_zeros() {
+            let input = vec![];
+            let result = zero_pad_to_32(input);
+            assert_eq!([0u8; 32], result);
+        }
+    }
+
+    #[cfg(test)]
+    mod with_all_bytes_set_to_1 {
+        use super::*;
+        #[test]
+        fn it_returns_32_ones() {
+            let input = vec![1u8; 32];
+            let result = zero_pad_to_32(input);
+            assert_eq!([1u8; 32], result);
+        }
+    }
+
+    #[cfg(test)]
+    mod with_3_bytes_set {
+        use super::*;
+        #[test]
+        fn it_returns_input_zero_padded_to_32_bytes() {
+            let input = vec![1u8; 3];
+            let result = zero_pad_to_32(input);
+            let expected_content = vec![
+                1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0,
+            ];
+            assert_eq!(expected_content, result.to_vec());
+        }
+    }
+
+    #[cfg(test)]
+    mod with_oversized_input {
+        use super::*;
+        #[test]
+        #[should_panic]
+        fn it_panics() {
+            let input = vec![1u8; 33];
+            zero_pad_to_32(input);
+        }
+    }
+}

src/utils/mod.rs

@@ -0,0 +1 @@
+pub mod bytes;