mongodb 0.3.5

use bson::Bson;

use mongodb::{Client, ThreadedClient};
use mongodb::db::ThreadedDatabase;
use mongodb::coll::options::{FindOptions, FindOneAndUpdateOptions, IndexModel, IndexOptions,
                             ReturnDocument};

#[test]
fn find_sorted() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("find_sorted");

    coll.drop().expect("Failed to drop collection");

    // Insert document
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };
    let doc3 = doc! { "title" => "Dobby" };

    coll.insert_many(vec![doc1.clone(), doc2.clone(), doc3.clone()], None)
        .expect("Failed to insert documents.");

    // Find document
    let mut opts = FindOptions::new();
    opts.sort = Some(doc! { "title" => 1 });

    let mut cursor = coll.find(None, Some(opts)).expect("Failed to execute find command.");
    let results = cursor.next_n(3).expect("Failed to retrieve documents.");

    // Assert expected titles of documents
    match results[0].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Back to the Future", title),
        _ => panic!("Expected Bson::String!"),
    };

    match results[1].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Dobby", title),
        _ => panic!("Expected Bson::String!"),
    };

    match results[2].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Jaws", title),
        _ => panic!("Expected Bson::String!"),
    };


    assert!(cursor.next().is_none());
}

#[test]
fn find_and_insert() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("find_and_insert");

    coll.drop().expect("Failed to drop collection");

    // Insert document
    let doc = doc! { "title" => "Jaws" };
    coll.insert_one(doc, None).expect("Failed to insert document");

    // Find document
    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let result = match cursor.next() {
        Some(Ok(res)) => res,
        Some(Err(_)) => panic!("Received error from 'cursor.next()'."),
        None => panic!("Expected bson."),
    };

    // Assert expected title of document
    match result.get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Jaws", title),
        _ => panic!("Expected Bson::String!"),
    };

    assert!(cursor.next().is_none());
}

#[test]
fn find_and_insert_one() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("find_and_insert_one");

    coll.drop().expect("Failed to drop database");

    // Insert document
    let doc = doc! { "title" => "Jaws" };
    coll.insert_one(doc, None).expect("Failed to insert document");

    // Find single document
    let result = coll.find_one(None, None).expect("Failed to execute find command.");
    assert!(result.is_some());

    // Assert expected title of document
    match result.unwrap().get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Jaws", title),
        _ => panic!("Expected Bson::String!"),
    };
}

#[test]
fn find_one_and_delete() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("find_one_and_delete");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };

    coll.insert_many(vec![doc1.clone(), doc2.clone()], None)
        .expect("Failed to insert documents.");

    // Find and Delete document
    let result = coll.find_one_and_delete(doc2.clone(), None)
        .expect("Failed to execute find_one_and_delete command.");

    match result.unwrap().get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Back to the Future", title),
        _ => panic!("Expected Bson::String!"),
    }

    // Validate state of collection
    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let result = match cursor.next() {
        Some(Ok(res)) => res,
        Some(Err(_)) => panic!("Received error from 'cursor.next()'."),
        None => panic!("Expected bson."),
    };

    match result.get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Jaws", title),
        _ => panic!("Expected Bson::String!"),
    }

    assert!(cursor.next().is_none());
}

#[test]
fn find_one_and_replace() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("find_one_and_replace");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };
    let doc3 = doc! { "title" => "12 Angry Men" };

    coll.insert_many(vec![doc1.clone(), doc2.clone(), doc3.clone()], None)
        .expect("Failed to insert documents into collection.");

    // Replace single document
    let result = coll.find_one_and_replace(doc2.clone(), doc3.clone(), None)
        .expect("Failed to execute find_one_and_replace command.");

    match result.unwrap().get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Back to the Future", title),
        _ => panic!("Expected Bson::String!"),
    }

    // Validate state of collection
    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let results = cursor.next_n(3).expect("Failed to get next 3 from cursor.");
    assert_eq!(3, results.len());

    // Assert expected title of documents
    match results[0].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Jaws", title),
        _ => panic!("Expected Bson::String!"),
    };
    match results[1].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("12 Angry Men", title),
        _ => panic!("Expected Bson::String!"),
    };
    match results[2].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("12 Angry Men", title),
        _ => panic!("Expected Bson::String!"),
    };

    // Replace with 'new' option
    let mut opts = FindOneAndUpdateOptions::new();
    opts.return_document = Some(ReturnDocument::After);
    let result = coll.find_one_and_replace(doc3.clone(), doc2.clone(), Some(opts))
        .expect("Failed to execute find_one_and_replace command.");

    match result.unwrap().get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Back to the Future", title),
        _ => panic!("Expected Bson::String!"),
    }
}

