Reviewed Environment and Database API for similar changes

Author: CoreyKaylor

src/LightningDB.Tests/DatabaseIOTests.cs

@@ -44,7 +44,7 @@ public void DatabaseGetShouldNotThrowExceptions()
         }
 
         [Fact]
-        public void DatabaseInsertedValueShouldBeRetrivedThen()
+        public void DatabaseInsertedValueShouldBeRetrievedThen()
         {
             var key = "key";
             var value = "value";

src/LightningDB.Tests/DatabaseTests.cs

@@ -166,7 +166,7 @@ public void TruncatingTheDatabase()
             db = _txn.OpenDatabase();
             var result = _txn.Get(db, UTF8.GetBytes("hello"));
 
-            Assert.Null(result);
+            Assert.Equal(MDBResultCode.NotFound, result.resultCode);
         }
     }
 }

src/LightningDB.Tests/TestHelperExtensions.cs

@@ -6,17 +6,17 @@ namespace LightningDB.Tests
 {
     public static class TestHelperExtensions
     {
-        public static void Put(this LightningTransaction tx, LightningDatabase db, string key, string value)
+        public static MDBResultCode Put(this LightningTransaction tx, LightningDatabase db, string key, string value)
         {
             var enc = System.Text.Encoding.UTF8;
-            tx.Put(db, enc.GetBytes(key), enc.GetBytes(value));
+            return tx.Put(db, enc.GetBytes(key), enc.GetBytes(value));
         }
 
         public static string Get(this LightningTransaction tx, LightningDatabase db, string key)
         {
             var enc = System.Text.Encoding.UTF8;
             var result = tx.Get(db, enc.GetBytes(key));
-            return enc.GetString(result);
+            return enc.GetString(result.value.CopyToNewArray());
         }
 
         public static void Delete(this LightningTransaction tx, LightningDatabase db, string key)
@@ -57,5 +57,14 @@ public static void RunCursorScenario(this LightningEnvironment env,
             using var cursor = tx.CreateCursor(db);
             scenario(tx, db, cursor);
         }
+        
+        public static void RunTransactionScenario(this LightningEnvironment env, 
+            Action<LightningTransaction, LightningDatabase> scenario,
+            DatabaseOpenFlags flags = DatabaseOpenFlags.Create, TransactionBeginFlags transactionFlags = TransactionBeginFlags.None)
+        {
+            using var tx = env.BeginTransaction(transactionFlags);
+            using var db = tx.OpenDatabase(configuration: new DatabaseConfiguration { Flags = flags });
+            scenario(tx, db);
+        }
     }
 }

src/LightningDB.Tests/TransactionTests.cs

