Add dedicated enum for MIN/MAX

Add a dedicated enum for the MIN and MAX arguments. It feels cleaner
than using Order and having to mentally map Ascending to Min and
Descending to Max.

Author: Gabriel Erzse

src/NRedisStack/CoreCommands/CoreCommandBuilder.cs

@@ -1,6 +1,7 @@
 using NRedisStack.RedisStackCommands;
 using NRedisStack.Core.Literals;
 using NRedisStack.Core;
+using NRedisStack.Core.DataTypes;
 using StackExchange.Redis;
 
 namespace NRedisStack
@@ -20,7 +21,7 @@ public static SerializedCommand ClientSetInfo(SetInfoAttr attr, string value)
             return new SerializedCommand(RedisCoreCommands.CLIENT, RedisCoreCommands.SETINFO, attrValue, value);
         }
 
-        public static SerializedCommand BzmPop(int timeout, RedisKey[] keys, Order order, long? count)
+        public static SerializedCommand BzmPop(int timeout, RedisKey[] keys, MinMaxModifier minMaxModifier, long? count)
         {
             if (keys.Length == 0)
             {
@@ -31,7 +32,7 @@ public static SerializedCommand BzmPop(int timeout, RedisKey[] keys, Order order
                 timeout,
                 keys.Length,
                 .. keys.Cast<object>(),
-                order == Order.Ascending ? CoreArgs.MIN : CoreArgs.MAX
+                minMaxModifier == MinMaxModifier.Min ? CoreArgs.MIN : CoreArgs.MAX
             ];
 
             if (count != null)

src/NRedisStack/CoreCommands/CoreCommands.cs

@@ -46,16 +46,16 @@ public static bool ClientSetInfo(this IDatabase db, SetInfoAttr attr, string val
         /// <param name="db">The <see cref="IDatabase"/> class where this extension method is applied.</param>
         /// <param name="timeout">Server-side timeout for the wait. A value of <c>0</c> means to wait indefinitely.</param>
         /// <param name="keys">The keys to check.</param>
-        /// <param name="order">The order to sort by when popping items out of the set. If set to <c>Order.ascending</c>
+        /// <param name="minMaxModifier">Specify from which end of the sorted set to pop values. If set to <c>MinMaxModifier.Min</c>
         /// then the minimum elements will be popped, otherwise the maximum values.</param>
         /// <param name="count">The maximum number of records to pop out. If set to <c>null</c> then the server default
         /// will be used.</param>
         /// <returns>A collection of sorted set entries paired with their scores, together with the key they were popped
         /// from, or <c>null</c> if the server timeout expires.</returns>
         /// <remarks><seealso href="https://redis.io/commands/bzmpop"/></remarks>
-        public static Tuple<RedisKey, List<RedisValueWithScore>>? BzmPop(this IDatabase db, int timeout, RedisKey[] keys, Order order, long? count = null)
+        public static Tuple<RedisKey, List<RedisValueWithScore>>? BzmPop(this IDatabase db, int timeout, RedisKey[] keys, MinMaxModifier minMaxModifier, long? count = null)
         {
-            var command = CoreCommandBuilder.BzmPop(timeout, keys, order, count);
+            var command = CoreCommandBuilder.BzmPop(timeout, keys, minMaxModifier, count);
             return db.Execute(command).ToSortedSetPopResult();
         }
 
@@ -66,16 +66,16 @@ public static bool ClientSetInfo(this IDatabase db, SetInfoAttr attr, string val
         /// <param name="db">The <see cref="IDatabase"/> class where this extension method is applied.</param>
         /// <param name="timeout">Server-side timeout for the wait. A value of <c>0</c> means to wait indefinitely.</param>
         /// <param name="key">The key to check.</param>
-        /// <param name="order">The order to sort by when popping items out of the set. If set to <c>Order.ascending</c>
+        /// <param name="minMaxModifier">Specify from which end of the sorted set to pop values. If set to <c>MinMaxModifier.Min</c>
         /// then the minimum elements will be popped, otherwise the maximum values.</param>
         /// <param name="count">The maximum number of records to pop out. If set to <c>null</c> then the server default
         /// will be used.</param>
         /// <returns>A collection of sorted set entries paired with their scores, together with the key they were popped
         /// from, or <c>null</c> if the server timeout expires.</returns>
         /// <remarks><seealso href="https://redis.io/commands/bzmpop"/></remarks>
-        public static Tuple<RedisKey, List<RedisValueWithScore>>? BzmPop(this IDatabase db, int timeout, RedisKey key, Order order, long? count = null)
+        public static Tuple<RedisKey, List<RedisValueWithScore>>? BzmPop(this IDatabase db, int timeout, RedisKey key, MinMaxModifier minMaxModifier, long? count = null)
         {
-            return BzmPop(db, timeout, [key], order, count);
+            return BzmPop(db, timeout, [key], minMaxModifier, count);
         }
     }
 }

src/NRedisStack/CoreCommands/DataTypes/MinMaxModifier.cs

@@ -0,0 +1,35 @@
+using StackExchange.Redis;
+
+namespace NRedisStack.Core.DataTypes;
+
+/// <summary>
+/// Modifier that can be used for sorted set commands, where a MIN/MAX argument is expected by the Redis server.
+/// </summary>
+public enum MinMaxModifier
+{
+    /// <summary>
+    /// Maps to the <c>MIN</c> argument on the Redis server.
+    /// </summary>
+    Min,
+
+    /// <summary>
+    /// Maps to the <c>MAX</c> argument on the Redis server.
+    /// </summary>
+    Max
+}
+
+/// <summary>
+/// Conversion methods from/to other common data types.
+/// </summary>
+public static class MinMaxModifierExtensions
+{
+    /// <summary>
+    /// Convert from <see cref="Order"/> to <see cref="MinMaxModifier"/>.
+    /// </summary>
+    public static MinMaxModifier ToMinMax(this Order order) => order switch
+    {
+        Order.Ascending => MinMaxModifier.Min,
+        Order.Descending => MinMaxModifier.Max,
+        _ => throw new ArgumentOutOfRangeException(nameof(order))
+    };
+}

tests/NRedisStack.Tests/Core Commands/CoreTests.cs

@@ -1,10 +1,8 @@
 using Xunit;
 using NRedisStack.Core;
-using NRedisStack;
 using static NRedisStack.Auxiliary;
 using StackExchange.Redis;
-using System.Xml.Linq;
-using System.Reflection;
+using NRedisStack.Core.DataTypes;
 using NRedisStack.RedisStackCommands;
 
 
@@ -164,7 +162,7 @@ public void TestBzmPop()
         db.SortedSetAdd(sortedSetKey, "e", 7.76);
 
         // Pop two items with default order, which means it will pop the minimum values.
-        var resultWithDefaultOrder = db.BzmPop(0, [sortedSetKey], Order.Ascending, 2);
+        var resultWithDefaultOrder = db.BzmPop(0, [sortedSetKey], MinMaxModifier.Min, 2);
 
         Assert.NotNull(resultWithDefaultOrder);
         Assert.Equal(sortedSetKey, resultWithDefaultOrder!.Item1);
@@ -173,7 +171,7 @@ public void TestBzmPop()
         Assert.Equal("c", resultWithDefaultOrder.Item2[1].Value.ToString());
 
         // Pop one more item, with descending order, which means it will pop the maximum value.
-        var resultWithDescendingOrder = db.BzmPop(0, [sortedSetKey], Order.Descending, 1);
+        var resultWithDescendingOrder = db.BzmPop(0, [sortedSetKey], MinMaxModifier.Max, 1);
 
         Assert.NotNull(resultWithDescendingOrder);
         Assert.Equal(sortedSetKey, resultWithDescendingOrder!.Item1);
@@ -190,7 +188,7 @@ public void TestBzmPopNull()
         db.Execute("FLUSHALL");
 
         // Nothing in the set, and a short server timeout, which yields null.
-        var result = db.BzmPop(1, ["my-set"], Order.Ascending, null);
+        var result = db.BzmPop(1, ["my-set"], MinMaxModifier.Min, null);
 
         Assert.Null(result);
     }
@@ -207,7 +205,7 @@ public void TestBzmPopMultiplexerTimeout()
         db.Execute("FLUSHALL");
 
         // Server would wait forever, but the multiplexer times out in 1 second.
-        Assert.Throws<RedisTimeoutException>(() => db.BzmPop(0, ["my-set"], Order.Ascending));
+        Assert.Throws<RedisTimeoutException>(() => db.BzmPop(0, ["my-set"], MinMaxModifier.Min));
     }
 
     [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "7.0.0")]