#[test]
fn find_one_and_update() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("find_one_and_update");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };
    let doc3 = doc! { "title" => "12 Angry Men" };

    coll.insert_many(vec![doc1.clone(), doc2.clone(), doc3.clone()], None)
        .expect("Failed to insert documents into collection.");

    // Update single document
    let update = doc! { "$set" => { "director" => "Robert Zemeckis" } };

    let result = coll.find_one_and_update(doc2.clone(), update, None)
        .expect("Failed to execute find_one_and_update command.");

    match result.unwrap().get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Back to the Future", title),
        _ => panic!("Expected Bson::String!"),
    }

    // Validate state of collection
    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let results = cursor.next_n(3).expect("Failed to get next 3 from cursor.");
    assert_eq!(3, results.len());

    // Assert director attributes
    assert!(results[0].get("director").is_none());
    assert!(results[2].get("director").is_none());
    match results[1].get("director") {
        Some(&Bson::String(ref director)) => assert_eq!("Robert Zemeckis", director),
        _ => panic!("Expected Bson::String!"),
    }
}

#[test]
fn aggregate() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("aggregate");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "tags" => ["a", "b", "c"] };
    let doc2 = doc! { "tags" => ["a", "b", "d"] };
    let doc3 = doc! { "tags" => ["d", "e", "f"] };

    coll.insert_many(vec![doc1.clone(), doc2.clone(), doc3.clone()], None)
        .expect("Failed to execute insert_many command.");

    // Build aggregation pipeline to unwind tag arrays and group distinct tags
    let project = doc! { "$project" => { "tags" => 1 } };
    let unwind = doc! { "$unwind" => ("$tags") };
    let group = doc! { "$group" => { "_id" => "$tags" } };

    // Aggregate
    let mut cursor = coll.aggregate(vec![project, unwind, group], None)
        .expect("Failed to execute aggregate command.");

    let results = cursor.next_n(10).expect("Failed to get next 10 from cursor.");
    assert_eq!(6, results.len());

    // Grab ids from aggregated docs
    let vec: Vec<_> = results.iter()
        .filter_map(|bdoc| match bdoc.get("_id") {
            Some(&Bson::String(ref tag)) => Some(tag.to_owned()),
            _ => None,
        })
        .collect();

    // Validate that all distinct tags were received.
    assert_eq!(6, vec.len());
    assert!(vec.contains(&"a".to_owned()));
    assert!(vec.contains(&"b".to_owned()));
    assert!(vec.contains(&"c".to_owned()));
    assert!(vec.contains(&"d".to_owned()));
    assert!(vec.contains(&"e".to_owned()));
    assert!(vec.contains(&"f".to_owned()));
}

#[test]
fn count() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("count");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };

    let mut vec = vec![doc1.clone()];
    for _ in 0..10 {
        vec.push(doc2.clone());
    }

    coll.insert_many(vec, None).expect("Failed to insert documents.");
    let count_doc1 = coll.count(Some(doc1), None).expect("Failed to execute count.");
    assert_eq!(1, count_doc1);

    let count_doc2 = coll.count(Some(doc2), None).expect("Failed to execute count.");
    assert_eq!(10, count_doc2);

    let count_all = coll.count(None, None).expect("Failed to execute count.");
    assert_eq!(11, count_all);

    let no_doc = doc! { "title" => "Houdini" };
    let count_none = coll.count(Some(no_doc), None).expect("Failed to execute count.");
    assert_eq!(0, count_none);
}

#[test]
fn distinct_none() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("distinct_none");

    coll.drop().expect("Failed to drop database");
    let distinct_titles = coll.distinct("title", None, None)
        .expect("Failed to execute 'distinct'.");
    assert_eq!(0, distinct_titles.len());
}

#[test]
fn distinct_one() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("distinct_one");

    coll.drop().expect("Failed to drop database");
    let doc2 = doc! { "title" => "Back to the Future" };
    coll.insert_one(doc2, None).expect("Failed to insert document.");

    let distinct_titles = coll.distinct("title", None, None)
        .expect("Failed to execute 'distinct'.");
    assert_eq!(1, distinct_titles.len());
}