@@ -7,11 +7,11 @@
 namespace LightningDB.Tests
 {
     [Collection("SharedFileSystem")]
-    public class TransactionDupFixedTests : IDisposable
+    public class TransactionTests : IDisposable
     {
-        private LightningEnvironment _env;
+        private readonly LightningEnvironment _env;
 
-        public TransactionDupFixedTests(SharedFileSystem fileSystem)
+        public TransactionTests(SharedFileSystem fileSystem)
         {
             var path = fileSystem.CreateNewDirectoryForTest();
             _env = new LightningEnvironment(path);
@@ -22,167 +22,143 @@ public void Dispose()
         {
             _env.Dispose();
         }
-
-
+        
         [Fact]
-        public void CanCountTransactionEntries()
+        public void CanDeletePreviouslyCommittedWithMultipleValuesByPassingNullForValue()
         {
-            LightningDatabase db;
-
-            using (var openDbTxn = _env.BeginTransaction())
-            {
-                db = openDbTxn.OpenDatabase();
-            }
-
-            var key = MemoryMarshal.Cast<char, byte>("abcd");
-
-            using(var writeTxn = _env.BeginTransaction())
+            _env.RunTransactionScenario((tx, db) =>
             {
-                writeTxn.Put(db, key, MemoryMarshal.Cast<char,byte>("Value1"));
-                writeTxn.Put(db, key, MemoryMarshal.Cast<char, byte>("Value2"));
-                writeTxn.Commit();
-            }
-
-            using (var delTxn = _env.BeginTransaction())
-            {
-                delTxn.Delete(db, key, null);//should not throw
-                delTxn.Commit();
-            }
-        }
-    }
-
-
-    [Collection("SharedFileSystem")]
-    public class TransactionTests : IDisposable
-    {
-        private LightningEnvironment _env;
-
-        public TransactionTests(SharedFileSystem fileSystem)
-        {
-            var path = fileSystem.CreateNewDirectoryForTest();
-            _env = new LightningEnvironment(path);
-            _env.Open();
-        }
+                var key = MemoryMarshal.Cast<char, byte>("abcd");
 
-        public void Dispose()
-        {
-            _env.Dispose();
+                tx.Put(db, key, MemoryMarshal.Cast<char, byte>("Value1"));
+                tx.Put(db, key, MemoryMarshal.Cast<char, byte>("Value2"), PutOptions.AppendData);
+                tx.Commit();
+                tx.Dispose();
+                
+                using var delTxn = _env.BeginTransaction();
+                var result = delTxn.Delete(db, key, null);
+                Assert.Equal(MDBResultCode.Success, result);
+                result = delTxn.Commit();
+                Assert.Equal(MDBResultCode.Success, result);
+            }, DatabaseOpenFlags.Create | DatabaseOpenFlags.DuplicatesFixed);
         }
 
         [Fact]
         public void TransactionShouldBeCreated()
         {
-            var txn = _env.BeginTransaction();
-
-            Assert.Equal(LightningTransactionState.Active, txn.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                Assert.Equal(LightningTransactionState.Active, tx.State);
+            });
         }
 
         [Fact]
         public void TransactionShouldBeAbortedIfEnvironmentCloses()
         {
-            var txn = _env.BeginTransaction();
-
-            _env.Dispose();
-
-            Assert.Equal(LightningTransactionState.Aborted, txn.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                _env.Dispose();
+                Assert.Equal(LightningTransactionState.Aborted, tx.State);
+            });
         }
 
         [Fact]
         public void TransactionShouldChangeStateOnCommit()
         {
-            var txn = _env.BeginTransaction();
-
-            txn.Commit();
-
-            Assert.Equal(LightningTransactionState.Commited, txn.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                tx.Commit();
+                Assert.Equal(LightningTransactionState.Commited, tx.State);
+            });
         }
 
         [Fact]
         public void ChildTransactionShouldBeCreated()
         {
-            var txn = _env.BeginTransaction();
-
-            var subTxn = txn.BeginTransaction();
-
-            Assert.Equal(LightningTransactionState.Active, subTxn.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                var subTxn = tx.BeginTransaction();
+                Assert.Equal(LightningTransactionState.Active, subTxn.State);
+            });
         }
 
         [Fact]
         public void ResetTransactionAbortedOnDispose()
         {
-            var txn = _env.BeginTransaction(TransactionBeginFlags.ReadOnly);
-            txn.Reset();
-            txn.Dispose();
-            Assert.Equal(LightningTransactionState.Aborted, txn.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                tx.Reset();
+                tx.Dispose();
+                Assert.Equal(LightningTransactionState.Aborted, tx.State);
+            }, transactionFlags: TransactionBeginFlags.ReadOnly);
         }
 
         [Fact]
         public void ChildTransactionShouldBeAbortedIfParentIsAborted()
         {
-            var txn = _env.BeginTransaction();
-            var child = txn.BeginTransaction();
-
-            txn.Abort();
-
-            Assert.Equal(LightningTransactionState.Aborted, child.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                var child = tx.BeginTransaction();
+                tx.Abort();
+                Assert.Equal(LightningTransactionState.Aborted, child.State);
+            });
         }
 
         [Fact]
         public void ChildTransactionShouldBeAbortedIfParentIsCommited()
         {
-            var txn = _env.BeginTransaction();
-            var child = txn.BeginTransaction();
-
-            txn.Commit();
-
-            Assert.Equal(LightningTransactionState.Aborted, child.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                var child = tx.BeginTransaction();
+                tx.Commit();
+                Assert.Equal(LightningTransactionState.Aborted, child.State);
+            });
         }
 
         [Fact]
         public void ChildTransactionShouldBeAbortedIfEnvironmentIsClosed()
         {
-            var txn = _env.BeginTransaction();
-            var child = txn.BeginTransaction();
-
-            _env.Dispose();
-
-            Assert.Equal(LightningTransactionState.Aborted, child.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                var child = tx.BeginTransaction();
+                _env.Dispose();
+                Assert.Equal(LightningTransactionState.Aborted, child.State);
+            });
         }
 
         [Fact]
         public void ReadOnlyTransactionShouldChangeStateOnReset()
         {
-            var txn = _env.BeginTransaction(TransactionBeginFlags.ReadOnly);
-
-            txn.Reset();
-
-            Assert.Equal(LightningTransactionState.Reseted, txn.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                tx.Reset();
+                Assert.Equal(LightningTransactionState.Reseted, tx.State);
+            }, transactionFlags: TransactionBeginFlags.ReadOnly);
         }
 
         [Fact]
         public void ReadOnlyTransactionShouldChangeStateOnRenew()
         {
-            var txn = _env.BeginTransaction(TransactionBeginFlags.ReadOnly);
-            txn.Reset();
-
-            txn.Renew();
-
-            Assert.Equal(LightningTransactionState.Active, txn.State);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                tx.Reset();
+                tx.Renew();
+                Assert.Equal(LightningTransactionState.Active, tx.State);
+            }, transactionFlags: TransactionBeginFlags.ReadOnly);
         }
 
         [Fact]
         public void CanCountTransactionEntries()
         {
-            var txn = _env.BeginTransaction();
-            var db = txn.OpenDatabase();
-
-            const int entriesCount = 10;
-            for (var i = 0; i < entriesCount; i++)
-                txn.Put(db, i.ToString(), i.ToString());
-
-            var count = txn.GetEntriesCount(db);
+            _env.RunTransactionScenario((tx, db) =>
+            {
+                const int entriesCount = 10;
+                for (var i = 0; i < entriesCount; i++)
+                    tx.Put(db, i.ToString(), i.ToString());
 
-            Assert.Equal(entriesCount, count);
+                var count = tx.GetEntriesCount(db);
+                Assert.Equal(entriesCount, count);
+            });
         }
 
         [Fact]