@@ -224,28 +222,28 @@ public void TestBzmPopMultipleSets()
         db.SortedSetAdd("set-two", "d", 9.4);
         db.SortedSetAdd("set-two", "e", 7.76);
 
-        var result = db.BzmPop(0, "set-two", Order.Descending);
+        var result = db.BzmPop(0, "set-two", MinMaxModifier.Max);
 
         Assert.NotNull(result);
         Assert.Equal("set-two", result!.Item1);
         Assert.Single(result.Item2);
         Assert.Equal("d", result.Item2[0].Value.ToString());
 
-        result = db.BzmPop(0, ["set-two", "set-one"], Order.Ascending);
+        result = db.BzmPop(0, ["set-two", "set-one"], MinMaxModifier.Min);
 
         Assert.NotNull(result);
         Assert.Equal("set-two", result!.Item1);
         Assert.Single(result.Item2);
         Assert.Equal("e", result.Item2[0].Value.ToString());
 
-        result = db.BzmPop(0, ["set-two", "set-one"], Order.Descending);
+        result = db.BzmPop(0, ["set-two", "set-one"], MinMaxModifier.Max);
 
         Assert.NotNull(result);
         Assert.Equal("set-one", result!.Item1);
         Assert.Single(result.Item2);
         Assert.Equal("b", result.Item2[0].Value.ToString());
 
