RedisSetStudyTest 完成

RedisStudyTest/RedisSetStudyTest.cs

@@ -41,6 +41,11 @@ namespace RedisStudyTest
         #endregion
 
         #region SetAdd
+        [Fact]
+        public void SetAdd_Exception_Test()
+        {
+            Assert.Throws<RedisServerException>(() => redisSetStudy.SetAdd(defaultRedisKey, new RedisValue[] { }));
+        }
 
         [Fact]
         public void SetAddOneTest()
@@ -321,6 +326,9 @@ namespace RedisStudyTest
 
             var first_in_destonation= redisSetStudy.SetContains(distination_key, "first");
             Assert.True(first_in_destonation);
+
+            redisDatabase.KeyDelete(source_key);
+            redisDatabase.KeyDelete(distination_key);
         }
 
         [Fact]
@@ -339,6 +347,284 @@ namespace RedisStudyTest
 
             var first_in_destonation = redisSetStudy.SetContains(distination_key, "first");
             Assert.True(first_in_destonation);
+
+            redisDatabase.KeyDelete(source_key);
+            redisDatabase.KeyDelete(distination_key);
+        }
+        #endregion
+
+        #region SetCombine
+
+        [Fact]
+        public void SetCombine_NullSet_Test()
+        {
+            RedisKey[] keys = new RedisKey[] 
+            {
+                defaultRedisKey,
+                defaultRedisKey + "2"
+            };
+
+            RedisValue[] redisValues = redisSetStudy.SetCombine(SetOperation.Difference, keys);
+            Assert.Empty(redisValues);
+
+            redisValues = redisSetStudy.SetCombine(SetOperation.Intersect, keys);
+            Assert.Empty(redisValues);
+
+            redisValues = redisSetStudy.SetCombine(SetOperation.Union, keys);
+            Assert.Empty(redisValues);
+
+            foreach (var key in keys)
+            {
+                redisDatabase.KeyDelete(key);
+            }
+        }
+
+        /// <summary>
+        /// 差集运算 测试
+        /// (注意：集合顺序影响结果)
+        /// </summary>
+        [Fact]
+        public void SetCombine_Difference_Test()
+        {
+            //准备数据
+            RedisKey[] keys = new RedisKey[]
+            {
+                defaultRedisKey,
+                defaultRedisKey + "2"
+            };
+            redisSetStudy.SetAdd(keys[0], new RedisValue[] { 1,2,3,4,5,7,8,9});
+            redisSetStudy.SetAdd(keys[1], new RedisValue[] { 2,4,6,8,10 });
+
+            //keys的集合中第一个集合与后续集合的差集
+            RedisValue[] redisValues = redisSetStudy.SetCombine(SetOperation.Difference, keys);
+            Assert.Equal(new RedisValue[] { 1, 3, 5, 7, 9}, redisValues);
+
+            //反转顺序，影响结果
+            keys =  keys.Reverse().ToArray();
+            redisValues = redisSetStudy.SetCombine(SetOperation.Difference, keys);
+            Assert.Equal(new RedisValue[] { 6,10 }, redisValues);
+
+            //清理
+            foreach (var key in keys)
+            {
+                redisDatabase.KeyDelete(key);
+            }
+        }
+
+        /// <summary>
+        /// 交集运算 测试
+        /// </summary>
+        [Fact]
+        public void SetCombine_Intersect_Test()
+        {
+            //准备数据
+            RedisKey[] keys = new RedisKey[]
+            {
+                defaultRedisKey,
+                defaultRedisKey + "2"
+            };
+            redisSetStudy.SetAdd(keys[0], new RedisValue[] { 1, 2, 3, 4, 5, 7, 8, 9 });
+            redisSetStudy.SetAdd(keys[1], new RedisValue[] { 2, 4, 6, 8, 10 });
+
+            //集合的交集
+            RedisValue[] redisValues = redisSetStudy.SetCombine(SetOperation.Intersect, keys);
+            Assert.Equal(new RedisValue[] { 2, 4, 8 }, redisValues);
+
+            //反转顺序，并不影响结果
+            keys = keys.Reverse().ToArray();
+            redisValues = redisSetStudy.SetCombine(SetOperation.Intersect, keys);
+            Assert.Equal(new RedisValue[] { 2, 4, 8 }, redisValues);
+
+            //清理
+            foreach (var key in keys)
+            {
+                redisDatabase.KeyDelete(key);
+            }
+        }
+
+        /// <summary>
+        /// 并集运算 测试
+        /// </summary>
+        [Fact]
+        public void SetCombine_Union_Test()
+        {
+            //准备数据
+            RedisKey[] keys = new RedisKey[]
+            {
+                defaultRedisKey,
+                defaultRedisKey + "2"
+            };
+            redisSetStudy.SetAdd(keys[0], new RedisValue[] { 1, 2, 3, 4, 5, 7, 8, 9 });
+            redisSetStudy.SetAdd(keys[1], new RedisValue[] { 2, 4, 6, 8, 10 });
+
+            //集合的并集
+            RedisValue[] redisValues = redisSetStudy.SetCombine(SetOperation.Union, keys);
+            Assert.Equal(new RedisValue[] { 1,2,3,4,5,6,7,8,9,10 }, redisValues);
+
+            //反转顺序，并不影响结果
+            keys = keys.Reverse().ToArray();
+            redisValues = redisSetStudy.SetCombine(SetOperation.Union, keys);
+            Assert.Equal(new RedisValue[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, redisValues);
+
+            //清理
+            foreach (var key in keys)
+            {
+                redisDatabase.KeyDelete(key);
+            }
+        }
+
+        /// <summary>
+        /// 并集运算 测试
+        /// </summary>
+        [Fact]
+        public void SetCombine_Overload_Test()
+        {
+            //准备数据
+            RedisKey[] keys = new RedisKey[]
+            {
+                defaultRedisKey,
+                defaultRedisKey + "2"
+            };
+            redisSetStudy.SetAdd(keys[0], new RedisValue[] { 1, 2, 3, 4, 5, 7, 8, 9 });
+            redisSetStudy.SetAdd(keys[1], new RedisValue[] { 2, 4, 6, 8, 10 });
+
+            //集合的并集
+            RedisValue[] redisValues = redisSetStudy.SetCombine(SetOperation.Union, keys[0],keys[1]);
+            Assert.Equal(new RedisValue[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, redisValues);
+
+            //清理
+            foreach (var key in keys)
+            {
+                redisDatabase.KeyDelete(key);
+            }
+        }
+        #endregion
+
+        #region SetCombineAndStore
+
+        [Fact]
+        public void SetCombineAndStore_NotKey_Test()
+        {
+            var firstKey = defaultRedisKey;
+            var secondKey = defaultRedisKey + "2";
+            var desinationKey = defaultRedisKey + "desination";
+
+            var result = redisSetStudy.SetCombineAndStore(SetOperation.Difference, defaultRedisKey, firstKey, secondKey);
+            Assert.Equal(0, result);
+
+            var desination_exits = redisDatabase.KeyExists(desinationKey);
+            Assert.False(desination_exits);
+        }
+
+        /// <summary>
+        /// 差集
+        /// </summary>
+        [Fact]
+        public void SetCombineAndStore_Difference_Test()
+        {
+            //准备
+            var firstKey = defaultRedisKey;
+            var secondKey = defaultRedisKey + "2";
+            var desinationKey = defaultRedisKey + "desination";
+            redisSetStudy.SetAdd(firstKey, new RedisValue[] {  2, 4, 5, 7, 8, 9 });
+            redisSetStudy.SetAdd(secondKey, new RedisValue[] { 2, 4, 6, 8, 10 });
+
+            //操作与断言
+            var result = redisSetStudy.SetCombineAndStore(SetOperation.Difference, desinationKey, firstKey, secondKey);
+            Assert.Equal(3, result);
+
+            var desination_members = redisSetStudy.SetMembers(desinationKey);
+            Assert.Equal(new RedisValue[] {5,7,9},desination_members);
+
+            //交换集合顺序，影响结果
+            result = redisSetStudy.SetCombineAndStore(SetOperation.Difference, desinationKey,new RedisKey[]{secondKey,firstKey });
+            Assert.Equal(2, result);
+
+            desination_members = redisSetStudy.SetMembers(desinationKey);
+            Assert.Equal(new RedisValue[] { 6, 10 }, desination_members);
+
+            //清理
+            redisDatabase.KeyDelete(firstKey);
+            redisDatabase.KeyDelete(secondKey);
+            redisDatabase.KeyDelete(desinationKey);
+        }
+
+        /// <summary>
+        /// 交集
+        /// </summary>
+        [Fact]
+        public void SetCombineAndStore_Intersect_Test()
+        {
+            //准备
+            var firstKey = defaultRedisKey;
+            var secondKey = defaultRedisKey + "2";
+            var desinationKey = defaultRedisKey + "desination";
+            redisSetStudy.SetAdd(firstKey, new RedisValue[] { 2, 4, 5, 7, 8, 9 });
+            redisSetStudy.SetAdd(secondKey, new RedisValue[] { 2, 4, 6, 8, 10 });
+
+            //操作与断言
+            var result = redisSetStudy.SetCombineAndStore(SetOperation.Intersect, desinationKey, firstKey, secondKey);
+            Assert.Equal(3, result);
+
+            var desination_members = redisSetStudy.SetMembers(desinationKey);
+            Assert.Equal(new RedisValue[] { 2, 4, 8 }, desination_members);
+
+            //清理
+            redisDatabase.KeyDelete(firstKey);
+            redisDatabase.KeyDelete(secondKey);
+            redisDatabase.KeyDelete(desinationKey);
+        }
+
+        /// <summary>
+        /// 并集
+        /// </summary>
+        [Fact]
+        public void SetCombineAndStore_Union_Test()
+        {
+            //准备
+            var firstKey = defaultRedisKey;
+            var secondKey = defaultRedisKey + "2";
+            var desinationKey = defaultRedisKey + "desination";
+            redisSetStudy.SetAdd(firstKey, new RedisValue[] { 2, 4, 5, 7, 8, 9 });
+            redisSetStudy.SetAdd(secondKey, new RedisValue[] { 2, 4, 6, 8, 10 });
+
+            //操作与断言
+            var result = redisSetStudy.SetCombineAndStore(SetOperation.Union, desinationKey, firstKey, secondKey);
+            Assert.Equal(8, result);
+
+            var desination_members = redisSetStudy.SetMembers(desinationKey);
+            Assert.Equal(new RedisValue[] { 2, 4, 5, 6, 7, 8, 9, 10 }, desination_members);
+
+            //清理
+            redisDatabase.KeyDelete(firstKey);
+            redisDatabase.KeyDelete(secondKey);
+            redisDatabase.KeyDelete(desinationKey);
+        }
+        #endregion
+
+        #region SetScan 简单测试，有专注测试Scan方法的类
+        [Fact]
+        public void SetScanTest()
+        {
+            var values = new RedisValue[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+
+            redisSetStudy.SetAdd(defaultRedisKey,values);
+
+            var members = redisSetStudy.SetScan(defaultRedisKey, "*", 200,CommandFlags.None);
+            var membaerList = members.ToList();
+            Assert.Equal(values, membaerList);
+        }
+
+        [Fact]
+        public void SetScan_OverLoad_Test()
+        {
+            var values = new RedisValue[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+
+            redisSetStudy.SetAdd(defaultRedisKey, values);
+
+            var members = redisSetStudy.SetScan(defaultRedisKey, "*", 100, 0, 0, CommandFlags.None);
+            var membaerList = members.ToList();
+            Assert.Equal(values, membaerList);
         }
         #endregion