#[test]
fn distinct() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("distinct");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws",
                      "director" => "MB" };

    let doc2 = doc! { "title" => "Back to the Future" };

    let doc3 = doc! { "title" => "12 Angry Men",
                      "director" => "MB" };

    let mut vec = vec![doc1.clone()];
    for _ in 0..4 {
        vec.push(doc2.clone());
    }
    for _ in 0..60 {
        vec.push(doc3.clone());
    }

    coll.insert_many(vec, None).expect("Failed to insert documents.");

    // Distinct titles over all documents
    let distinct_titles = coll.distinct("title", None, None)
        .expect("Failed to execute 'distinct'.");
    assert_eq!(3, distinct_titles.len());

    let titles: Vec<_> = distinct_titles.iter()
        .filter_map(|bson| match *bson {
            Bson::String(ref title) => Some(title.to_owned()),
            _ => None,
        })
        .collect();

    assert_eq!(3, titles.len());
    assert!(titles.contains(&"Jaws".to_owned()));
    assert!(titles.contains(&"Back to the Future".to_owned()));
    assert!(titles.contains(&"12 Angry Men".to_owned()));

    // Distinct titles over documents with certain director
    let filter = doc! { "director" => "MB" };
    let distinct_titles = coll.distinct("title", Some(filter), None)
        .expect("Failed to execute 'distinct'.");

    assert_eq!(2, distinct_titles.len());

    let titles: Vec<_> = distinct_titles.iter()
        .filter_map(|bson| match *bson {
            Bson::String(ref title) => Some(title.to_owned()),
            _ => None,
        })
        .collect();

    assert_eq!(2, titles.len());
    assert!(titles.contains(&"Jaws".to_owned()));
    assert!(titles.contains(&"12 Angry Men".to_owned()));
}

#[test]
fn insert_many() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("insert_many");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };

    coll.insert_many(vec![doc1, doc2], None).expect("Failed to insert documents.");

    // Find documents
    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let results = cursor.next_n(2).expect("Failed to get next 2 from cursor.");
    assert_eq!(2, results.len());

    // Assert expected title of documents
    match results[0].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Jaws", title),
        _ => panic!("Expected Bson::String!"),
    }
    match results[1].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Back to the Future", title),
        _ => panic!("Expected Bson::String!"),
    }
}

#[test]
fn delete_one() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("delete_one");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };

    coll.insert_many(vec![doc1.clone(), doc2.clone()], None)
        .expect("Failed to insert documents.");

    // Delete document
    coll.delete_one(doc2.clone(), None).expect("Failed to delete document.");
    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let result = match cursor.next() {
        Some(Ok(res)) => res,
        Some(Err(_)) => panic!("Received error from 'cursor.next()'."),
        None => panic!("Expected bson."),
    };

    match result.get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Jaws", title),
        _ => panic!("Expected Bson::String!"),
    }

    assert!(cursor.next().is_none());
}

#[test]
fn delete_many() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("delete_many");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };

    coll.insert_many(vec![doc1.clone(), doc2.clone(), doc2.clone()], None)
        .expect("Failed to insert documents into collection.");

    // Delete document
    coll.delete_many(doc2.clone(), None).expect("Failed to delete documents.");
    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let result = match cursor.next() {
        Some(Ok(res)) => res,
        Some(Err(_)) => panic!("Received error from 'cursor.next()'."),
        None => panic!("Expected bson."),
    };

    match result.get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Jaws", title),
        _ => panic!("Expected Bson::String!"),
    }

    assert!(cursor.next().is_none());
}

#[test]
fn replace_one() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("replace_one");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };
    let doc3 = doc! { "title" => "12 Angry Men" };

    coll.insert_many(vec![doc1.clone(), doc2.clone(), doc3.clone()], None)
        .expect("Failed to insert documents into collection.");

    // Replace single document
    coll.replace_one(doc2.clone(), doc3.clone(), None).expect("Failed to replace document.");
    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let results = cursor.next_n(3).expect("Failed to get next 3 from cursor.");
    assert_eq!(3, results.len());

    // Assert expected title of documents
    match results[0].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("Jaws", title),
        _ => panic!("Expected Bson::String!"),
    };
    match results[1].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("12 Angry Men", title),
        _ => panic!("Expected Bson::String!"),
    };
    match results[2].get("title") {
        Some(&Bson::String(ref title)) => assert_eq!("12 Angry Men", title),
        _ => panic!("Expected Bson::String!"),
    };
}

