0.5.6 update and improving file based storage resiliency (#185)

- References are only saved on set, not on flush. Required to avoid excessive serialisation or IO
- Added logging capability
- FileStorage now writes to a temp file and moves to original location (framework dependent how). Should provide better resiliency in case app crashes
- Set version to 0.5.6

Author: peter-quix

src/CsharpClient/QuixStreams.RawReadSamples/QuixStreams.RawReadSamples.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <Configurations>Debug;Release;Python</Configurations>
     <Platforms>AnyCPU</Platforms>
   </PropertyGroup>

src/CsharpClient/QuixStreams.State.UnitTests/BaseCrudShould.cs

@@ -4,11 +4,19 @@
 using QuixStreams.State.Storage;
 using QuixStreams.State.Storage.FileStorage;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace QuixStreams.State.UnitTests
 {
     public abstract class BaseCRUDShould
     {
+        protected readonly ITestOutputHelper output;
+
+        public BaseCRUDShould(ITestOutputHelper output)
+        {
+            this.output = output;
+        }
+        
         protected abstract BaseFileStorage GetStorage();
 
         protected async Task testLong(BaseFileStorage storage, string key, long inp)
@@ -190,5 +198,36 @@ public async Task TestClearStorage()
             (await storage.GetAllKeysAsync()).Length.Should().Be(0);
         }
 
+        [Theory(Skip = "Intended for local use only")]
+        [InlineData(100, 512)]
+        [InlineData(1000, 512)]
+
+        [InlineData(100, 1024*1024)]
+        [InlineData(1000, 1024*1024)]
+        
+        [InlineData(10, 1024*1024*1024)]
+        [InlineData(100, 1024*1024*1024)]
+        public async Task PerfTest(int count, int size)
+        {
+            var start = DateTime.UtcNow;
+
+            var storage = this.GetStorage();
+            
+            var bytes = new byte[size];
+            var random = new Random();
+
+            for (int i = 0; i < count; i++)
+            {
+                random.NextBytes(bytes);
+                await storage.SaveRaw($"KEY_{i}", bytes);
+                await storage.SaveRaw($"KEY_{i}", bytes);
+            }
+
+
+            var end = DateTime.UtcNow;
+            this.output.WriteLine($"Took {end-start:g}");
+
+        }
+
     }
 }

src/CsharpClient/QuixStreams.State.UnitTests/LocalCrudShould.cs

@@ -1,15 +1,20 @@
+using Quix.TestBase.Extensions;
 using QuixStreams.State.Storage;
 using QuixStreams.State.Storage.FileStorage;
 using QuixStreams.State.Storage.FileStorage.LocalFileStorage;
+using Xunit.Abstractions;
 
 namespace QuixStreams.State.UnitTests
 {
     public class LocalCRUDShould : BaseCRUDShould
     {
-        override
-        protected BaseFileStorage GetStorage()
+        public LocalCRUDShould(ITestOutputHelper output) : base(output)
         {
-            var storage = new LocalFileStorage();
+        }
+        
+        protected override BaseFileStorage GetStorage()
+        {
+            var storage = new LocalFileStorage(loggerFactory:this.output.CreateLoggerFactory());
             storage.Clear();
             return storage;
         }

src/CsharpClient/QuixStreams.State.UnitTests/ScalarStateShould.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using FluentAssertions;
 using QuixStreams.State.Storage;
 using Xunit;
@@ -64,6 +65,36 @@ public void Flush_Value_ShouldPersistChangesToStorage()
             storage.Get(ScalarState.StorageKey).StringValue.Should().BeEquivalentTo("value");
         }
 
+        [Fact]
+        public void ListConversion_ShouldStoreAndRetrieveCorrectly()
+        {
+            var storage = new InMemoryStorage();
+            var key = "TestKey";
+            var state = new DictionaryState<List<int>>(storage);
+            state.Clear();
+
+            var list = new List<int>();
+            state[key] = list;
+            state[key].Add(1);
+            list.Add(2);
+            list.Add(3);
+
+            // No change is expected!
+            state[key].Should().BeEquivalentTo(new List<StateTemplatedShould.CustomClass>());
+
+            state[key] = list;
+
+            state[key].Count.Should().Be(2);
+            state[key].Should().BeEquivalentTo(list, o => o.WithStrictOrdering());
+
+            state.Flush();
+
+            var state2 = new DictionaryState<List<int>>(storage);
+
+            state2[key].Count.Should().Be(2);
+            state2[key].Should().BeEquivalentTo(list, o => o.WithStrictOrdering());
+        }
+        
         [Fact]
         public void Flush_ClearBeforeFlush_ShouldClearStorage()
         {