Parallelize test suite (#173)

Author: kyeah

.travis.yml

@@ -10,16 +10,11 @@ before_install:
     - tar xvf mongodb-linux-x86_64-3.2.10.tgz
     - mv mongodb-linux-x86_64-3.2.10 3.2.10
 
-env:
-    - RUST_TEST_THREADS=1
-
 script:
-    - mkdir -p ./data/db ./data/test ./data/db2 ./data/test2
+    - mkdir -p ./data/db ./data/db2
     - 3.0.12/bin/mongod --fork --nopreallocj --dbpath ./data/db --syslog --port 27017
-    - 3.0.12/bin/mongod --fork --nopreallocj --dbpath ./data/test --syslog --port 27018
     - cargo build --verbose
     - cargo test --verbose
     - killall mongod
     - 3.2.10/bin/mongod --fork --nopreallocj --dbpath ./data/db2 --syslog --port 27017
-    - 3.2.10/bin/mongod --fork --nopreallocj --dbpath ./data/test2 --syslog --port 27018
     - cargo test --verbose

tests/apm/mod.rs

@@ -27,8 +27,8 @@ fn timed_query(_client: Client, command_result: &CommandResult) {
 #[test]
 fn command_duration() {
     let mut client = Client::connect("localhost", 27017).expect("damn it!");
-    let db = client.db("test");
-    let coll = db.collection("event_hooks");
+    let db = client.db("test-apm-mod");
+    let coll = db.collection("command_duration");
     coll.drop().unwrap();
 
     let docs = (1..4).map(|i| doc! { "_id" => i, "x" => (rand::random::<u8>() as u32) }).collect();
@@ -54,16 +54,23 @@ fn read_first_non_monitor_line(file: &mut BufReader<&File>, line: &mut String) {
 
 #[test]
 fn logging() {
-    let _ = fs::remove_file("test_log.txt");
+    let _ = fs::remove_file("test_apm_log.txt");
 
-    let client_options = ClientOptions::with_log_file("test_log.txt");
+    // Reset State
+    let reset_client = Client::connect("localhost", 27017).expect("Failed to connect to localhost:27017");
+    let reset_db = reset_client.db("test-apm-mod");
+    let reset_coll = reset_db.collection("logging");
+    reset_coll.drop().unwrap();
+
+    // Start logging
+    let client_options = ClientOptions::with_log_file("test_apm_log.txt");
     let client = Client::connect_with_options("localhost", 27017, client_options).unwrap();
 
-    let db = client.db("test");
-    db.create_collection("logging", None).unwrap();
+    let db = client.db("test-apm-mod");
     let coll = db.collection("logging");
+    db.create_collection("logging", None).unwrap();
     coll.drop().unwrap();
-
+    
     let doc1 = doc! { "_id" => 1 };
     let doc2 = doc! { "_id" => 2 };
     let doc3 = doc! { "_id" => 3 };
@@ -78,7 +85,7 @@ fn logging() {
 
     coll.find(Some(filter), None).unwrap();
 
-    let f = File::open("test_log.txt").unwrap();
+    let f = File::open("test_apm_log.txt").unwrap();
     let mut file = BufReader::new(&f);
     let mut line = String::new();
 
@@ -88,7 +95,7 @@ fn logging() {
                 capped: false, auto_index_id: true, flags: 1 }\n",
                &line);
 
-    // Create Collection completed
+    // Create collection completed
     line.clear();
     read_first_non_monitor_line(&mut file, &mut line);
     assert!(line.starts_with("COMMAND.create_collection 127.0.0.1:27017 COMPLETED: { ok: 1 } ("));
@@ -104,7 +111,7 @@ fn logging() {
     line.clear();
     read_first_non_monitor_line(&mut file, &mut line);
     assert!(line.starts_with("COMMAND.drop_collection 127.0.0.1:27017 COMPLETED: { ns: \
-                              \"test.logging\", nIndexesWas: 1, ok: 1 } ("));
+                              \"test-apm-mod.logging\", nIndexesWas: 1, ok: 1 } ("));
     assert!(line.ends_with(" ns)\n"));
 
     // First insert started
@@ -157,11 +164,11 @@ fn logging() {
     line.clear();
     read_first_non_monitor_line(&mut file, &mut line);
     assert!(line.starts_with("COMMAND.find 127.0.0.1:27017 COMPLETED: { cursor: { id: 0, ns: \
-                              \"test.logging\", firstBatch: [{ _id: 2 }, { _id: 3 }] }, ok: 1 } \
+                              \"test-apm-mod.logging\", firstBatch: [{ _id: 2 }, { _id: 3 }] }, ok: 1 } \
                               ("));
     assert!(line.ends_with(" ns)\n"));
 
     coll.drop().unwrap();
 
-    fs::remove_file("test_log.txt").unwrap();
+    fs::remove_file("test_apm_log.txt").unwrap();
 }

tests/auth/mod.rs

@@ -3,11 +3,24 @@ use mongodb::{CommandType, Client, ThreadedClient};
 use mongodb::db::ThreadedDatabase;
 use mongodb::error::Error::OperationError;
 
+fn doc_vec_find(vec: &Vec<Bson>, key: &str, val: &str) -> Option<Bson> {
+    vec.iter()
+       .cloned()
+       .find(|ref bdoc| match bdoc {
+           &&Bson::Document(ref doc) => match doc.get(key) {
+               Some(&Bson::String(ref s)) => s == val,
+               _ => false
+           },
+           _ => false,
+       })
+       .map(|ref bson| bson.to_owned())
+}
+
 #[test]
 fn invalid_user() {
     let client = Client::connect("localhost", 27017).unwrap();
-    let db = client.db("auth");
-    let _ = db.drop_all_users(None).unwrap();
+    let db = client.db("test-auth-mod-invalid_user");
+    let _ = db.drop_user("test-auth-mod-invalid_user-saghm", None);
     let doc = doc! { "connectionStatus" => 1};
     let before = db.command(doc.clone(), CommandType::Suppressed, None).unwrap();
 
@@ -17,11 +30,11 @@ fn invalid_user() {
     };
 
     match info.get("authenticatedUsers") {
-        Some(&Bson::Array(ref vec)) => assert!(vec.is_empty()),
+        Some(&Bson::Array(ref vec)) => assert!(doc_vec_find(&vec, "user", "test-auth-mod-invalid_user-saghm").is_none()),
         _ => panic!("Invalid array of authenticatedUsers for initial connectionStatus command"),
     };
 
-    match db.auth("invalid_user", "some_password") {
+    match db.auth("test-auth-mod-invalid_user-saghm", "some_password") {
         Err(OperationError(_)) => (),
         Err(_) => {
             panic!("Expected OperationError for invalid authentication, but got some other error \
@@ -36,19 +49,18 @@ fn invalid_user() {
         Some(&Bson::Document(ref doc)) => doc.clone(),
         _ => panic!("Invalid response for subsequent connectionStatus command"),
     };
-
+        
     match info.get("authenticatedUsers") {
-        Some(&Bson::Array(ref vec)) => assert!(vec.is_empty()),
-        _ => panic!("Invalid array of authenticatedUsers for subsequent connectionStatus command"),
+        Some(&Bson::Array(ref vec)) => assert!(doc_vec_find(&vec, "user", "test-auth-mod-invalid_user-saghm").is_none()),
+        _ => panic!("Invalid array of authenticatedUsers for initial connectionStatus command"),
     };
 }
 
-
 #[test]
 fn invalid_password() {
     let client = Client::connect("localhost", 27017).unwrap();
-    let db = client.db("auth");
-    let _ = db.drop_all_users(None).unwrap();
+    let db = client.db("test-auth-mod-invalid_password");
+    let _ = db.drop_user("test-auth-mod-invalid_password-saghm", None);
     let doc = doc! { "connectionStatus" => 1};
     let before = db.command(doc.clone(), CommandType::Suppressed, None).unwrap();
 
@@ -58,13 +70,13 @@ fn invalid_password() {
     };
 
     match info.get("authenticatedUsers") {
-        Some(&Bson::Array(ref vec)) => assert!(vec.is_empty()),
+        Some(&Bson::Array(ref vec)) => assert!(doc_vec_find(&vec, "user", "test-auth-mod-invalid_password-saghm").is_none()),
         _ => panic!("Invalid array of authenticatedUsers for initial connectionStatus command"),
     };
 
-    db.create_user("saghm", "such_secure_password", None).unwrap();
+    db.create_user("test-auth-mod-invalid_password-saghm", "such_secure_password", None).unwrap();
 
-    match db.auth("saghm", "wrong_password") {
+    match db.auth("test-auth-mod-invalid_password-saghm", "wrong_password") {
         Err(OperationError(_)) => (),
         Err(_) => {
             panic!("Expected OperationError for invalid authentication, but got some other error \
@@ -81,16 +93,16 @@ fn invalid_password() {
     };
 
     match info.get("authenticatedUsers") {
-        Some(&Bson::Array(ref vec)) => assert!(vec.is_empty()),
+        Some(&Bson::Array(ref vec)) => assert!(doc_vec_find(&vec, "user", "test-auth-mod-invalid_password-saghm").is_none()),
         _ => panic!("Invalid array of authenticatedUsers for subsequent connectionStatus command"),
     };
 }
 
 #[test]
 fn successful_login() {
     let client = Client::connect("localhost", 27017).unwrap();
-    let db = client.db("auth");
-    let _ = db.drop_all_users(None).unwrap();
+    let db = client.db("test-auth-mod-successful_login");
+    let _ = db.drop_user("test-auth-mod-successful_login-saghm", None);
     let doc = doc! { "connectionStatus" => 1};
     let before = db.command(doc.clone(), CommandType::Suppressed, None).unwrap();
 
@@ -100,12 +112,12 @@ fn successful_login() {
     };
 
     match info.get("authenticatedUsers") {
-        Some(&Bson::Array(ref vec)) => assert!(vec.is_empty()),
+        Some(&Bson::Array(ref vec)) => assert!(doc_vec_find(&vec, "user", "test-auth-mod-successful_login-saghm").is_none()),
         _ => panic!("Invalid array of authenticatedUsers for initial connectionStatus command"),
     };
 
-    db.create_user("saghm", "such_secure_password", None).unwrap();
-    db.auth("saghm", "such_secure_password").unwrap();
+    db.create_user("test-auth-mod-successful_login-saghm", "such_secure_password", None).unwrap();
+    db.auth("test-auth-mod-successful_login-saghm", "such_secure_password").unwrap();
 
     let after = db.command(doc, CommandType::Suppressed, None).unwrap();
 
@@ -119,20 +131,20 @@ fn successful_login() {
         _ => panic!("Invalid array of authenticatedUsers for subsequent connectionStatus command"),
     };
 
-    assert_eq!(authed_users.len(), 1);
+    let bson_user = doc_vec_find(&authed_users, "user", "test-auth-mod-successful_login-saghm").unwrap();
 
-    let user = match authed_users[0] {
+    let user = match bson_user {
         Bson::Document(ref doc) => doc.clone(),
         _ => panic!("Invalid auth'd user in subsequent connectionStatus response"),
     };
 
     match user.get("user") {
-        Some(&Bson::String(ref s)) => assert_eq!(s, "saghm"),
+        Some(&Bson::String(ref s)) => assert_eq!(s, "test-auth-mod-successful_login-saghm"),
         _ => panic!("Invalid `user` field of auth'd user"),
     };
 
     match user.get("db") {
-        Some(&Bson::String(ref s)) => assert_eq!(s, "auth"),
+        Some(&Bson::String(ref s)) => assert_eq!(s, "test-auth-mod-successful_login"),
         _ => panic!("Invalid `db` field of auth'd user"),
     };
 }

tests/client/bulk.rs

@@ -6,9 +6,8 @@ use mongodb::db::ThreadedDatabase;
 #[test]
 fn bulk_ordered_insert_only() {
     let client = Client::connect("localhost", 27017).unwrap();
-    let db = client.db("test");
+    let db = client.db("test-client-bulk");
     let coll = db.collection("bulk_ordered_insert_only");
-
     coll.drop().unwrap();
 
     let models = (1..5)
@@ -47,7 +46,7 @@ fn bulk_ordered_insert_only() {
 #[test]
 fn bulk_unordered_insert_only() {
     let client = Client::connect("localhost", 27017).unwrap();
-    let db = client.db("test");
+    let db = client.db("test-client-bulk");
     let coll = db.collection("bulk_unordered_insert_only");
 
     coll.drop().unwrap();
@@ -148,9 +147,8 @@ fn bulk_ordered_mix() {
     ];
 
     let client = Client::connect("localhost", 27017).unwrap();
-    let db = client.db("test");
+    let db = client.db("test-client-bulk");
     let coll = db.collection("bulk_ordered_mix");
-
     coll.drop().unwrap();
 
     let result = coll.bulk_write(models, true);