#[test]
fn update_one() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("update_one");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };
    let doc3 = doc! { "title" => "12 Angry Men" };

    coll.insert_many(vec![doc1.clone(), doc2.clone(), doc3.clone()], None)
        .expect("Failed to insert documents into collection.");

    // Update single document
    let update = doc! { "$set" => { "director" => "Robert Zemeckis" } };

    coll.update_one(doc2.clone(), update, None).expect("Failed to update document.");

    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let results = cursor.next_n(3).expect("Failed to get next 3 from cursor.");
    assert_eq!(3, results.len());

    // Assert director attributes
    assert!(results[0].get("director").is_none());
    assert!(results[2].get("director").is_none());
    match results[1].get("director") {
        Some(&Bson::String(ref director)) => assert_eq!("Robert Zemeckis", director),
        _ => panic!("Expected Bson::String!"),
    }
}

#[test]
fn update_many() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("update_many");

    coll.drop().expect("Failed to drop database");

    // Insert documents
    let doc1 = doc! { "title" => "Jaws" };
    let doc2 = doc! { "title" => "Back to the Future" };
    let doc3 = doc! { "title" => "12 Angry Men" };

    coll.insert_many(vec![doc1.clone(), doc2.clone(), doc3.clone(), doc2.clone()],
                     None)
        .expect("Failed to insert documents into collection.");

    // Update single document
    let update = doc! { "$set" => { "director" => "Robert Zemeckis" } };

    coll.update_many(doc2.clone(), update, None).expect("Failed to update documents.");

    let mut cursor = coll.find(None, None).expect("Failed to execute find command.");
    let results = cursor.next_n(4).expect("Failed to get next 4 from cursor.");
    assert_eq!(4, results.len());

    // Assert director attributes
    assert!(results[0].get("director").is_none());
    assert!(results[2].get("director").is_none());

    match results[1].get("director") {
        Some(&Bson::String(ref director)) => assert_eq!("Robert Zemeckis", director),
        _ => panic!("Expected Bson::String for director!"),
    }

    match results[3].get("director") {
        Some(&Bson::String(ref director)) => assert_eq!("Robert Zemeckis", director),
        _ => panic!("Expected Bson::String for director!"),
    }
}

#[test]
fn create_list_drop_indexes() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("create_list_drop_indexes");

    coll.drop().expect("Failed to drop database.");

    let mut opts1 = IndexOptions::new();
    opts1.name = Some("nid".to_owned());

    // Test name option
    let index1 = IndexModel::new(doc!{ "n" => 1, "id" => 1}, Some(opts1));

    // Test negative value and index name generation
    let index2 = IndexModel::new(doc!{ "test" => (-1), "height" => 1}, None);

    coll.create_indexes(vec![index1, index2]).unwrap();
    let mut cursor = coll.list_indexes().unwrap();
    let results = cursor.next_n(5).unwrap();

    assert_eq!(3, results.len());

    // Assert first inserted index
    match results[1].get("key") {
        Some(&Bson::Document(ref keys)) => {
            match keys.get("n") {
                Some(&Bson::I32(ref i)) => assert_eq!(1, *i),
                _ => panic!("Expected key 'n => 1'."),
            }
            match keys.get("id") {
                Some(&Bson::I32(ref i)) => assert_eq!(1, *i),
                _ => panic!("Expected key 'id => 1'."),
            }
        }
        _ => panic!("keys not found for first index."),
    }

    match results[1].get("name") {
        Some(&Bson::String(ref name)) => assert_eq!("nid", name),
        _ => panic!("Expected first index to have a name."),
    }

    // Assert second inserted index
    match results[2].get("key") {
        Some(&Bson::Document(ref keys)) => {
            match keys.get("test") {
                Some(&Bson::I32(ref i)) => assert_eq!(-1, *i),
                _ => panic!("Expected key 'test => -1'."),
            }
            match keys.get("height") {
                Some(&Bson::I32(ref i)) => assert_eq!(1, *i),
                _ => panic!("Expected key 'height => 1'."),
            }
        }
        _ => panic!("keys not found for second index."),
    }

    match results[2].get("name") {
        Some(&Bson::String(ref name)) => assert_eq!("test_-1_height_1", name),
        _ => panic!("Expected first index to have a name."),
    }

    // Drop and ensure
    coll.drop_index_string("nid".to_owned()).unwrap();
    let mut cursor = coll.list_indexes().unwrap();
    let results = cursor.next_n(5).unwrap();

    assert_eq!(2, results.len());

    coll.drop_index(doc!{ "test" => (-1), "height" => 1 }, None).unwrap();
    let mut cursor = coll.list_indexes().unwrap();
    let results = cursor.next_n(5).unwrap();

    assert_eq!(1, results.len());
}

