feat(foundationdb): add validation for a Directory layer

Author: PierreZ

foundationdb/src/directory/mod.rs

@@ -117,13 +117,13 @@ impl DirectoryLayer {
         txn: &Transaction,
         paths: Vec<String>,
     ) -> Result<Subspace, DirectoryError> {
-        self.create_or_open_internal(txn, paths, vec![], vec![], true, true)
+        self.create_or_open_internal(txn, paths, vec![], true, true)
             .await
     }
 
     /// Creates a directory located at path (creating parent directories if necessary).
     pub async fn create(&self, txn: &Transaction, paths: Vec<String>) -> Option<DirectoryError> {
-        self.create_or_open_internal(txn, paths, vec![], vec![], true, false)
+        self.create_or_open_internal(txn, paths, vec![], true, false)
             .await
             .err()
     }
@@ -134,7 +134,7 @@ impl DirectoryLayer {
         txn: &Transaction,
         paths: Vec<String>,
     ) -> Result<Subspace, DirectoryError> {
-        self.create_or_open_internal(txn, paths, vec![], vec![], false, true)
+        self.create_or_open_internal(txn, paths, vec![], false, true)
             .await
     }
 
@@ -143,7 +143,6 @@ impl DirectoryLayer {
         trx: &Transaction,
         paths: Vec<String>,
         prefix: Vec<u8>,
-        layer: Vec<u8>,
         allow_create: bool,
         allow_open: bool,
     ) -> Result<Subspace, DirectoryError> {
@@ -178,8 +177,8 @@ impl DirectoryLayer {
                 return Err(DirectoryError::DirAlreadyExists);
             }
 
-            if layer.len() > 0 {
-                node.check_layer(layer)?;
+            if self.layer.len() > 0 {
+                node.check_layer(self.layer.to_owned())?;
             }
 
             return Ok(node.content_subspace.clone().unwrap());

foundationdb/tests/directory.rs

@@ -5,11 +5,42 @@
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
 
+use foundationdb::directory::error::DirectoryError;
 use foundationdb::directory::DirectoryLayer;
 use foundationdb::*;
 
 mod common;
 
+#[test]
+fn test_directory() {
+    let _guard = unsafe { foundationdb::boot() };
+    let db = futures::executor::block_on(common::database()).expect("cannot open fdb");
+
+    eprintln!("clearing all keys");
+    let trx = db.create_trx().expect("cannot create txn");
+    trx.clear_range(b"\x00", b"\xff");
+    futures::executor::block_on(trx.commit()).expect("could not clear keys");
+
+    eprintln!("creating directories");
+    let directory = DirectoryLayer::default();
+
+    futures::executor::block_on(test_create_or_open_async(
+        &db,
+        &directory,
+        vec![String::from("a")],
+    ))
+    .expect("failed to run");
+
+    futures::executor::block_on(test_create_then_open_async(
+        &db,
+        &directory,
+        vec![String::from("b"), String::from("a")],
+    ))
+    .expect("failed to run");
+
+    futures::executor::block_on(test_bad_layer(&db)).expect("failed to run");
+}
+
 async fn test_create_then_open_async(
     db: &Database,
     directory: &DirectoryLayer,
@@ -42,30 +73,29 @@ async fn test_create_or_open_async(
     Ok(())
 }
 
-#[test]
-fn test_directory() {
-    let _guard = unsafe { foundationdb::boot() };
-    let db = futures::executor::block_on(common::database()).expect("cannot open fdb");
+async fn test_bad_layer(db: &Database) -> Result<(), DirectoryError> {
+    let directory = DirectoryLayer {
+        layer: vec![0u8],
+        ..Default::default()
+    };
+    let trx = db.create_trx()?;
 
-    eprintln!("clearing all keys");
-    let trx = db.create_trx().expect("cannot create txn");
-    trx.clear_range(b"\x00", b"\xff");
-    futures::executor::block_on(trx.commit()).expect("could not clear keys");
+    directory
+        .create_or_open(&trx, vec![String::from("bad_layer")])
+        .await?;
 
-    eprintln!("creating directories");
-    let directory = DirectoryLayer::default();
+    let directory = DirectoryLayer {
+        layer: vec![1u8],
+        ..Default::default()
+    };
 
-    futures::executor::block_on(test_create_or_open_async(
-        &db,
-        &directory,
-        vec![String::from("a")],
-    ))
-    .expect("failed to run");
+    let result = directory
+        .create_or_open(&trx, vec![String::from("bad_layer")])
+        .await;
+    match result {
+        Err(DirectoryError::IncompatibleLayer) => {}
+        _ => panic!("should have been an IncompatibleLayer error"),
+    }
 
-    futures::executor::block_on(test_create_then_open_async(
-        &db,
-        &directory,
-        vec![String::from("b"), String::from("a")],
-    ))
-    .expect("failed to run");
+    Ok(())
 }