use tempdir

Cargo.toml

@@ -25,3 +25,4 @@ path = "test/test.rs"
 
 [dependencies]
 libc = "0.1.8"
+tempdir = "0.3.4"

src/ffi.rs

@@ -416,6 +416,7 @@ mod test {
     use super::*;
     use libc::*;
     use std::ffi::CString;
+    use tempdir::TempDir;
 
     #[test]
     fn internal() {
@@ -427,8 +428,10 @@ mod test {
             rocksdb_options_optimize_level_style_compaction(opts, 0);
             rocksdb_options_set_create_if_missing(opts, true);
 
-            let rustpath = "_rust_rocksdb_internaltest";
-            let cpath = CString::new(rustpath).unwrap();
+            let rustpath = TempDir::new("_rust_rocksdb_internaltest")
+                               .expect("");
+            let cpath = CString::new(rustpath.path().to_str().unwrap())
+                            .unwrap();
             let cpath_ptr = cpath.as_ptr();
 
             let mut err: *const i8 = 0 as *const i8;

src/lib.rs

@@ -14,6 +14,9 @@
 //
 extern crate libc;
 
+#[cfg(test)]
+extern crate tempdir;
+
 pub mod rocksdb;
 pub mod ffi;
 pub mod rocksdb_options;

src/merge_operator.rs

@@ -156,6 +156,7 @@ mod test {
     use super::*;
     use rocksdb_options::Options;
     use rocksdb::{DB, DBVector, Writable};
+    use tempdir::TempDir;
 
     #[allow(unused_variables)]
     #[allow(dead_code)]
@@ -184,39 +185,34 @@ mod test {
     #[allow(dead_code)]
     #[test]
     fn mergetest() {
-        let path = "_rust_rocksdb_mergetest";
+        let path = TempDir::new("_rust_rocksdb_mergetest").expect("");
         let mut opts = Options::new();
         opts.create_if_missing(true);
         opts.add_merge_operator("test operator", test_provided_merge);
-        {
-            let db = DB::open(&opts, path).unwrap();
-            let p = db.put(b"k1", b"a");
-            assert!(p.is_ok());
-            let _ = db.merge(b"k1", b"b");
-            let _ = db.merge(b"k1", b"c");
-            let _ = db.merge(b"k1", b"d");
-            let _ = db.merge(b"k1", b"efg");
-            let m = db.merge(b"k1", b"h");
-            assert!(m.is_ok());
-            match db.get(b"k1") {
-                Ok(Some(value)) => {
-                    match value.to_utf8() {
-                        Some(v) => println!("retrieved utf8 value: {}", v),
-                        None => {
-                            println!("did not read valid utf-8 out of the db")
-                        }
-                    }
+        let db = DB::open(&opts, path.path().to_str().unwrap()).unwrap();
+        let p = db.put(b"k1", b"a");
+        assert!(p.is_ok());
+        let _ = db.merge(b"k1", b"b");
+        let _ = db.merge(b"k1", b"c");
+        let _ = db.merge(b"k1", b"d");
+        let _ = db.merge(b"k1", b"efg");
+        let m = db.merge(b"k1", b"h");
+        assert!(m.is_ok());
+        match db.get(b"k1") {
+            Ok(Some(value)) => {
+                match value.to_utf8() {
+                    Some(v) => println!("retrieved utf8 value: {}", v),
+                    None => println!("did not read valid utf-8 out of the db"),
                 }
-                Err(e) => println!("error reading value {:?}", e),
-                _ => panic!("value not present"),
             }
-
-            assert!(m.is_ok());
-            let r: Result<Option<DBVector>, String> = db.get(b"k1");
-            assert!(r.unwrap().unwrap().to_utf8().unwrap() == "abcdefgh");
-            assert!(db.delete(b"k1").is_ok());
-            assert!(db.get(b"k1").unwrap().is_none());
+            Err(e) => println!("error reading value {:?}", e),
+            _ => panic!("value not present"),
         }
-        assert!(DB::destroy(&opts, path).is_ok());
+
+        assert!(m.is_ok());
+        let r: Result<Option<DBVector>, String> = db.get(b"k1");
+        assert!(r.unwrap().unwrap().to_utf8().unwrap() == "abcdefgh");
+        assert!(db.delete(b"k1").is_ok());
+        assert!(db.get(b"k1").unwrap().is_none());
     }
 }

src/rocksdb.rs

@@ -868,89 +868,73 @@ mod test {
     use super::*;
     use rocksdb_options::*;
     use std::str;
+    use tempdir::TempDir;
 
     #[test]
     fn external() {
-        let path = "_rust_rocksdb_externaltest";
-        {
-            let db = DB::open_default(path).unwrap();
-            let p = db.put(b"k1", b"v1111");
-            assert!(p.is_ok());
-            let r: Result<Option<DBVector>, String> = db.get(b"k1");
-            assert!(r.unwrap().unwrap().to_utf8().unwrap() == "v1111");
-            assert!(db.delete(b"k1").is_ok());
-            assert!(db.get(b"k1").unwrap().is_none());
-        }
-        let opts = Options::new();
-        let result = DB::destroy(&opts, path);
-        assert!(result.is_ok());
+        let path = TempDir::new("_rust_rocksdb_externaltest").expect("");
+        let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
+        let p = db.put(b"k1", b"v1111");
+        assert!(p.is_ok());
+        let r: Result<Option<DBVector>, String> = db.get(b"k1");
+        assert!(r.unwrap().unwrap().to_utf8().unwrap() == "v1111");
+        assert!(db.delete(b"k1").is_ok());
+        assert!(db.get(b"k1").unwrap().is_none());
     }
 
     #[allow(unused_variables)]
     #[test]
     fn errors_do_stuff() {
-        let path = "_rust_rocksdb_error";
-        let db = DB::open_default(path).unwrap();
+        let path = TempDir::new("_rust_rocksdb_error").expect("");
+        let path_str = path.path().to_str().unwrap();
+        let db = DB::open_default(path_str).unwrap();
         let opts = Options::new();
         // The DB will still be open when we try to destroy and the lock should fail
-        match DB::destroy(&opts, path) {
-            Err(ref s) => {
-                assert!(s ==
-                        "IO error: lock _rust_rocksdb_error/LOCK: No locks \
-                         available")
-            }
+        match DB::destroy(&opts, path_str) {
+            Err(ref s) => assert!(s.contains("LOCK: No locks available")),
             Ok(_) => panic!("should fail"),
         }
     }
 
     #[test]
     fn writebatch_works() {
-        let path = "_rust_rocksdb_writebacktest";
-        {
-            let db = DB::open_default(path).unwrap();
-            {
-                // test put
-                let batch = WriteBatch::new();
-                assert!(db.get(b"k1").unwrap().is_none());
-                let _ = batch.put(b"k1", b"v1111");
-                assert!(db.get(b"k1").unwrap().is_none());
-                let p = db.write(batch);
-                assert!(p.is_ok());
-                let r: Result<Option<DBVector>, String> = db.get(b"k1");
-                assert!(r.unwrap().unwrap().to_utf8().unwrap() == "v1111");
-            }
-            {
-                // test delete
-                let batch = WriteBatch::new();
-                let _ = batch.delete(b"k1");
-                let p = db.write(batch);
-                assert!(p.is_ok());
-                assert!(db.get(b"k1").unwrap().is_none());
-            }
-        }
-        let opts = Options::new();
-        assert!(DB::destroy(&opts, path).is_ok());
+        let path = TempDir::new("_rust_rocksdb_writebacktest").expect("");
+        let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
+
+        // test put
+        let batch = WriteBatch::new();
+        assert!(db.get(b"k1").unwrap().is_none());
+        let _ = batch.put(b"k1", b"v1111");
+        assert!(db.get(b"k1").unwrap().is_none());
+        let p = db.write(batch);
+        assert!(p.is_ok());
+        let r: Result<Option<DBVector>, String> = db.get(b"k1");
+        assert!(r.unwrap().unwrap().to_utf8().unwrap() == "v1111");
+
+        // test delete
+        let batch = WriteBatch::new();
+        let _ = batch.delete(b"k1");
+        let p = db.write(batch);
+        assert!(p.is_ok());
+        assert!(db.get(b"k1").unwrap().is_none());
     }
 
     #[test]
     fn iterator_test() {
-        let path = "_rust_rocksdb_iteratortest";
-        {
-            let db = DB::open_default(path).unwrap();
-            let p = db.put(b"k1", b"v1111");
-            assert!(p.is_ok());
-            let p = db.put(b"k2", b"v2222");
-            assert!(p.is_ok());
-            let p = db.put(b"k3", b"v3333");
-            assert!(p.is_ok());
-            let iter = db.iterator(IteratorMode::Start);
-            for (k, v) in iter {
-                println!("Hello {}: {}",
-                         str::from_utf8(&*k).unwrap(),
-                         str::from_utf8(&*v).unwrap());
-            }
+        let path = TempDir::new("_rust_rocksdb_iteratortest").expect("");
+
+        let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
+        let p = db.put(b"k1", b"v1111");
+        assert!(p.is_ok());
+        let p = db.put(b"k2", b"v2222");
+        assert!(p.is_ok());
+        let p = db.put(b"k3", b"v3333");
+        assert!(p.is_ok());
+        let iter = db.iterator(IteratorMode::Start);
+        for (k, v) in iter {
+            println!("Hello {}: {}",
+                     str::from_utf8(&*k).unwrap(),
+                     str::from_utf8(&*v).unwrap());
         }
-        let opts = Options::new();
-        assert!(DB::destroy(&opts, path).is_ok());
     }
 }

test/test.rs

 extern crate rocksdb;
+extern crate tempdir;
 
 mod test_iterator;
 mod test_multithreaded;

test/test_column_family.rs

@@ -13,17 +13,19 @@
 // limitations under the License.
 //
 use rocksdb::{DB, MergeOperands, Options, Writable};
+use tempdir::TempDir;
 
 #[test]
 pub fn test_column_family() {
-    let path = "_rust_rocksdb_cftest";
+    let path = TempDir::new("_rust_rocksdb_cftest").expect("");
+    let path_str = path.path().to_str().unwrap();
 
     // should be able to create column families
     {
         let mut opts = Options::new();
         opts.create_if_missing(true);
         opts.add_merge_operator("test operator", test_provided_merge);
-        let mut db = DB::open(&opts, path).unwrap();
+        let mut db = DB::open(&opts, path_str).unwrap();
         let opts = Options::new();
         match db.create_cf("cf1", &opts) {
             Ok(_) => println!("cf1 created successfully"),
@@ -37,7 +39,7 @@ pub fn test_column_family() {
     {
         let mut opts = Options::new();
         opts.add_merge_operator("test operator", test_provided_merge);
-        match DB::open(&opts, path) {
+        match DB::open(&opts, path_str) {
             Ok(_) => {
                 panic!("should not have opened DB successfully without \
                         specifying column
@@ -54,7 +56,7 @@ pub fn test_column_family() {
     {
         let mut opts = Options::new();
         opts.add_merge_operator("test operator", test_provided_merge);
-        match DB::open_cf(&opts, path, &["cf1"]) {
+        match DB::open_cf(&opts, path_str, &["cf1"]) {
             Ok(_) => println!("successfully opened db with column family"),
             Err(e) => panic!("failed to open db with column family: {}", e),
         }
@@ -63,7 +65,7 @@ pub fn test_column_family() {
     {
         let mut opts = Options::new();
         opts.add_merge_operator("test operator", test_provided_merge);
-        let db = match DB::open_cf(&opts, path, &["cf1"]) {
+        let db = match DB::open_cf(&opts, path_str, &["cf1"]) {
             Ok(db) => {
                 println!("successfully opened db with column family");
                 db
@@ -111,14 +113,12 @@ pub fn test_column_family() {
     }
     // should b able to drop a cf
     {
-        let mut db = DB::open_cf(&Options::new(), path, &["cf1"]).unwrap();
+        let mut db = DB::open_cf(&Options::new(), path_str, &["cf1"]).unwrap();
         match db.drop_cf("cf1") {
             Ok(_) => println!("cf1 successfully dropped."),
             Err(e) => panic!("failed to drop column family: {}", e),
         }
     }
-
-    assert!(DB::destroy(&Options::new(), path).is_ok());
 }
 
 fn test_provided_merge(_: &[u8],

test/test_iterator.rs

-use rocksdb::{DB, Direction, IteratorMode, Options, Writable};
+use rocksdb::{DB, Direction, IteratorMode, Writable};
+use tempdir::TempDir;
 
 fn cba(input: &Box<[u8]>) -> Box<[u8]> {
     input.iter().cloned().collect::<Vec<_>>().into_boxed_slice()
@@ -6,113 +7,94 @@ fn cba(input: &Box<[u8]>) -> Box<[u8]> {
 
 #[test]
 pub fn test_iterator() {
-    let path = "_rust_rocksdb_iteratortest";
-    {
-        let k1: Box<[u8]> = b"k1".to_vec().into_boxed_slice();
-        let k2: Box<[u8]> = b"k2".to_vec().into_boxed_slice();
-        let k3: Box<[u8]> = b"k3".to_vec().into_boxed_slice();
-        let k4: Box<[u8]> = b"k4".to_vec().into_boxed_slice();
-        let v1: Box<[u8]> = b"v1111".to_vec().into_boxed_slice();
-        let v2: Box<[u8]> = b"v2222".to_vec().into_boxed_slice();
-        let v3: Box<[u8]> = b"v3333".to_vec().into_boxed_slice();
-        let v4: Box<[u8]> = b"v4444".to_vec().into_boxed_slice();
-        let db = DB::open_default(path).unwrap();
-        let p = db.put(&*k1, &*v1);
-        assert!(p.is_ok());
-        let p = db.put(&*k2, &*v2);
-        assert!(p.is_ok());
-        let p = db.put(&*k3, &*v3);
-        assert!(p.is_ok());
-        let expected = vec![(cba(&k1), cba(&v1)),
-                            (cba(&k2), cba(&v2)),
-                            (cba(&k3), cba(&v3))];
-        {
-            let iterator1 = db.iterator(IteratorMode::Start);
-            assert_eq!(iterator1.collect::<Vec<_>>(), expected);
-        }
-        // Test that it's idempotent
-        {
-            let iterator1 = db.iterator(IteratorMode::Start);
-            assert_eq!(iterator1.collect::<Vec<_>>(), expected);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::Start);
-            assert_eq!(iterator1.collect::<Vec<_>>(), expected);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::Start);
-            assert_eq!(iterator1.collect::<Vec<_>>(), expected);
-        }
-        // Test it in reverse a few times
-        {
-            let iterator1 = db.iterator(IteratorMode::End);
-            let mut tmp_vec = iterator1.collect::<Vec<_>>();
-            tmp_vec.reverse();
-            assert_eq!(tmp_vec, expected);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::End);
-            let mut tmp_vec = iterator1.collect::<Vec<_>>();
-            tmp_vec.reverse();
-            assert_eq!(tmp_vec, expected);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::End);
-            let mut tmp_vec = iterator1.collect::<Vec<_>>();
-            tmp_vec.reverse();
-            assert_eq!(tmp_vec, expected);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::End);
-            let mut tmp_vec = iterator1.collect::<Vec<_>>();
-            tmp_vec.reverse();
-            assert_eq!(tmp_vec, expected);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::End);
-            let mut tmp_vec = iterator1.collect::<Vec<_>>();
-            tmp_vec.reverse();
-            assert_eq!(tmp_vec, expected);
-        }
-        // Try it forward again
-        {
-            let iterator1 = db.iterator(IteratorMode::Start);
-            assert_eq!(iterator1.collect::<Vec<_>>(), expected);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::Start);
-            assert_eq!(iterator1.collect::<Vec<_>>(), expected);
-        }
-
-        let old_iterator = db.iterator(IteratorMode::Start);
-        let p = db.put(&*k4, &*v4);
-        assert!(p.is_ok());
-        let expected2 = vec![(cba(&k1), cba(&v1)),
-                             (cba(&k2), cba(&v2)),
-                             (cba(&k3), cba(&v3)),
-                             (cba(&k4), cba(&v4))];
-        {
-            assert_eq!(old_iterator.collect::<Vec<_>>(), expected);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::Start);
-            assert_eq!(iterator1.collect::<Vec<_>>(), expected2);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::From(b"k2",
-                                                           Direction::Forward));
-            let expected = vec![(cba(&k2), cba(&v2)),
-                                (cba(&k3), cba(&v3)),
-                                (cba(&k4), cba(&v4))];
-            assert_eq!(iterator1.collect::<Vec<_>>(), expected);
-        }
-        {
-            let iterator1 = db.iterator(IteratorMode::From(b"k2",
-                                                           Direction::Reverse));
-            let expected = vec![(cba(&k2), cba(&v2)), (cba(&k1), cba(&v1))];
-            assert_eq!(iterator1.collect::<Vec<_>>(), expected);
-        }
-    }
-    let opts = Options::new();
-    assert!(DB::destroy(&opts, path).is_ok());
+    let path = TempDir::new("_rust_rocksdb_iteratortest").expect("");
+
+    let k1: Box<[u8]> = b"k1".to_vec().into_boxed_slice();
+    let k2: Box<[u8]> = b"k2".to_vec().into_boxed_slice();
+    let k3: Box<[u8]> = b"k3".to_vec().into_boxed_slice();
+    let k4: Box<[u8]> = b"k4".to_vec().into_boxed_slice();
+    let v1: Box<[u8]> = b"v1111".to_vec().into_boxed_slice();
+    let v2: Box<[u8]> = b"v2222".to_vec().into_boxed_slice();
+    let v3: Box<[u8]> = b"v3333".to_vec().into_boxed_slice();
+    let v4: Box<[u8]> = b"v4444".to_vec().into_boxed_slice();
+    let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
+    let p = db.put(&*k1, &*v1);
+    assert!(p.is_ok());
+    let p = db.put(&*k2, &*v2);
+    assert!(p.is_ok());
+    let p = db.put(&*k3, &*v3);
+    assert!(p.is_ok());
+    let expected = vec![(cba(&k1), cba(&v1)),
+                        (cba(&k2), cba(&v2)),
+                        (cba(&k3), cba(&v3))];
+
+    let iterator1 = db.iterator(IteratorMode::Start);
+    assert_eq!(iterator1.collect::<Vec<_>>(), expected);
+
+    // Test that it's idempotent
+    let iterator1 = db.iterator(IteratorMode::Start);
+    assert_eq!(iterator1.collect::<Vec<_>>(), expected);
+
+    let iterator1 = db.iterator(IteratorMode::Start);
+    assert_eq!(iterator1.collect::<Vec<_>>(), expected);
+
+    let iterator1 = db.iterator(IteratorMode::Start);
+    assert_eq!(iterator1.collect::<Vec<_>>(), expected);
+
+    // Test it in reverse a few times
+    let iterator1 = db.iterator(IteratorMode::End);
+    let mut tmp_vec = iterator1.collect::<Vec<_>>();
+    tmp_vec.reverse();
+    assert_eq!(tmp_vec, expected);
+
+    let iterator1 = db.iterator(IteratorMode::End);
+    let mut tmp_vec = iterator1.collect::<Vec<_>>();
+    tmp_vec.reverse();
+    assert_eq!(tmp_vec, expected);
+
+    let iterator1 = db.iterator(IteratorMode::End);
+    let mut tmp_vec = iterator1.collect::<Vec<_>>();
+    tmp_vec.reverse();
+    assert_eq!(tmp_vec, expected);
+
+    let iterator1 = db.iterator(IteratorMode::End);
+    let mut tmp_vec = iterator1.collect::<Vec<_>>();
+    tmp_vec.reverse();
+    assert_eq!(tmp_vec, expected);
+
+    let iterator1 = db.iterator(IteratorMode::End);
+    let mut tmp_vec = iterator1.collect::<Vec<_>>();
+    tmp_vec.reverse();
+    assert_eq!(tmp_vec, expected);
+
+    // Try it forward again
+    let iterator1 = db.iterator(IteratorMode::Start);
+    assert_eq!(iterator1.collect::<Vec<_>>(), expected);
+
+    let iterator1 = db.iterator(IteratorMode::Start);
+    assert_eq!(iterator1.collect::<Vec<_>>(), expected);
+
+    let old_iterator = db.iterator(IteratorMode::Start);
+    let p = db.put(&*k4, &*v4);
+    assert!(p.is_ok());
+    let expected2 = vec![(cba(&k1), cba(&v1)),
+                         (cba(&k2), cba(&v2)),
+                         (cba(&k3), cba(&v3)),
+                         (cba(&k4), cba(&v4))];
+    assert_eq!(old_iterator.collect::<Vec<_>>(), expected);
+
+    let iterator1 = db.iterator(IteratorMode::Start);
+    assert_eq!(iterator1.collect::<Vec<_>>(), expected2);
+
+    let iterator1 = db.iterator(IteratorMode::From(b"k2",
+                                                   Direction::Forward));
+    let expected = vec![(cba(&k2), cba(&v2)),
+                        (cba(&k3), cba(&v3)),
+                        (cba(&k4), cba(&v4))];
+    assert_eq!(iterator1.collect::<Vec<_>>(), expected);
+
+    let iterator1 = db.iterator(IteratorMode::From(b"k2",
+                                                   Direction::Reverse));
+    let expected = vec![(cba(&k2), cba(&v2)), (cba(&k1), cba(&v1))];
+    assert_eq!(iterator1.collect::<Vec<_>>(), expected);
 }

test/test_multithreaded.rs

-use rocksdb::{DB, Options, Writable};
+use rocksdb::{DB, Writable};
 use std::thread;
 use std::sync::Arc;
+use tempdir::TempDir;
 
 const N: usize = 100_000;
 
 #[test]
 pub fn test_multithreaded() {
-    let path = "_rust_rocksdb_multithreadtest";
-    {
-        let db = DB::open_default(path).unwrap();
-        let db = Arc::new(db);
+    let path = TempDir::new("_rust_rocksdb_multithreadtest").expect("");
 
-        db.put(b"key", b"value1").unwrap();
+    let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
+    let db = Arc::new(db);
 
-        let db1 = db.clone();
-        let j1 = thread::spawn(move || {
-            for _ in 1..N {
-                db1.put(b"key", b"value1").unwrap();
-            }
-        });
+    db.put(b"key", b"value1").unwrap();
 
-        let db2 = db.clone();
-        let j2 = thread::spawn(move || {
-            for _ in 1..N {
-                db2.put(b"key", b"value2").unwrap();
-            }
-        });
-
-        let db3 = db.clone();
-        let j3 = thread::spawn(move || {
-            for _ in 1..N {
-                match db3.get(b"key") {
-                    Ok(Some(v)) => {
-                        if &v[..] != b"value1" && &v[..] != b"value2" {
-                            assert!(false);
-                        }
-                    }
-                    _ => {
+    let db1 = db.clone();
+    let j1 = thread::spawn(move || {
+        for _ in 1..N {
+            db1.put(b"key", b"value1").unwrap();
+        }
+    });
+
+    let db2 = db.clone();
+    let j2 = thread::spawn(move || {
+        for _ in 1..N {
+            db2.put(b"key", b"value2").unwrap();
+        }
+    });
+
+    let db3 = db.clone();
+    let j3 = thread::spawn(move || {
+        for _ in 1..N {
+            match db3.get(b"key") {
+                Ok(Some(v)) => {
+                    if &v[..] != b"value1" && &v[..] != b"value2" {
                         assert!(false);
                     }
                 }
+                _ => {
+                    assert!(false);
+                }
             }
-        });
+        }
+    });
 
-        j1.join().unwrap();
-        j2.join().unwrap();
-        j3.join().unwrap();
-    }
-    assert!(DB::destroy(&Options::new(), path).is_ok());
+    j1.join().unwrap();
+    j2.join().unwrap();
+    j3.join().unwrap();
 }