Added LockFile connection type

Author: surgicalcoder

LiteDBX.Tests/Database/ConnectionString_Tests.cs

@@ -31,6 +31,10 @@ public void ConnectionString_Parser()
         full.Password.Should().Be("john-doe ");
         full.ReadOnly.Should().BeTrue();
         full.InitialSize.Should().Be(10 * 1024 * 1024);
+
+        var lockFile = new ConnectionString(@"filename=demo.db;connection=LockFile");
+
+        lockFile.Connection.Should().Be(ConnectionType.LockFile);
     }
 
     [Fact]

LiteDBX.Tests/Engine/LockFileEngine_Tests.cs

@@ -0,0 +1,94 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace LiteDbX.Tests.Engine;
+
+public class LockFileEngine_Tests
+{
+    [Fact]
+    public void Constructor_Requires_Physical_Filename()
+    {
+        Action act = () => _ = new LockFileEngine(new LiteDbX.Engine.EngineSettings { Filename = ":memory:" });
+
+        act.Should().Throw<NotSupportedException>()
+            .WithMessage("*physical Filename*");
+    }
+
+    [Fact]
+    public async Task Write_Waits_For_Lock_File_And_Honours_Cancellation()
+    {
+        using var file = new TempFile();
+        var lockFilename = FileHelper.GetLockFile(file.Filename);
+
+        await using var database = new LiteDatabase(new ConnectionString
+        {
+            Filename = file.Filename,
+            Connection = ConnectionType.LockFile
+        });
+
+        var collection = database.GetCollection("lockfile");
+
+        using (new FileStream(lockFilename, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None))
+        {
+            using (var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(250)))
+            {
+                await Assert.ThrowsAnyAsync<OperationCanceledException>(async () =>
+                {
+                    await collection.Insert(new BsonDocument(), cts.Token);
+                });
+            }
+        }
+
+        await collection.Insert(new BsonDocument());
+        (await collection.Count()).Should().Be(1);
+    }
+
+    [Fact]
+    public async Task Separate_Database_Instances_Can_Write_Sequentially_To_Same_File()
+    {
+        using var file = new TempFile();
+
+        await using var first = new LiteDatabase(new ConnectionString
+        {
+            Filename = file.Filename,
+            Connection = ConnectionType.LockFile
+        });
+
+        await using var second = new LiteDatabase(new ConnectionString
+        {
+            Filename = file.Filename,
+            Connection = ConnectionType.LockFile
+        });
+
+        var firstCollection = first.GetCollection("items");
+        var secondCollection = second.GetCollection("items");
+
+        await firstCollection.Insert(new BsonDocument { ["name"] = "first" });
+        await secondCollection.Insert(new BsonDocument { ["name"] = "second" });
+
+        (await firstCollection.Count()).Should().Be(2);
+        (await secondCollection.Count()).Should().Be(2);
+    }
+
+    [Fact]
+    public async Task Read_First_On_New_File_Creates_Database_Safely()
+    {
+        using var file = new TempFile();
+
+        await using var database = new LiteDatabase(new ConnectionString
+        {
+            Filename = file.Filename,
+            Connection = ConnectionType.LockFile
+        });
+
+        var collection = database.GetCollection("items");
+
+        (await collection.Count()).Should().Be(0);
+        File.Exists(file.Filename).Should().BeTrue();
+    }
+}
+

LiteDBX.Tests/Engine/Recursion_Tests.cs

@@ -7,10 +7,12 @@ namespace LiteDbX.Tests.Engine;
 
 public class Recursion_Tests
 {
-    [Fact]
-    public async Task UpdateInFindAll()
+    [Theory]
+    [InlineData(ConnectionType.Shared)]
+    [InlineData(ConnectionType.LockFile)]
+    public async Task UpdateInFindAll(ConnectionType connectionType)
     {
-        await Test(async collection =>
+        await Test(connectionType, async collection =>
         {
             var updated = 0;
 
@@ -25,10 +27,12 @@ await Test(async collection =>
         });
     }
 
-    [Fact]
-    public async Task InsertDeleteInFindAll()
+    [Theory]
+    [InlineData(ConnectionType.Shared)]
+    [InlineData(ConnectionType.LockFile)]
+    public async Task InsertDeleteInFindAll(ConnectionType connectionType)
     {
-        await Test(async collection =>
+        await Test(connectionType, async collection =>
         {
             var iterations = 0;
 
@@ -44,10 +48,12 @@ await Test(async collection =>
         });
     }
 
-    [Fact]
-    public async Task QueryInFindAll()
+    [Theory]
+    [InlineData(ConnectionType.Shared)]
+    [InlineData(ConnectionType.LockFile)]
+    public async Task QueryInFindAll(ConnectionType connectionType)
     {
-        await Test(async collection =>
+        await Test(connectionType, async collection =>
         {
             var iterations = 0;
 
@@ -61,10 +67,12 @@ await Test(async collection =>
         });
     }
 
-    [Fact]
-    public async Task BreakInFindAll_ReleasesSharedLease()
+    [Theory]
+    [InlineData(ConnectionType.Shared)]
+    [InlineData(ConnectionType.LockFile)]
+    public async Task BreakInFindAll_ReleasesSharedLease(ConnectionType connectionType)
     {
-        await Test(async collection =>
+        await Test(connectionType, async collection =>
         {
             var iterations = 0;
 
@@ -82,14 +90,14 @@ await Test(async collection =>
         });
     }
 
-    private static async Task Test(Func<ILiteCollection<BsonDocument>, Task> action)
+    private static async Task Test(ConnectionType connectionType, Func<ILiteCollection<BsonDocument>, Task> action)
     {
         using var file = new TempFile();
 
         await using var database = new LiteDatabase(new ConnectionString
         {
             Filename = file.Filename,
-            Connection = ConnectionType.Shared
+            Connection = connectionType
         });
 
         var accounts = database.GetCollection("Recursion");