feat(Cachula.Redis): make CachulaRedisCacheSettings.BatchSize configurable

Author: ne4ta

src/Cachula.Redis/CachulaRedisCache.cs

@@ -14,21 +14,18 @@ public class CachulaRedisCache : ICachulaDistributedCache
 {
     private readonly IDatabase _redisDatabase;
     private readonly JsonSerializerOptions _serializerOptions;
-    private readonly CachulaRedisCacheSettings _settings = new()
-    {
-        // TODO: Make it configurable via DI or options pattern.
-        BatchSize = 100,
-    };
+    private readonly CachulaRedisCacheSettings _settings;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="CachulaRedisCache"/> class.
     /// </summary>
     /// <param name="redisDatabase">The Redis database instance.</param>
     /// <param name="serializerOptions">Optional serializer options for JSON serialization.</param>
+    /// <param name="settings">Optional settings for Cachula Redis cache (e.g., BatchSize).</param>
     /// <remarks>
     /// This constructor requires an instance of <see cref="IDatabase"/> from StackExchange.Redis.
     /// </remarks>
-    public CachulaRedisCache(IDatabase redisDatabase, JsonSerializerOptions? serializerOptions = null)
+    public CachulaRedisCache(IDatabase redisDatabase, JsonSerializerOptions? serializerOptions = null, CachulaRedisCacheSettings? settings = null)
     {
         _redisDatabase = redisDatabase ?? throw new ArgumentNullException(nameof(redisDatabase));
         _serializerOptions = serializerOptions ?? new JsonSerializerOptions
@@ -38,6 +35,11 @@ public CachulaRedisCache(IDatabase redisDatabase, JsonSerializerOptions? seriali
             //// This helps reduce payload size and avoids unnecessary data storage.
             DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
         };
+        _settings = settings ?? new CachulaRedisCacheSettings();
+        if (_settings.BatchSize <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(settings), "BatchSize must be greater than zero.");
+        }
     }
 
     /// <inheritdoc />

src/Cachula/Configurations/CachulaRedisCacheSettings.cs

@@ -8,5 +8,5 @@ public class CachulaRedisCacheSettings
     /// <summary>
     /// Gets the batch size for Redis cache operations.
     /// </summary>
-    public int BatchSize { get; init; }
+    public int BatchSize { get; init; } = 100;
 }

tests/Cachula.Redis.Tests/CachulaRedisCacheTests/CachulaRedisCache_BatchSize_Tests.cs

@@ -0,0 +1,73 @@
+using Cachula.Configurations;
+using StackExchange.Redis;
+
+namespace Cachula.Redis.Tests.CachulaRedisCacheTests;
+
+[TestFixture]
+public class CachulaRedisCache_BatchSize_Tests
+{
+    [Test]
+    public void Ctor_ThrowsArgumentOutOfRange_WhenBatchSizeIsZeroOrNegative()
+    {
+        var db = Substitute.For<IDatabase>();
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => new CachulaRedisCache(db, settings: new CachulaRedisCacheSettings { BatchSize = 0 }));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new CachulaRedisCache(db, settings: new CachulaRedisCacheSettings { BatchSize = -5 }));
+    }
+
+    [Test]
+    public async Task SetManyAsync_SplitsIntoBatches_BySettingsBatchSize()
+    {
+        // Arrange
+        var db = Substitute.For<IDatabase>();
+        var settings = new CachulaRedisCacheSettings { BatchSize = 2 };
+        var executeCalls = 0;
+        var createBatchCalls = 0;
+        var batches = new List<IBatch>();
+
+        db.CreateBatch().Returns(ci =>
+        {
+            createBatchCalls++;
+            var batch = Substitute.For<IBatch>();
+            batches.Add(batch);
+
+            batch.StringSetAsync(
+                    Arg.Any<RedisKey>(),
+                    Arg.Any<RedisValue>(),
+                    Arg.Any<TimeSpan?>(),
+                    Arg.Any<When>(),
+                    Arg.Any<CommandFlags>())
+                .Returns(Task.FromResult(true));
+
+            batch.When(b => b.Execute()).Do(_ => executeCalls++);
+
+            return batch;
+        });
+
+        var cache = new CachulaRedisCache(db, settings: settings);
+        var values = new Dictionary<string, string>
+        {
+            ["k1"] = "v1",
+            ["k2"] = "v2",
+            ["k3"] = "v3",
+            ["k4"] = "v4",
+            ["k5"] = "v5",
+        };
+
+        // Act
+        await cache.SetManyAsync(values, TimeSpan.FromMinutes(1));
+        
+        // Assert
+        Assert.Multiple(() =>
+        {
+            // With BatchSize=2 and 5 items, we expect 3 batches (2+2+1)
+            Assert.That(createBatchCalls, Is.EqualTo(3));
+            Assert.That(executeCalls, Is.EqualTo(3));
+        });
+
+        var stringSetCallsTotal = batches
+            .SelectMany(b => b.ReceivedCalls())
+            .Count(ci => ci.GetMethodInfo().Name == nameof(IBatch.StringSetAsync));
+        Assert.That(stringSetCallsTotal, Is.EqualTo(5));
+    }
+}