Added cursor tests + cursor ext methods

Also  project structure and Cursor menbers are refactored

Author: ilyalukyanov

src/LightningDB.Tests/CursorTests.cs

@@ -0,0 +1,223 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace LightningDB.Tests
+{
+    [TestFixture]
+    public class CursorTests
+    {
+        private string _path;
+        private LightningEnvironment _env;
+        private LightningTransaction _txn;
+        private LightningDatabase _db;
+
+        public CursorTests()
+        {
+            var location = typeof(EnvironmentTests).Assembly.Location;
+            _path = Path.Combine(Path.GetDirectoryName(location), "TestDb");
+        }
+
+        [SetUp]
+        public void Init()
+        {
+            Directory.CreateDirectory(_path);
+
+            _env = new LightningEnvironment(_path, EnvironmentOpenFlags.None);
+            _env.Open();
+
+            _txn = _env.BeginTransaction();
+            _db = _txn.OpenDatabase();
+        }
+
+        [TearDown]
+        public void Cleanup()
+        {
+            _txn.Commit();
+            _env.Close();
+
+            if (Directory.Exists(_path))
+                Directory.Delete(_path, true);
+        }
+
+        private void PopulateCursorValues()
+        {
+            using (var cur = _txn.CreateCursor(_db))
+            {
+                var keys = Enumerable.Range(1, 5)
+                    .Select(i => Encoding.UTF8.GetBytes("key" + i))
+                    .ToArray();
+
+                //act
+                foreach (var k in keys)
+                {
+                    cur.Put(k, k, PutOptions.None);
+                }
+            }
+        }
+
+        [Test]
+        public void CursorShouldBeCreated()
+        {
+            //arrange
+            
+            //act
+
+            //assert
+            _txn.CreateCursor(_db);
+        }
+
+        [Test]
+        public void CursorShouldPutValues()
+        {
+            //arrange
+            
+            //act
+
+            //assert
+            this.PopulateCursorValues();
+        }
+
+        [Test]
+        public void CursorShouldMoveToLast()
+        {
+            //arrange
+            this.PopulateCursorValues();
+
+            //assert
+
+            using (var cur = _txn.CreateCursor(_db))
+            {
+                var last = cur.MoveToLast().Value;
+
+                var lastKey = Encoding.UTF8.GetString(last.Key);
+                var lastValue = Encoding.UTF8.GetString(last.Value);
+
+                Assert.AreEqual("key5", lastKey);
+                Assert.AreEqual("key5", lastValue);
+            }
+        }
+
+        [Test]
+        public void CursorShouldMoveToFirst()
+        {
+            //arrange
+            this.PopulateCursorValues();
+
+            //assert
+
+            using (var cur = _txn.CreateCursor(_db))
+            {
+                var last = cur.MoveToFirst().Value;
+
+                var lastKey = Encoding.UTF8.GetString(last.Key);
+                var lastValue = Encoding.UTF8.GetString(last.Value);
+
+                Assert.AreEqual("key1", lastKey);
+                Assert.AreEqual("key1", lastValue);
+            }
+        }
+
+        [Test]
+        public void ShouldIterateThroughCursor()
+        {
+            //arrange
+            this.PopulateCursorValues();
+                        
+            using (var cur = _txn.CreateCursor(_db))
+            {
+                var i = 0;
+
+                //act
+                while (true)
+                {
+                    var current = cur.MoveNext();
+                    if (!current.HasValue)
+                        break;
+
+                    var key = Encoding.UTF8.GetString(current.Value.Key);
+                    var value = Encoding.UTF8.GetString(current.Value.Value);
+
+                    var name = "key" + ++i;
+
+                    //assert
+
+                    Assert.AreEqual(name, key);
+                    Assert.AreEqual(name, value);
+                }                
+            }
+        }
+
+        [Test]
+        public void ShouldIterateThroughCursorByExtensions()
+        {
+            //arrange
+            this.PopulateCursorValues();
+
+            using (var cur = _txn.CreateCursor(_db))
+            {
+                var i = 0;
+
+                //act
+                for(var current = cur.MoveToFirstBy(); current.PairExists; current = cur.MoveNextBy())
+                {
+                    var pair = current.Pair<string, string>();
+                    var name = "key" + ++i;
+
+                    //assert
+
+                    Assert.AreEqual(name, pair.Key);
+                    Assert.AreEqual(name, pair.Value);
+                }
+            }
+        }
+
+        [Test]
+        public void CursorShouldDeleteElements()
+        {
+            //arrange
+            this.PopulateCursorValues();
+
+            using (var cur = _txn.CreateCursor(_db))
+            {
+                var i = 0;
+
+                //act
+                for (var current = cur.MoveToFirstBy(); current.PairExists && i < 2; current = cur.MoveNextBy(), i++)
+                {
+                    cur.Delete();
+                }
+
+                //assert
+                for (var current = cur.MoveToFirstBy(); current.PairExists; current = cur.MoveNextBy())
+                {
+                    var key = current.Key<string>();
+
+                    Assert.AreNotEqual("key1", key);
+                    Assert.AreNotEqual("key2", key);
+                }
+            }
+        }
+
+        [Test]
+        public void ShouldIterateThroughCursorByEnumerator()
+        {
+            //arrange
+            this.PopulateCursorValues();
+
+            var i = 0;
+            foreach (var pair in _txn.EnumerateDatabase<string, string>(_db))
+            {
+                var name = "key" + ++i;
+
+                //assert
+
+                Assert.AreEqual(name, pair.Key);
+                Assert.AreEqual(name, pair.Value);
+            }
+        }
+    }
+}