-        result = db.BzmPop(0, "set-one", Order.Ascending, count: 2);
+        result = db.BzmPop(0, "set-one", MinMaxModifier.Min, count: 2);
 
         Assert.NotNull(result);
         Assert.Equal("set-one", result!.Item1);
@@ -263,6 +261,37 @@ public void TestBzmPopNoKeysProvided()
         db.Execute("FLUSHALL");
 
         // Server would wait forever, but the multiplexer times out in 1 second.
-        Assert.Throws<ArgumentException>(() => db.BzmPop(0, [], Order.Ascending));
+        Assert.Throws<ArgumentException>(() => db.BzmPop(0, [], MinMaxModifier.Min));
+    }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "7.0.0")]
+    public void TestBzmPopWithOrderEnum()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        var sortedSetKey = "my-set";
+
+        db.SortedSetAdd(sortedSetKey, "a", 1.5);
+        db.SortedSetAdd(sortedSetKey, "b", 5.1);
+        db.SortedSetAdd(sortedSetKey, "c", 3.7);
+
+        // Pop two items with default order, which means it will pop the minimum values.
+        var resultWithDefaultOrder = db.BzmPop(0, [sortedSetKey], Order.Ascending.ToMinMax());
+
+        Assert.NotNull(resultWithDefaultOrder);
+        Assert.Equal(sortedSetKey, resultWithDefaultOrder!.Item1);
+        Assert.Single(resultWithDefaultOrder.Item2);
+        Assert.Equal("a", resultWithDefaultOrder.Item2[0].Value.ToString());
+
+        // Pop one more item, with descending order, which means it will pop the maximum value.
+        var resultWithDescendingOrder = db.BzmPop(0, [sortedSetKey], Order.Descending.ToMinMax());
+
+        Assert.NotNull(resultWithDescendingOrder);
+        Assert.Equal(sortedSetKey, resultWithDescendingOrder!.Item1);
+        Assert.Single(resultWithDescendingOrder.Item2);
+        Assert.Equal("b", resultWithDescendingOrder.Item2[0].Value.ToString());
     }
 }