- change the test-server to support multi-DB operations

- update the client to use the product-variant info to allow multi-DB operations on Valkey
- unit test with the toy-server

Author: mgravell

src/StackExchange.Redis/ServerEndPoint.cs

@@ -91,7 +91,12 @@ public RedisServer GetRedisServer(object? asyncState)
         /// This is memoized because it's accessed on hot paths inside the write lock.
         /// </remarks>
         public bool SupportsDatabases =>
-            supportsDatabases ??= serverType == ServerType.Standalone && Multiplexer.CommandMap.IsAvailable(RedisCommand.SELECT);
+            supportsDatabases ??= serverType switch
+            {
+                ServerType.Standalone => true,
+                ServerType.Cluster => _productVariant is ProductVariant.Valkey,
+                _ => false,
+            } && Multiplexer.CommandMap.IsAvailable(RedisCommand.SELECT);
 
         public int Databases
         {
@@ -1140,6 +1145,7 @@ internal void SetProductVariant(ProductVariant variant, string productVersion)
         {
             _productVariant = variant;
             _productVersion = productVersion;
+            ClearMemoized(); // variant impacts multi-DB rules for cluster
         }
 
         internal ProductVariant GetProductVariant(out string productVersion)

tests/StackExchange.Redis.Tests/InProcessDatabaseUnitTests.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace StackExchange.Redis.Tests;
+
+[RunPerProtocol]
+public class InProcessDatabaseUnitTests(ITestOutputHelper output)
+{
+    [Fact]
+    public async Task DatabasesAreIsolatedAndCanBeFlushed()
+    {
+        using var server = new InProcessTestServer(output);
+        await using var conn = await server.ConnectAsync();
+
+        var admin = conn.GetServer(conn.GetEndPoints()[0]);
+        var key = (RedisKey)Guid.NewGuid().ToString("n");
+        var db0 = conn.GetDatabase(0);
+        var db1 = conn.GetDatabase(1);
+
+        db0.KeyDelete(key, CommandFlags.FireAndForget);
+        db1.KeyDelete(key, CommandFlags.FireAndForget);
+        db0.StringSet(key, "a");
+        db1.StringSet(key, "b");
+
+        Assert.Equal("a", db0.StringGet(key));
+        Assert.Equal("b", db1.StringGet(key));
+        Assert.Equal(1, admin.DatabaseSize(0));
+        Assert.Equal(1, admin.DatabaseSize(1));
+
+        admin.FlushDatabase(0);
+        Assert.True(db0.StringGet(key).IsNull);
+        Assert.Equal("b", db1.StringGet(key));
+
+        admin.FlushAllDatabases();
+        Assert.True(db1.StringGet(key).IsNull);
+        Assert.Equal(0, admin.DatabaseSize(0));
+        Assert.Equal(0, admin.DatabaseSize(1));
+    }
+}

tests/StackExchange.Redis.Tests/ProductVariantUnitTests.cs

@@ -14,7 +14,7 @@ public class ProductVariantUnitTests(ITestOutputHelper log)
     public async Task DetectProductVariant(ProductVariant variant)
     {
         using var serverObj = new ProductServer(variant, log);
-        using var conn = await serverObj.ConnectAsync();
+        using var conn = await serverObj.ConnectAsync(withPubSub: false);
         var serverApi = conn.GetServer(conn.GetEndPoints().First());
         serverApi.Ping();
         var reportedProduct = serverApi.GetProductVariant(out var reportedVersion);
@@ -30,14 +30,64 @@ public async Task DetectProductVariant(ProductVariant variant)
         }
     }
 
-    private sealed class ProductServer(ProductVariant variant, ITestOutputHelper log) : InProcessTestServer(log)
+    [Theory]
+    [InlineData(ProductVariant.Redis, ServerType.Standalone, true)]
+    [InlineData(ProductVariant.Redis, ServerType.Cluster, false)]
+    [InlineData(ProductVariant.Garnet, ServerType.Standalone, true)]
+    [InlineData(ProductVariant.Garnet, ServerType.Cluster, false)]
+    [InlineData(ProductVariant.Valkey, ServerType.Standalone, true)]
+    [InlineData(ProductVariant.Valkey, ServerType.Cluster, true)]
+    public async Task MultiDbSupportMatchesProductVariantAndServerType(ProductVariant variant, ServerType serverType, bool supportsMultiDb)
+    {
+        using var serverObj = new ProductServer(variant, log, serverType);
+        await using var conn = await serverObj.ConnectAsync(withPubSub: false);
+
+        var serverApi = conn.GetServer(conn.GetEndPoints().First());
+        await serverApi.PingAsync();
+        Assert.Equal(serverType, serverApi.ServerType);
+        Assert.Equal(variant, serverApi.GetProductVariant(out _));
+
+        RedisKey key = $"multidb:{variant}:{serverType}";
+        const string db0Value = "db0";
+        const string db1Value = "db1";
+        var db0 = conn.GetDatabase(0);
+
+        var db1 = conn.GetDatabase(1);
+
+        await db0.StringSetAsync(key, db0Value);
+
+        if (supportsMultiDb)
+        {
+            await db1.StringSetAsync(key, db1Value);
+            Assert.Equal(db0Value, (string?)await db0.StringGetAsync(key));
+            Assert.Equal(db1Value, (string?)await db1.StringGetAsync(key));
+        }
+        else
+        {
+            var ex = await Assert.ThrowsAsync<RedisConnectionException>(() => db1.StringSetAsync(key, db1Value));
+            var inner = Assert.IsType<RedisCommandException>(ex.InnerException);
+            Assert.Contains("cannot switch to database: 1", inner.Message);
+            Assert.Equal(db0Value, (string?)await db0.StringGetAsync(key));
+        }
+    }
+
+    private sealed class ProductServer : InProcessTestServer
     {
+        private readonly ProductVariant _variant;
+
+        public ProductServer(ProductVariant variant, ITestOutputHelper log, ServerType serverType = ServerType.Standalone)
+            : base(log)
+        {
+            _variant = variant;
+            ServerType = serverType;
+        }
+
         protected override void Info(StringBuilder sb, string section)
         {
             base.Info(sb, section);
             if (section is "Server")
             {
-                switch (variant)
+                switch (_variant)
                 {
                     case ProductVariant.Garnet:
                         sb.AppendLine("garnet_version:1.2.3-preview4");
@@ -49,5 +99,18 @@ protected override void Info(StringBuilder sb, string section)
                 }
             }
         }
+
+        protected override bool SupportMultiDb(out string err)
+        {
+            switch (_variant)
+            {
+                case ProductVariant.Valkey:
+                    // support multiple databases even on cluster
+                    err = "";
+                    return true;
+                default:
+                    return base.SupportMultiDb(out err);
+            }
+        }
     }
 }