Add additional From traits, update macro tests to check validity of document

Author: kyeah

src/bson.rs

@@ -54,6 +54,12 @@ pub type Array = Vec<Bson>;
 /// Alias for `OrderedDocument`.
 pub type Document = OrderedDocument;
 
+impl From<f32> for Bson {
+    fn from(a: f32) -> Bson {
+        Bson::FloatingPoint(a as f64)
+    }
+}
+
 impl From<f64> for Bson {
     fn from(a: f64) -> Bson {
         Bson::FloatingPoint(a)
@@ -123,6 +129,18 @@ impl From<i64> for Bson {
     }
 }
 
+impl From<u32> for Bson {
+    fn from(a: u32) -> Bson {
+        Bson::I32(a as i32)
+    }
+}
+
+impl From<u64> for Bson {
+    fn from(a: u64) -> Bson {
+        Bson::I64(a as i64)
+    }
+}
+
 impl From<[u8; 12]> for Bson {
     fn from(a: [u8; 12]) -> Bson {
         Bson::ObjectId(oid::ObjectId::with_bytes(a))

tests/modules/macros.rs

@@ -1,54 +1,4 @@
-use bson::{self, Bson, Document};
-
-fn print_doc_with_indent_level(doc: &Document, n: i32) {
-    macro_rules! print_spaces {
-        ( $n:expr ) => {
-            for _ in 0..$n {
-                print!(" ");
-            }
-        };
-    }
-
-    println!("{{");
-
-    for (key, value) in doc.iter() {
-        print_spaces!(n + 4);
-        print!("{}: ", key);
-
-        print_bson_with_indent_level(value, n);
-        println!("");
-    }
-
-    print_spaces!(n);
-    println!("}}");
-}
-
-#[macro_export]
-macro_rules! print_doc {
-    ( $doc:expr ) => {
-        print_doc_with_indent_level($doc, 0)
-    };
-}
-
-fn print_bson_with_indent_level(bson: &Bson, n: i32) {
-    match bson {
-        &Bson::Document(ref d) => print_doc_with_indent_level(&d, n + 4),
-        &Bson::String(ref s) => print!("\"{}\",", s),
-        &Bson::Boolean(b) => print!("{},", b),
-        &Bson::Array(ref v) => {
-            print!("[ ");
-
-            for b in v {
-                print_bson_with_indent_level(b, n);
-                print!(" ");
-            }
-
-            print!("]");
-        },
-        ref bson => print!("{:?},", bson)
-    };
-}
-
+use bson::Bson;
 
 #[test]
 fn recursive_macro() {
@@ -64,5 +14,60 @@ fn recursive_macro() {
         "c" => [-7]
     };
 
-    print_doc!(&doc);
+    match doc.get("a") {
+        Some(&Bson::String(ref s)) => assert_eq!("foo", s),
+        _ => panic!("String 'foo' was not inserted correctly."),
+    }
+
+    // Inner Doc 1
+    match doc.get("b") {
+        Some(&Bson::Document(ref doc)) => {
+
+            // Inner doc 2
+            match doc.get("bar") {
+                Some(&Bson::Document(ref inner_doc)) => {
+
+                    // Inner array
+                    match inner_doc.get("harbor") {
+                        Some(&Bson::Array(ref arr)) => {
+                            assert_eq!(2, arr.len());
+
+                            // Match array items
+                            match arr[0] {
+                                Bson::String(ref s) => assert_eq!("seal", s),
+                                _ => panic!("String 'seal' was not inserted into inner array correctly."),
+                            }
+                            match arr[1] {
+                                Bson::Boolean(ref b) => assert!(!b),
+                                _ => panic!("Boolean 'false' was not inserted into inner array correctly."),
+                            }
+                        },
+                        _ => panic!("Inner array was not inserted correctly."),
+                    }
+
+                    // Inner floating point
+                    match inner_doc.get("jelly") {
+                        Some(&Bson::FloatingPoint(ref fp)) => assert_eq!(42.0, *fp),
+                        _ => panic!("Floating point 42.0 was not inserted correctly."),
+                    }
+                },
+                _ => panic!("Second inner document was not inserted correctly."),
+            }
+        },
+        _ => panic!("Inner document was not inserted correctly."),
+    }
+
+    // Outer array
+    match doc.get("c") {
+        Some(&Bson::Array(ref arr)) => {
+            assert_eq!(1, arr.len());
+
+            // Integer type
+            match arr[0] {
+                Bson::I32(ref i) => assert_eq!(-7, *i),
+                _ => panic!("I32 '-7' was not inserted correctly."),
+            }
+        },
+        _ => panic!("Array was not inserted correctly."),
+    }
 }