1 files changed, 187 insertions, 0 deletions
diff --git a/third_party/rust/rkv/tests/env-all.rs b/third_party/rust/rkv/tests/env-all.rs
new file mode 100644
index 0000000000..325e20481e
--- /dev/null
+++ b/third_party/rust/rkv/tests/env-all.rs
@@ -0,0 +1,187 @@
+// Copyright 2018-2019 Mozilla
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+// this file except in compliance with the License. You may obtain a copy of the
+// License at http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+use std::fs;
+
+use tempfile::Builder;
+
+use rkv::{
+    backend::{
+        Lmdb,
+        SafeMode,
+    },
+    Rkv,
+    StoreOptions,
+    Value,
+};
+
+#[test]
+fn test_open_safe_same_dir_as_lmdb() {
+    let root = Builder::new().prefix("test_open_safe_same_dir_as_lmdb").tempdir().expect("tempdir");
+    fs::create_dir_all(root.path()).expect("dir created");
+
+    // Create database of type A and save to disk.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
+
+        let mut writer = k.write().expect("writer");
+        sk.put(&mut writer, "foo", &Value::I64(1234)).expect("wrote");
+        sk.put(&mut writer, "bar", &Value::Bool(true)).expect("wrote");
+        sk.put(&mut writer, "baz", &Value::Str("héllo, yöu")).expect("wrote");
+        assert_eq!(sk.get(&writer, "foo").expect("read"), Some(Value::I64(1234)));
+        assert_eq!(sk.get(&writer, "bar").expect("read"), Some(Value::Bool(true)));
+        assert_eq!(sk.get(&writer, "baz").expect("read"), Some(Value::Str("héllo, yöu")));
+        writer.commit().expect("committed");
+        k.sync(true).expect("synced");
+    }
+    // Verify that database of type A was written to disk.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::default()).expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(sk.get(&reader, "foo").expect("read"), Some(Value::I64(1234)));
+        assert_eq!(sk.get(&reader, "bar").expect("read"), Some(Value::Bool(true)));
+        assert_eq!(sk.get(&reader, "baz").expect("read"), Some(Value::Str("héllo, yöu")));
+    }
+    // Create database of type B and verify that it is empty.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let _ = k.open_single("sk", StoreOptions::default()).expect_err("not opened");
+    }
+    // Verify that database of type A wasn't changed.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::default()).expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(sk.get(&reader, "foo").expect("read"), Some(Value::I64(1234)));
+        assert_eq!(sk.get(&reader, "bar").expect("read"), Some(Value::Bool(true)));
+        assert_eq!(sk.get(&reader, "baz").expect("read"), Some(Value::Str("héllo, yöu")));
+    }
+    // Create database of type B and save to disk (type A exists at the same path).
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
+
+        let mut writer = k.write().expect("writer");
+        sk.put(&mut writer, "foo1", &Value::I64(5678)).expect("wrote");
+        sk.put(&mut writer, "bar1", &Value::Bool(false)).expect("wrote");
+        sk.put(&mut writer, "baz1", &Value::Str("héllo~ yöu")).expect("wrote");
+        assert_eq!(sk.get(&writer, "foo1").expect("read"), Some(Value::I64(5678)));
+        assert_eq!(sk.get(&writer, "bar1").expect("read"), Some(Value::Bool(false)));
+        assert_eq!(sk.get(&writer, "baz1").expect("read"), Some(Value::Str("héllo~ yöu")));
+        writer.commit().expect("committed");
+        k.sync(true).expect("synced");
+    }
+    // Verify that database of type B was written to disk.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::default()).expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(sk.get(&reader, "foo1").expect("read"), Some(Value::I64(5678)));
+        assert_eq!(sk.get(&reader, "bar1").expect("read"), Some(Value::Bool(false)));
+        assert_eq!(sk.get(&reader, "baz1").expect("read"), Some(Value::Str("héllo~ yöu")));
+    }
+    // Verify that database of type A still wasn't changed.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::default()).expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(sk.get(&reader, "foo").expect("read"), Some(Value::I64(1234)));
+        assert_eq!(sk.get(&reader, "bar").expect("read"), Some(Value::Bool(true)));
+        assert_eq!(sk.get(&reader, "baz").expect("read"), Some(Value::Str("héllo, yöu")));
+    }
+}
+
+#[test]
+fn test_open_lmdb_same_dir_as_safe() {
+    let root = Builder::new().prefix("test_open_lmdb_same_dir_as_safe").tempdir().expect("tempdir");
+    fs::create_dir_all(root.path()).expect("dir created");
+
+    // Create database of type A and save to disk.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
+
+        let mut writer = k.write().expect("writer");
+        sk.put(&mut writer, "foo", &Value::I64(1234)).expect("wrote");
+        sk.put(&mut writer, "bar", &Value::Bool(true)).expect("wrote");
+        sk.put(&mut writer, "baz", &Value::Str("héllo, yöu")).expect("wrote");
+        assert_eq!(sk.get(&writer, "foo").expect("read"), Some(Value::I64(1234)));
+        assert_eq!(sk.get(&writer, "bar").expect("read"), Some(Value::Bool(true)));
+        assert_eq!(sk.get(&writer, "baz").expect("read"), Some(Value::Str("héllo, yöu")));
+        writer.commit().expect("committed");
+        k.sync(true).expect("synced");
+    }
+    // Verify that database of type A was written to disk.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::default()).expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(sk.get(&reader, "foo").expect("read"), Some(Value::I64(1234)));
+        assert_eq!(sk.get(&reader, "bar").expect("read"), Some(Value::Bool(true)));
+        assert_eq!(sk.get(&reader, "baz").expect("read"), Some(Value::Str("héllo, yöu")));
+    }
+    // Create database of type B and verify that it is empty.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let _ = k.open_single("sk", StoreOptions::default()).expect_err("not opened");
+    }
+    // Verify that database of type A wasn't changed.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::default()).expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(sk.get(&reader, "foo").expect("read"), Some(Value::I64(1234)));
+        assert_eq!(sk.get(&reader, "bar").expect("read"), Some(Value::Bool(true)));
+        assert_eq!(sk.get(&reader, "baz").expect("read"), Some(Value::Str("héllo, yöu")));
+    }
+    // Create database of type B and save to disk (type A exists at the same path).
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
+
+        let mut writer = k.write().expect("writer");
+        sk.put(&mut writer, "foo1", &Value::I64(5678)).expect("wrote");
+        sk.put(&mut writer, "bar1", &Value::Bool(false)).expect("wrote");
+        sk.put(&mut writer, "baz1", &Value::Str("héllo~ yöu")).expect("wrote");
+        assert_eq!(sk.get(&writer, "foo1").expect("read"), Some(Value::I64(5678)));
+        assert_eq!(sk.get(&writer, "bar1").expect("read"), Some(Value::Bool(false)));
+        assert_eq!(sk.get(&writer, "baz1").expect("read"), Some(Value::Str("héllo~ yöu")));
+        writer.commit().expect("committed");
+        k.sync(true).expect("synced");
+    }
+    // Verify that database of type B was written to disk.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::default()).expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(sk.get(&reader, "foo1").expect("read"), Some(Value::I64(5678)));
+        assert_eq!(sk.get(&reader, "bar1").expect("read"), Some(Value::Bool(false)));
+        assert_eq!(sk.get(&reader, "baz1").expect("read"), Some(Value::Str("héllo~ yöu")));
+    }
+    // Verify that database of type A still wasn't changed.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::default()).expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(sk.get(&reader, "foo").expect("read"), Some(Value::I64(1234)));
+        assert_eq!(sk.get(&reader, "bar").expect("read"), Some(Value::Bool(true)));
+        assert_eq!(sk.get(&reader, "baz").expect("read"), Some(Value::Str("héllo, yöu")));
+    }
+}