more processors

Author: mgravell

src/StackExchange.Redis/ResultProcessor.cs

@@ -1120,50 +1120,46 @@ private static bool TryParseRole(string? val, out bool isReplica)
 
         private sealed class BooleanProcessor : ResultProcessor<bool>
         {
-            protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
+            protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader)
             {
-                if (result.IsNull)
+                if (reader.IsNull)
                 {
                     SetResult(message, false); // lots of ops return (nil) when they mean "no"
                     return true;
                 }
-                switch (result.Resp2TypeBulkString)
+                switch (reader.Resp2PrefixBulkString)
                 {
-                    case ResultType.SimpleString:
-                        if (result.IsEqual(CommonReplies.OK))
+                    case RespPrefix.SimpleString:
+                        if (reader.IsOK())
                         {
                             SetResult(message, true);
                         }
                         else
                         {
-                            SetResult(message, result.GetBoolean());
+                            SetResult(message, reader.ReadBoolean());
                         }
                         return true;
-                    case ResultType.Integer:
-                    case ResultType.BulkString:
-                        SetResult(message, result.GetBoolean());
+                    case RespPrefix.Integer:
+                    case RespPrefix.BulkString:
+                        SetResult(message, reader.ReadBoolean());
+                        return true;
+                    case RespPrefix.Array when reader.TryReadNext() && reader.IsScalar && reader.ReadBoolean() is var value && !reader.TryReadNext():
+                        // treat an array of 1 like a single reply (for example, SCRIPT EXISTS)
+                        SetResult(message, value);
                         return true;
-                    case ResultType.Array:
-                        var items = result.GetItems();
-                        if (items.Length == 1)
-                        { // treat an array of 1 like a single reply (for example, SCRIPT EXISTS)
-                            SetResult(message, items[0].GetBoolean());
-                            return true;
-                        }
-                        break;
                 }
                 return false;
             }
         }
 
         private sealed class ByteArrayProcessor : ResultProcessor<byte[]?>
         {
-            protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
+            protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader)
             {
-                switch (result.Resp2TypeBulkString)
+                switch (reader.Resp2PrefixBulkString)
                 {
-                    case ResultType.BulkString:
-                        SetResult(message, result.GetBlob());
+                    case RespPrefix.BulkString:
+                        SetResult(message, reader.ReadByteArray());
                         return true;
                 }
                 return false;
@@ -2838,20 +2834,21 @@ protected override KeyValuePair<string, string> Parse(in RawResult first, in Raw
 
         private sealed class StringProcessor : ResultProcessor<string?>
         {
-            protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
+            protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader)
             {
-                switch (result.Resp2TypeBulkString)
+                switch (reader.Resp2PrefixBulkString)
                 {
-                    case ResultType.Integer:
-                    case ResultType.SimpleString:
-                    case ResultType.BulkString:
-                        SetResult(message, result.GetString());
+                    case RespPrefix.Integer:
+                    case RespPrefix.SimpleString:
+                    case RespPrefix.BulkString:
+                        SetResult(message, reader.ReadString());
                         return true;
-                    case ResultType.Array:
-                        var arr = result.GetItems();
-                        if (arr.Length == 1)
+                    case RespPrefix.Array when reader.TryReadNext() && reader.IsScalar:
+                        // treat an array of 1 like a single reply
+                        var value = reader.ReadString();
+                        if (!reader.TryReadNext())
                         {
-                            SetResult(message, arr[0].GetString());
+                            SetResult(message, value);
                             return true;
                         }
                         break;

tests/StackExchange.Redis.Tests/ResultProcessorUnitTests.cs

@@ -99,6 +99,48 @@ public class ResultProcessorUnitTests(ITestOutputHelper log)
     [InlineData(ATTRIB_FOO_BAR + ",3.14\r\n", 3.14)]
     public void NullableDouble(string resp, double? value) => Assert.Equal(value, Execute(resp, ResultProcessor.NullableDouble));
 
+    [Theory]
+    [InlineData("_\r\n", false)] // null = false
+    [InlineData(":0\r\n", false)]
+    [InlineData(":1\r\n", true)]
+    [InlineData("#f\r\n", false)]
+    [InlineData("#t\r\n", true)]
+    [InlineData("+OK\r\n", true)]
+    [InlineData(ATTRIB_FOO_BAR + ":1\r\n", true)]
+    public void Boolean(string resp, bool value) => Assert.Equal(value, Execute(resp, ResultProcessor.Boolean));
+
+    [Theory]
+    [InlineData("*1\r\n:1\r\n", true)] // SCRIPT EXISTS returns array
+    [InlineData("*1\r\n:0\r\n", false)]
+    [InlineData(ATTRIB_FOO_BAR + "*1\r\n:1\r\n", true)]
+    public void BooleanArrayOfOne(string resp, bool value) => Assert.Equal(value, Execute(resp, ResultProcessor.Boolean));
+
+    [Theory]
+    [InlineData("*0\r\n")] // empty array
+    [InlineData("*2\r\n:1\r\n:0\r\n")] // two elements
+    [InlineData("*1\r\n*1\r\n:1\r\n")] // nested array (not scalar)
+    public void FailingBooleanArrayOfNonOne(string resp) => ExecuteUnexpected(resp, ResultProcessor.Boolean);
+
+    [Theory]
+    [InlineData("$5\r\nhello\r\n", "hello")]
+    [InlineData("+world\r\n", "world")]
+    [InlineData(":42\r\n", "42")]
+    [InlineData("$-1\r\n", null)]
+    [InlineData(ATTRIB_FOO_BAR + "$3\r\nfoo\r\n", "foo")]
+    public void String(string resp, string? value) => Assert.Equal(value, Execute(resp, ResultProcessor.String));
+
+    [Theory]
+    [InlineData("*1\r\n$3\r\nbar\r\n", "bar")]
+    [InlineData(ATTRIB_FOO_BAR + "*1\r\n$3\r\nbar\r\n", "bar")]
+    public void StringArrayOfOne(string resp, string? value) => Assert.Equal(value, Execute(resp, ResultProcessor.String));
+
+    [Theory]
+    [InlineData("*-1\r\n")] // null array
+    [InlineData("*0\r\n")] // empty array
+    [InlineData("*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n")] // two elements
+    [InlineData("*1\r\n*1\r\n$3\r\nfoo\r\n")] // nested array (not scalar)
+    public void FailingStringArrayOfNonOne(string resp) => ExecuteUnexpected(resp, ResultProcessor.String);
+
     [return: NotNullIfNotNull(nameof(array))]
     protected static string? Join<T>(T[]? array, string separator = ",")
     {