RUST-484 Add a test lock and move integration tests

Author: Utkarsh Mehta

Cargo.toml

@@ -41,6 +41,7 @@ base64 = "0.12.1"
 assert_matches = "1.2"
 serde_bytes = "0.11"
 pretty_assertions = "0.6.1"
+lazy_static = "1.4.0"
 
 [package.metadata.docs.rs]
 features = ["decimal128"]

src/lib.rs

@@ -214,3 +214,6 @@ pub mod extjson;
 pub mod oid;
 pub mod ser;
 pub mod spec;
+
+#[cfg(test)]
+mod tests;

src/oid.rs

@@ -198,8 +198,12 @@ impl fmt::Debug for ObjectId {
     }
 }
 
+#[cfg(test)]
+use crate::tests::LOCK;
+
 #[test]
 fn count_generated_is_big_endian() {
+    let _guard = LOCK.run_exclusively();
     let start = 1_122_866;
     OID_COUNTER.store(start, Ordering::SeqCst);
 

src/tests/mod.rs

@@ -0,0 +1,9 @@
+mod modules;
+mod spec;
+
+use lazy_static::lazy_static;
+use modules::TestLock;
+
+lazy_static! {
+    pub(crate) static ref LOCK: TestLock = TestLock::new();
+}

tests/modules/bson.rs renamed to src/tests/modules/bson.rs

@@ -1,9 +1,10 @@
 use std::convert::TryFrom;
 
-use bson::{
+use crate::{
     doc,
     oid::ObjectId,
     spec::BinarySubtype,
+    tests::LOCK,
     Binary,
     Bson,
     Document,
@@ -15,6 +16,7 @@ use serde_json::{json, Value};
 
 #[test]
 fn to_json() {
+    let _guard = LOCK.run_concurrently();
     let mut doc = Document::new();
     doc.insert(
         "_id",
@@ -49,19 +51,22 @@ fn to_json() {
 
 #[test]
 fn bson_default() {
+    let _guard = LOCK.run_concurrently();
     let bson1 = Bson::default();
     assert_eq!(bson1, Bson::Null);
 }
 
 #[test]
 fn document_default() {
+    let _guard = LOCK.run_concurrently();
     let doc1 = Document::default();
     assert_eq!(doc1.keys().count(), 0);
     assert_eq!(doc1, Document::new());
 }
 
 #[test]
 fn from_impls() {
+    let _guard = LOCK.run_concurrently();
     assert_eq!(Bson::from(1.5f32), Bson::Double(1.5));
     assert_eq!(Bson::from(2.25f64), Bson::Double(2.25));
     assert_eq!(Bson::from("data"), Bson::String(String::from("data")));
@@ -147,6 +152,7 @@ fn from_impls() {
 
 #[test]
 fn timestamp_ordering() {
+    let _guard = LOCK.run_concurrently();
     let ts1 = Timestamp {
         time: 0,
         increment: 1,

src/tests/modules/lock.rs

@@ -0,0 +1,20 @@
+use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+
+#[derive(Default)]
+pub struct TestLock {
+    inner: RwLock<()>,
+}
+
+impl TestLock {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn run_concurrently(&self) -> RwLockReadGuard<'_, ()> {
+        self.inner.read().unwrap()
+    }
+
+    pub fn run_exclusively(&self) -> RwLockWriteGuard<'_, ()> {
+        self.inner.write().unwrap()
+    }
+}

tests/modules/macros.rs renamed to src/tests/modules/macros.rs

@@ -1,9 +1,10 @@
-use bson::{doc, oid::ObjectId, spec::BinarySubtype, Binary, Bson, Regex, Timestamp};
+use crate::{doc, oid::ObjectId, spec::BinarySubtype, tests::LOCK, Binary, Bson, Regex, Timestamp};
 use chrono::offset::Utc;
 use pretty_assertions::assert_eq;
 
 #[test]
 fn standard_format() {
+    let _guard = LOCK.run_concurrently();
     let id_string = "thisismyname";
     let string_bytes: Vec<_> = id_string.bytes().collect();
     let mut bytes = [0; 12];
@@ -52,6 +53,7 @@ fn standard_format() {
 
 #[test]
 fn non_trailing_comma() {
+    let _guard = LOCK.run_concurrently();
     let doc = doc! {
         "a": "foo",
         "b": { "ok": "then" }
@@ -64,6 +66,7 @@ fn non_trailing_comma() {
 #[test]
 #[allow(clippy::float_cmp)]
 fn recursive_macro() {
+    let _guard = LOCK.run_concurrently();
     let doc = doc! {
         "a": "foo",
         "b": {

tests/modules/mod.rs renamed to src/tests/modules/mod.rs

@@ -1,6 +1,9 @@
 mod bson;
+mod lock;
 mod macros;
 mod oid;
 mod ordered;
 mod ser;
 mod serializer_deserializer;
+
+pub use self::lock::TestLock;

tests/modules/oid.rs renamed to src/tests/modules/oid.rs

@@ -1,7 +1,8 @@
-use bson::oid::ObjectId;
+use crate::{oid::ObjectId, tests::LOCK};
 
 #[test]
 fn string_oid() {
+    let _guard = LOCK.run_concurrently();
     let s = "123456789012123456789012";
     let oid_res = ObjectId::with_string(s);
     assert!(oid_res.is_ok());
@@ -11,6 +12,7 @@ fn string_oid() {
 
 #[test]
 fn byte_string_oid() {
+    let _guard = LOCK.run_concurrently();
     let s = "541b1a00e8a23afa832b218e";
     let oid_res = ObjectId::with_string(s);
     assert!(oid_res.is_ok());
@@ -26,18 +28,21 @@ fn byte_string_oid() {
 
 #[test]
 fn oid_equals() {
+    let _guard = LOCK.run_concurrently();
     let oid = ObjectId::new();
     assert_eq!(oid, oid);
 }
 
 #[test]
 fn oid_not_equals() {
+    let _guard = LOCK.run_concurrently();
     assert!(ObjectId::new() != ObjectId::new());
 }
 
 // check that the last byte in objectIDs is increasing
 #[test]
 fn counter_increasing() {
+    let _guard = LOCK.run_concurrently();
     let oid1_bytes = ObjectId::new().bytes();
     let oid2_bytes = ObjectId::new().bytes();
     assert!(oid1_bytes[11] < oid2_bytes[11]);

tests/modules/ordered.rs renamed to src/tests/modules/ordered.rs

@@ -1,10 +1,11 @@
 #[cfg(feature = "decimal128")]
-use bson::decimal128::Decimal128;
-use bson::{
+use crate::decimal128::Decimal128;
+use crate::{
     doc,
     document::ValueAccessError,
     oid::ObjectId,
     spec::BinarySubtype,
+    tests::LOCK,
     Binary,
     Bson,
     Document,
@@ -14,6 +15,7 @@ use chrono::Utc;
 
 #[test]
 fn ordered_insert() {
+    let _guard = LOCK.run_concurrently();
     let mut doc = Document::new();
     doc.insert("first".to_owned(), Bson::Int32(1));
     doc.insert("second".to_owned(), Bson::String("foo".to_owned()));
@@ -31,6 +33,7 @@ fn ordered_insert() {
 
 #[test]
 fn ordered_insert_shorthand() {
+    let _guard = LOCK.run_concurrently();
     let mut doc = Document::new();
     doc.insert("first", 1i32);
     doc.insert("second", "foo");
@@ -48,17 +51,16 @@ fn ordered_insert_shorthand() {
 
 #[cfg(feature = "decimal128")]
 fn test_decimal128(doc: &mut Document) {
+    let _guard = LOCK.run_concurrently();
     let dec = Decimal128::from_str("968E+1");
     doc.insert("decimal128".to_string(), Bson::Decimal128(dec.clone()));
     assert_eq!(Some(&Bson::Decimal128(dec.clone())), doc.get("decimal128"));
     assert_eq!(Ok(&dec), doc.get_decimal128("decimal128"));
 }
 
-#[cfg(not(feature = "decimal128"))]
-fn test_decimal128(_doc: &mut Document) {}
-
 #[test]
 fn test_getters() {
+    let _guard = LOCK.run_concurrently();
     let datetime = Utc::now();
     let cloned_dt = datetime;
     let binary = vec![0, 1, 2, 3, 4];
@@ -137,6 +139,7 @@ fn test_getters() {
     assert_eq!(Some(&Bson::DateTime(datetime)), doc.get("datetime"));
     assert_eq!(Ok(&datetime), doc.get_datetime("datetime"));
 
+    #[cfg(feature = "decimal128")]
     test_decimal128(&mut doc);
 
     assert_eq!(Some(&Bson::DateTime(datetime)), doc.get("datetime"));
@@ -159,6 +162,7 @@ fn test_getters() {
 
 #[test]
 fn remove() {
+    let _guard = LOCK.run_concurrently();
     let mut doc = Document::new();
     doc.insert("first", Bson::Int32(1));
     doc.insert("second", Bson::String("foo".to_owned()));
@@ -175,6 +179,7 @@ fn remove() {
 
 #[test]
 fn entry() {
+    let _guard = LOCK.run_concurrently();
     let mut doc = doc! {
         "first": 1i32,
         "second": "foo",