src/LightningDB.Tests/LightningDB.Tests.csproj

@@ -68,6 +68,7 @@
     <Otherwise />
   </Choose>
   <ItemGroup>
+    <Compile Include="CursorTests.cs" />
     <Compile Include="DatabaseIOTests.cs" />
     <Compile Include="DatabaseTests.cs" />
     <Compile Include="EnvironmentTests.cs" />

src/LightningDB/Collections/CursorEnumerable.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace LightningDB.Collections
+{
+    class CursorGenericEnumerable<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
+    {
+        private LightningTransaction _tx;
+        private LightningDatabase _db;
+
+        public CursorGenericEnumerable(LightningTransaction tx, LightningDatabase db)
+        {
+            if (tx == null)
+                throw new ArgumentNullException("tx");
+
+            if (db == null)
+                throw new ArgumentNullException("db");
+
+            _tx = tx;
+            _db = db;
+        }
+
+        #region IEnumerable<KeyValuePair<TKey,TValue>> Members
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            var cur = _tx.CreateCursor(_db);
+
+            return new CursorGenericEnumerator<TKey, TValue>(cur);
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+
+        #endregion
+    }
+}

src/LightningDB/Collections/CursorEnumerator.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace LightningDB.Collections
+{
+    class CursorEnumerator : IEnumerator<CursorGetByOperation>
+    {
+        private LightningCursor _cur;
+
+        public CursorEnumerator(LightningCursor cur)
+        {
+            _cur = cur;
+        }
+
+        #region IEnumerator<CursorGetByOperation> Members
+
+        public CursorGetByOperation Current { get; private set; }
+
+        #endregion
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            if (_cur != null)
+                _cur.Dispose();
+        }
+
+        #endregion
+
+        #region IEnumerator Members
+
+        object IEnumerator.Current { get { return this.Current; } }
+
+        public bool MoveNext()
+        {
+            var next = _cur.MoveNextBy();
+
+            this.Current = next.PairExists
+                ? next
+                : null;
+
+            return next.PairExists;
+        }
+
+        public void Reset()
+        {
+            _cur.Renew();
+        }
+
+        #endregion
+    }
+}

src/LightningDB/Collections/CursorGenericEnumerable.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace LightningDB.Collections
+{
+    class CursorEnumerable : IEnumerable<CursorGetByOperation>
+    {
+        private LightningTransaction _tx;
+        private LightningDatabase _db;
+
+        public CursorEnumerable(LightningTransaction tx, LightningDatabase db)
+        {
+            if (tx == null)
+                throw new ArgumentNullException("tx");
+
+            if (db == null)
+                throw new ArgumentNullException("db");
+
+            _tx = tx;
+            _db = db;
+        }
+
+        #region IEnumerable<CursorGetByOperation> Members
+
+        public IEnumerator<CursorGetByOperation> GetEnumerator()
+        {
+            var cur = _tx.CreateCursor(_db);
+
+            return new CursorEnumerator(cur);
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+
+        #endregion
+    }
+}