Merge branch 'setpop' of https://github.com/dmytrohridin/StackExchang…

…e.Redis.Extensions into dmytrohridin-setpop

Directory.Build.props

@@ -4,7 +4,7 @@
   <!-- General information -->
   <PropertyGroup>
     <Authors>Ugo Lattanzi</Authors>
-    <VersionPrefix>6.0.8</VersionPrefix>
+    <VersionPrefix>6.0.9</VersionPrefix>
     <VersionSuffix>pre</VersionSuffix>
     <TargetFrameworks>netstandard2.0;net461;net472;netcoreapp3.0;netcoreapp3.1</TargetFrameworks>
     <!-- <TargetFrameworks>netcoreapp3.1</TargetFrameworks> -->

src/core/StackExchange.Redis.Extensions.Core/Abstractions/IRedisDatabase.cs

@@ -227,6 +227,25 @@ public partial interface IRedisDatabase
         Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None)
             where T : class;
 
+        /// <summary>
+        ///     Run SPOP command https://redis.io/commands/spop
+        /// </summary>
+        /// <typeparam name="T">The type of the expected object.</typeparam>
+        /// <param name="key">The key of the set</param>
+        /// <param name="flag">Behaviour markers associated with a given command</param>
+        Task<T> SetPopAsync<T>(string key, CommandFlags flag = CommandFlags.None)
+            where T : class;
+
+        /// <summary>
+        ///     Run SPOP command https://redis.io/commands/spop
+        /// </summary>
+        /// <typeparam name="T">The type of the expected object.</typeparam>
+        /// <param name="key">The key of the set</param>
+        /// <param name="count">The number of elements to return</param>
+        /// <param name="flag">Behaviour markers associated with a given command</param>
+        Task<IEnumerable<T>> SetPopAsync<T>(string key, long count, CommandFlags flag = CommandFlags.None)
+            where T : class;
+
         /// <summary>
         ///     Returns if member is a member of the set stored at key.
         /// </summary>

src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.cs

@@ -256,6 +256,33 @@ public Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = Command
             return Database.SetAddAsync(key, serializedObject, flag);
         }
 
+        /// <inheritdoc/>
+        public async Task<T> SetPopAsync<T>(string key, CommandFlags flag = CommandFlags.None)
+            where T : class
+        {
+            if (string.IsNullOrEmpty(key))
+                throw new ArgumentException("key cannot be empty.", nameof(key));
+
+            var item = await Database.SetPopAsync(key, flag);
+
+            if (item == RedisValue.Null)
+                return default;
+
+            return Serializer.Deserialize<T>(item);
+        }
+
+        /// <inheritdoc/>
+        public async Task<IEnumerable<T>> SetPopAsync<T>(string key, long count, CommandFlags flag = CommandFlags.None)
+            where T : class
+        {
+            if (string.IsNullOrEmpty(key))
+                throw new ArgumentException("key cannot be empty.", nameof(key));
+
+            var items = await Database.SetPopAsync(key, count, flag);
+
+            return items.Select(item => item == RedisValue.Null ? default : Serializer.Deserialize<T>(item));
+        }
+
         /// <inheritdoc/>
         public Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None)
             where T : class

tests/StackExchange.Redis.Extensions.Core.Tests/CacheClientTestBase.cs

@@ -301,6 +301,79 @@ public async Task SetAdd_With_An_Existing_Key_Should_Return_Valid_Data()
             Assert.Equal(keys.Length, values.Length);
         }
 
+        [Fact]
+        public async Task SetPop_With_An_Existing_Key_Should_Return_Valid_Data()
+        {
+            var values = Range(0, 5)
+                .Select(_ => new TestClass<string>(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()))
+                .ToArray();
+
+            foreach (var value in values)
+            {
+                await db.SetAddAsync("MySet", serializer.Serialize(value.Value));
+            }
+
+            var result = await Sut.GetDbFromConfiguration().SetPopAsync<string>("MySet");
+            Assert.NotNull(result);
+            Assert.Contains(values, v => v.Value == result);
+
+            var members = await db.SetMembersAsync("MySet");
+            var itemsLeft = members.Select(m => serializer.Deserialize<string>(m)).ToArray();
+            Assert.True(itemsLeft.Length == 4);
+            Assert.DoesNotContain(itemsLeft, l => l == result);
+        }
+
+        [Fact]
+        public async Task SetPop_With_A_Non_Existing_Key_Should_Return_Null()
+        {
+            var result = await Sut.GetDbFromConfiguration().SetPopAsync<string>("MySet");
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public async Task SetPop_With_An_Empty_Key_Should_Throw_Exception()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() => Sut.GetDbFromConfiguration().SetPopAsync<string>(string.Empty));
+        }
+
+        [Fact]
+        public async Task SetPop_Count_With_An_Existing_Key_Should_Return_Valid_Data()
+        {
+            var values = Range(0, 5)
+                .Select(_ => new TestClass<string>(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()))
+                .ToArray();
+
+            foreach (var value in values)
+            {
+                await db.SetAddAsync("MySet", serializer.Serialize(value.Value));
+            }
+
+            var result = await Sut.GetDbFromConfiguration().SetPopAsync<string>("MySet", 3);
+            Assert.NotNull(result);
+            Assert.Equal(3, result.Count());
+            foreach (var r in result)
+                Assert.Contains(values, v => v.Value == r);
+
+            var members = await db.SetMembersAsync("MySet");
+            var itemsLeft = members.Select(m => serializer.Deserialize<string>(m)).ToArray();
+            Assert.True(itemsLeft.Length == 2);
+            foreach (var r in result)
+                Assert.DoesNotContain(itemsLeft, l => l == r);
+        }
+
+        [Fact]
+        public async Task SetPop_Count_With_A_Non_Existing_Key_Should_Return_Null()
+        {
+            var result = await Sut.GetDbFromConfiguration().SetPopAsync<string>("MySet", 0);
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public async Task SetPop_Count_With_An_Empty_Key_Should_Throw_Exception()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() => Sut.GetDbFromConfiguration().SetPopAsync<string>(string.Empty, 0));
+        }
+
         [Fact]
         public async Task SetMembers_With_Valid_Data_Should_Return_Correct_Keys()
         {