#[test]
fn create_text_hashed_2d_2dsphere_index() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("create_text_hashed_2d_2dsphere_index");

    coll.create_index(doc!{
        "a" => "text"
    }, None).expect("Failed to create text indexes");

    coll.create_index(doc!{
        "b" => "hashed"
    }, None).expect("Failed to create hashed indexes");

    coll.create_index(doc!{
        "c" => "2d"
    }, None).expect("Failed to create 2d indexes");

    coll.create_index(doc!{
        "d" => "2dsphere"
    }, None).expect("Failed to create 2dsphere indexes");
}

#[test]
fn block_ill_formed_index_models() {
    assert!(IndexModel::new(doc!{ "test" => 1.1 }, None).name().is_err());
    assert!(IndexModel::new(doc!{ "test" => 1i64 }, None).name().is_err());
    assert!(IndexModel::new(doc!{ "test" => "arbitrystr" }, None).name().is_err());
}

#[test]
fn create_query_text_index() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("create_query_text_index");

    coll.drop().expect("Failed to drop collection");

    let mut index_opt = IndexOptions::new();
    index_opt.weights = Some(doc!{
        "title" => 10,
        "content" => 5
    });
    coll.create_index(doc!{
        "title" => "text",
        "content" => "text"
    },
    Some(index_opt)).unwrap();

    let doc1 = doc! { "title" => "keyword keyword keyword", "content" => "nonkeyword", "id" => 1 };
    let doc2 = doc! { "title" => "nonkeyword", "content" => "keyword keyword keyword", "id" => 2 };
    let doc3 = doc! { "title" => "nonkeyword", "content" => "nonkeyword", "id" => 3 };

    coll.insert_many(vec![doc1.clone(), doc2.clone(), doc3.clone()], None).unwrap();

    let count = coll.count(Some(doc!{ "$text" => { "$search" => "keyword" }}), None).unwrap();
    assert_eq!(count, 2);

    let mut opts = FindOptions::new();
    opts.projection = Some(doc!{ "score" => { "$meta" => "textScore" }});
    opts.sort = Some(doc!{ "score" => { "$meta" => "textScore" }});

    let mut cursor = coll.find(
        Some(doc!{ "$text" => { "$search" => "keyword" }}),
        Some(opts)).unwrap();
    let results = cursor.next_n(2).unwrap();

    match results[0].get("id").unwrap() {
        &Bson::I32(id) => assert_eq!(1, id),
        _ => panic!("Why is id not a i32?")
    };

    match results[1].get("id").unwrap() {
        &Bson::I32(id) => assert_eq!(2, id),
        _ => panic!("Why is id not a i32?")
    };

    let count = coll.count(Some(doc!{ "$text" => { "$search" => "keyword nonkeyword" }}), None).unwrap();
    assert_eq!(count, 3);
}

#[test]
fn drop_all_indexes() {
    let client = Client::connect("localhost", 27017).unwrap();
    let db = client.db("test-client-coll");
    let coll = db.collection("drop_all_indexes");

    coll.drop().expect("Failed to drop database.");

    let mut opts1 = IndexOptions::new();
    opts1.name = Some("nid".to_owned());

    // Test name option
    let index1 = IndexModel::new(doc!{ "n" => 1, "id" => 1}, Some(opts1));

    // Test negative value and index name generation
    let index2 = IndexModel::new(doc!{ "test" => (-1), "height" => 1}, None);

    coll.create_indexes(vec![index1, index2]).unwrap();
    coll.drop_indexes().unwrap();
    let mut cursor = coll.list_indexes().unwrap();
    let results = cursor.next_n(5).unwrap();

    assert_eq!(1, results.len());
}