Merge pull request maidsafe-archive#23 from vtnerd/master

Tested ImmutableData

src/data/immutable_data.rs

@@ -15,6 +15,7 @@
 
     See the Licences for the specific language governing permissions and limitations relating to
     use of the MaidSafe Software.                                                                 */
+
 extern crate rustc_serialize;
 extern crate sodiumoxide;
 extern crate cbor;
@@ -34,111 +35,120 @@ use Random;
 ///
 /// ```
 /// // Create an ImmutableData using the new function.
-/// let immutable_data = maidsafe_types::ImmutableData::new(maidsafe_types::NameType([0u8; 64]),  vec![99u8; 10]);
+/// use maidsafe_types::traits::RoutingTrait;
+/// let immutable_data = maidsafe_types::ImmutableData::new(vec![99u8; 10]);
 /// // Retrieving values
 /// let ref name_type = immutable_data.get_name();
 /// let ref value = immutable_data.get_value();
 /// ```
 ///
 #[derive(Clone)]
 pub struct ImmutableData {
-	name: NameType,
-	value: Vec<u8>,
+    value: Vec<u8>,
 }
 
 impl RoutingTrait for ImmutableData {
-	fn get_name(&self) -> NameType {
-        let digest = crypto::hash::sha512::hash(&self.name.0);
-        NameType(digest.0)
-	}
+    fn get_name(&self) -> NameType {
+        self.calculate_name()
+    }
 }
 
 impl PartialEq for ImmutableData {
     fn eq(&self, other: &ImmutableData) -> bool {
-        self.name == other.name && self.value == other.value
+        self.value == other.value
     }
 }
 
 impl fmt::Debug for ImmutableData {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "ImmutableData( name: {:?}, value: {:?}", self.name, self.value)
+        write!(f, "ImmutableData( name: {:?}, value: {:?} )", self.calculate_name(), self.value)
     }
 }
 
 impl ImmutableData {
-	#[allow(dead_code)]
-	pub fn new(name: NameType, value: Vec<u8>) -> ImmutableData {
-		ImmutableData {
-    		name: name,
-    		value: value,
-		}
-	}
-
-	pub fn get_name(&self) -> &NameType {
-		&self.name
-	}
-
-	pub fn get_value(&self) -> &Vec<u8> {
-		&self.value
-	}
+    pub fn new(value: Vec<u8>) -> ImmutableData {
+        ImmutableData {
+            value: value,
+        }
+    }
 
+    // debug cannot call RoutingTrait due to current visibility
+    fn calculate_name(&self) -> NameType {
+        let digest = crypto::hash::sha512::hash(&self.value);
+        NameType(digest.0)
+    }
+
+    pub fn get_value(&self) -> &Vec<u8> {
+        &self.value
+    }
 }
 
 #[allow(unused_variables)]
 impl Random for ImmutableData {
-    fn generate_random() -> ImmutableData {     
-        let mut data = Vec::with_capacity(64);         
-        for i in 0..data.len() {
-            data.push(rand::random::<u8>());
-        }
-        ImmutableData {            
-            name: NameType::generate_random(),
-            value: data,
+    fn generate_random() -> ImmutableData {
+        use rand::Rng;
+        let size = 64;
+        let mut data = Vec::with_capacity(size);
+        let mut rng = rand::thread_rng();
+        for i in 0..size {
+            data.push(rng.gen());
         }
+        ImmutableData::new(data)
     }
 }
 
 impl Encodable for ImmutableData {
-	fn encode<E: Encoder>(&self, e: &mut E)->Result<(), E::Error> {
-		CborTagEncode::new(5483_001, &(&self.name, &self.value)).encode(e)
-	}
+    fn encode<E: Encoder>(&self, e: &mut E)->Result<(), E::Error> {
+        CborTagEncode::new(5483_001, &(&self.value)).encode(e)
+    }
 }
 
 impl Decodable for ImmutableData {
-	fn decode<D: Decoder>(d: &mut D)->Result<ImmutableData, D::Error> {
-		try!(d.read_u64());
-		let (name, value) = try!(Decodable::decode(d));
-		Ok(ImmutableData::new(name, value))
-	}
+    fn decode<D: Decoder>(d: &mut D)->Result<ImmutableData, D::Error> {
+        try!(d.read_u64());
+        let value = try!(Decodable::decode(d));
+        Ok(ImmutableData::new(value))
+    }
 }
+
 #[cfg(test)]
-mod test {    
+mod test {
     use super::*;
     use cbor::{ Encoder, Decoder};
     use rustc_serialize::{Decodable, Encodable};
     use Random;
-
+
+    #[test]
+    fn creation() {
+        use rustc_serialize::hex::ToHex;
+        let data = "this is a known string".to_string().into_bytes();
+        let expected_name = "8758b09d420bdb901d68fdd6888b38ce9ede06aad7f\
+                             e1e0ea81feffc76260554b9d46fb6ea3b169ff8bb02\
+                             ef14a03a122da52f3063bcb1bfb22cffc614def522".to_string();
+        let chunk = ImmutableData::new(data);
+        let actual_name = chunk.calculate_name().0.as_ref().to_hex();
+        assert_eq!(&expected_name, &actual_name);
+    }
+
     #[test]
     fn serialisation_immutable_data() {
-    	let obj_before = ImmutableData::generate_random();
-    	let mut e = Encoder::from_memory();
-    	e.encode(&[&obj_before]).unwrap();
-    
-    	let mut d = Decoder::from_bytes(e.as_bytes());
-    	let obj_after: ImmutableData = d.decode().next().unwrap().unwrap();
-    	    	
-    	assert_eq!(obj_before, obj_after);
+        let obj_before = ImmutableData::generate_random();
+        let mut e = Encoder::from_memory();
+        e.encode(&[&obj_before]).unwrap();
+
+        let mut d = Decoder::from_bytes(e.as_bytes());
+        let obj_after: ImmutableData = d.decode().next().unwrap().unwrap();
+
+        assert_eq!(obj_before, obj_after);
     }
-    
+
     #[test]
     fn equality_assertion_immutable_data() {
         let first_obj = ImmutableData::generate_random();
         let second_obj = ImmutableData::generate_random();
         let cloned_obj = second_obj.clone();
-        
+
         assert!(first_obj != second_obj);
-        assert!(second_obj == cloned_obj);    
+        assert!(second_obj == cloned_obj);
     }
-
-
 }