working unit tests and API shim

mgravell · mgravell · commit 70125100dd65 · 2026-02-15T14:18:31.000Z
diff --git a/src/StackExchange.Redis/PhysicalConnection.Read.cs b/src/StackExchange.Redis/PhysicalConnection.Read.cs
@@ -4,11 +4,11 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.IO.Pipelines;
 using System.Net;
-using System.Net.Sockets;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
-using Pipelines.Sockets.Unofficial;
 using RESPite.Buffers;
 using RESPite.Internal;
 using RESPite.Messages;
@@ -17,6 +17,8 @@ namespace StackExchange.Redis;
 
 internal sealed partial class PhysicalConnection
 {
+    internal static PhysicalConnection Dummy() => new(null!);
+
     private volatile ReadStatus _readStatus = ReadStatus.NotStarted;
     internal ReadStatus GetReadStatus() => _readStatus;
 
diff --git a/src/StackExchange.Redis/PhysicalConnection.cs b/src/StackExchange.Redis/PhysicalConnection.cs
@@ -85,6 +85,21 @@ internal void GetBytes(out long sent, out long received)
         private Socket? _socket;
         internal Socket? VolatileSocket => Volatile.Read(ref _socket);
 
+        // used for dummy test connections
+        public PhysicalConnection(
+            ConnectionType connectionType = ConnectionType.Interactive,
+            RedisProtocol protocol = RedisProtocol.Resp2,
+            [CallerMemberName] string name = "")
+        {
+            lastWriteTickCount = lastReadTickCount = Environment.TickCount;
+            lastBeatTickCount = 0;
+            this.connectionType = connectionType;
+            _protocol = protocol;
+            _bridge = new WeakReference(null);
+            _physicalName = name;
+
+            OnCreateEcho();
+        }
         public PhysicalConnection(PhysicalBridge bridge)
         {
             lastWriteTickCount = lastReadTickCount = Environment.TickCount;
@@ -275,7 +290,7 @@ private enum ReadMode : byte
         private RedisProtocol _protocol; // note starts at **zero**, not RESP2
         public RedisProtocol? Protocol => _protocol == 0 ? null : _protocol;
 
-        internal void SetProtocol(RedisProtocol value)
+        public void SetProtocol(RedisProtocol value)
         {
             _protocol = value;
             BridgeCouldBeNull?.SetProtocol(value);
diff --git a/src/StackExchange.Redis/ResultProcessor.cs b/src/StackExchange.Redis/ResultProcessor.cs
@@ -348,8 +348,50 @@ private bool HandleCommonError(Message message, RespReader reader, PhysicalBridg
 
         protected virtual bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader)
         {
-            // temp hack so we can compile; this should be abstract
-            return false;
+            // spoof the old API from the new API; this is a transitional step only, and is inefficient
+            var rawResult = AsRaw(ref reader, connection.Protocol is RedisProtocol.Resp3);
+            return SetResultCore(connection, message, rawResult);
+        }
+
+        private static RawResult AsRaw(ref RespReader reader, bool resp3)
+        {
+            var flags = RawResult.ResultFlags.HasValue;
+            if (!reader.IsNull) flags |= RawResult.ResultFlags.NonNull;
+            if (resp3) flags |= RawResult.ResultFlags.Resp3;
+            var type = Type(reader.Prefix);
+            if (reader.IsAggregate)
+            {
+                var inner = reader.ReadPastArray((ref value) => AsRaw(ref value, resp3), false) ?? [];
+                return new RawResult(type, new Sequence<RawResult>(inner), flags);
+            }
+
+            if (reader.IsScalar)
+            {
+                ReadOnlySequence<byte> blob = new(reader.ReadByteArray() ?? []);
+                return new RawResult(type, blob, flags);
+            }
+
+            return default;
+
+            static ResultType Type(RespPrefix prefix) => prefix switch
+            {
+                RespPrefix.Array => ResultType.Array,
+                RespPrefix.Attribute => ResultType.Attribute,
+                RespPrefix.BigInteger => ResultType.BigInteger,
+                RespPrefix.Boolean => ResultType.Boolean,
+                RespPrefix.BulkError => ResultType.BlobError,
+                RespPrefix.BulkString => ResultType.BulkString,
+                RespPrefix.SimpleString => ResultType.SimpleString,
+                RespPrefix.Map => ResultType.Map,
+                RespPrefix.Set => ResultType.Set,
+                RespPrefix.Double => ResultType.Double,
+                RespPrefix.Integer => ResultType.Integer,
+                RespPrefix.SimpleError => ResultType.Error,
+                RespPrefix.Null => ResultType.Null,
+                RespPrefix.VerbatimString => ResultType.VerbatimString,
+                RespPrefix.Push=> ResultType.Push,
+                _ => throw new ArgumentOutOfRangeException(nameof(prefix), prefix, null),
+            };
         }
 
         // temp hack so we can compile; this should be removed
@@ -1733,7 +1775,13 @@ private sealed class Int64ArrayProcessor : ResultProcessor<long[]>
         {
             protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
             {
-                if (result.Resp2TypeArray == ResultType.Array && !result.IsNull)
+                if (result.IsNull)
+                {
+                    SetResult(message, null!);
+                    return true;
+                }
+
+                if (result.Resp2TypeArray == ResultType.Array)
                 {
                     var arr = result.ToArray((in RawResult x) => (long)x.AsRedisValue())!;
                     SetResult(message, arr);
diff --git a/tests/StackExchange.Redis.Tests/Helpers/SharedConnectionFixture.cs b/tests/StackExchange.Redis.Tests/Helpers/SharedConnectionFixture.cs
@@ -17,23 +17,8 @@ namespace StackExchange.Redis.Tests;
 
 public class SharedConnectionFixture : IDisposable
 {
-    public bool IsEnabled { get; }
-
-    private readonly ConnectionMultiplexer _actualConnection;
-    public string Configuration { get; }
-
-    public SharedConnectionFixture()
-    {
-        IsEnabled = TestConfig.Current.UseSharedConnection;
-        Configuration = TestBase.GetDefaultConfiguration();
-        _actualConnection = TestBase.CreateDefault(
-            output: null,
-            clientName: nameof(SharedConnectionFixture),
-            configuration: Configuration,
-            allowAdmin: true);
-        _actualConnection.InternalError += OnInternalError;
-        _actualConnection.ConnectionFailed += OnConnectionFailed;
-    }
+    public bool IsEnabled { get; } = TestConfig.Current.UseSharedConnection;
+    public string Configuration { get; } = TestBase.GetDefaultConfiguration();
 
     private NonDisposingConnection? resp2, resp3;
     internal IInternalConnectionMultiplexer GetConnection(TestBase obj, RedisProtocol protocol, [CallerMemberName] string caller = "")
@@ -273,11 +258,16 @@ public void Teardown(TextWriter output)
             }
             // Assert.True(false, $"There were {privateFailCount} private ambient exceptions.");
         }
+        TearDown(resp2, output);
+        TearDown(resp3, output);
+    }
 
-        if (_actualConnection != null)
+    private void TearDown(IInternalConnectionMultiplexer? connection, TextWriter output)
+    {
+        if (connection is { } conn)
         {
-            TestBase.Log(output, "Connection Counts: " + _actualConnection.GetCounters().ToString());
-            foreach (var ep in _actualConnection.GetServerSnapshot())
+            TestBase.Log(output, "Connection Counts: " + conn.GetCounters().ToString());
+            foreach (var ep in conn.GetServerSnapshot())
             {
                 var interactive = ep.GetBridge(ConnectionType.Interactive);
                 TestBase.Log(output, $"  {Format.ToString(interactive)}: {interactive?.GetStatus()}");
diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests.cs
@@ -1,5 +1,7 @@
 ﻿using System;
 using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Text;
 using RESPite.Messages;
 using Xunit;
@@ -8,39 +10,84 @@ namespace StackExchange.Redis.Tests;
 
 public class ResultProcessorUnitTests(ITestOutputHelper log)
 {
-    public void Log(string message) => log?.WriteLine(message);
-
-    private protected static Message DummyMessage<T>()
-        => Message.Create(0, default, RedisCommand.UNKNOWN);
-
     [Theory]
     [InlineData(":1\r\n", 1)]
     [InlineData("+1\r\n", 1)]
     [InlineData("$1\r\n1\r\n", 1)]
-    public void Int32(string resp, int value)
-    {
-        var result = Execute(resp, ResultProcessor.Int32);
-        Assert.Equal(value, result);
-    }
+    [InlineData(":-42\r\n", -42)]
+    [InlineData("+-42\r\n", -42)]
+    [InlineData("$3\r\n-42\r\n", -42)]
+    public void Int32(string resp, int value) => Assert.Equal(value, Execute(resp, ResultProcessor.Int32));
+
+    [Theory]
+    [InlineData("+OK\r\n")]
+    [InlineData("$4\r\nPONG\r\n")]
+    public void FailingInt32(string resp) => ExecuteUnexpected(resp, ResultProcessor.Int32);
 
     [Theory]
     [InlineData(":1\r\n", 1)]
     [InlineData("+1\r\n", 1)]
     [InlineData("$1\r\n1\r\n", 1)]
-    public void Int64(string resp, int value)
+    [InlineData(":-42\r\n", -42)]
+    [InlineData("+-42\r\n", -42)]
+    [InlineData("$3\r\n-42\r\n", -42)]
+    public void Int64(string resp, long value) => Assert.Equal(value, Execute(resp, ResultProcessor.Int64));
+
+    [Theory]
+    [InlineData("+OK\r\n")]
+    [InlineData("$4\r\nPONG\r\n")]
+    public void FailingInt64(string resp) => ExecuteUnexpected(resp, ResultProcessor.Int64);
+
+    [Theory]
+    [InlineData("*-1\r\n", null)]
+    [InlineData("*0\r\n", "")]
+    [InlineData("*1\r\n+42\r\n", "42")]
+    [InlineData("*2\r\n+42\r\n:78\r\n", "42,78")]
+    public void Int64Array(string resp, string? value) => Assert.Equal(value, Join(Execute(resp, ResultProcessor.Int64Array)));
+
+    [return: NotNullIfNotNull(nameof(array))]
+    protected static string? Join<T>(T[]? array, string separator = ",")
     {
-        var result = Execute(resp, ResultProcessor.Int32);
-        Assert.Equal(value, result);
+        if (array is null) return null;
+        return string.Join(separator, array);
     }
 
-    private protected static T? Execute<T>(string resp, ResultProcessor<T> processor)
+    public void Log(string message) => log?.WriteLine(message);
+
+    private protected static Message DummyMessage<T>()
+        => Message.Create(0, default, RedisCommand.UNKNOWN);
+
+    private protected void ExecuteUnexpected<T>(
+        string resp,
+        ResultProcessor<T> processor,
+        ConnectionType connectionType = ConnectionType.Interactive,
+        RedisProtocol protocol = RedisProtocol.Resp2,
+        [CallerMemberName] string caller = "")
+    {
+        Assert.False(TryExecute(resp, processor, out _, out var ex));
+        if (ex is not null) Log(ex.Message);
+        Assert.StartsWith("Unexpected response to UNKNOWN:", Assert.IsType<RedisConnectionException>(ex).Message);
+    }
+    private protected static T? Execute<T>(
+        string resp,
+        ResultProcessor<T> processor,
+        ConnectionType connectionType = ConnectionType.Interactive,
+        RedisProtocol protocol = RedisProtocol.Resp2,
+        [CallerMemberName] string caller = "")
     {
         Assert.True(TryExecute<T>(resp, processor, out var value, out var ex));
         Assert.Null(ex);
         return value;
     }
 
-    private protected static bool TryExecute<T>(string resp, ResultProcessor<T> processor, out T? value, out Exception? exception)
+    private protected static bool TryExecute<T>(
+        string resp,
+        ResultProcessor<T> processor,
+        out T? value,
+        out Exception? exception,
+        ConnectionType connectionType = ConnectionType.Interactive,
+        RedisProtocol protocol = RedisProtocol.Resp2,
+        [CallerMemberName] string caller = "")
     {
         byte[]? lease = null;
         try
@@ -51,15 +98,15 @@ private protected static bool TryExecute<T>(string resp, ResultProcessor<T> proc
                 ? stackalloc byte[MAX_STACK]
                 : (lease = ArrayPool<byte>.Shared.Rent(maxLen));
 
-            var msg = DummyMessage<int>();
+            var msg = DummyMessage<T>();
             var box = SimpleResultBox<T>.Get();
             msg.SetSource(processor, box);
 
             var reader = new RespReader(oversized.Slice(0, Encoding.UTF8.GetBytes(resp, oversized)));
-            bool success = processor.SetResult(null!, msg, ref reader);
-            exception = null;
-            value = success ? box.GetResult(out exception, canRecycle: true) : default;
-            return success;
+            PhysicalConnection connection = new(connectionType, protocol, caller);
+            Assert.True(processor.SetResult(connection, msg, ref reader));
+            value = box.GetResult(out exception, canRecycle: true);
+            return exception is null;
         }
         finally
         {
