RedisStudy/RedisStudyTest/RedisSetStudyTest.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using StackExchange.Redis;

using Xunit;
using Xunit.Extensions;
using Xunit.Serialization;
using Xunit.Abstractions;
using Xunit.Sdk;

using RedisStuy;

namespace RedisStudyTest
{
    /// <summary>
    /// Redis 集合学习 测试
    /// </summary>
    [Trait("RedisSet", "All")]
    public class RedisSetStudyTest:IDisposable
    {
        #region 初始化
        private readonly ITestOutputHelper testOutput;
        private IDatabase redisDatabase = null;
        private RedisSetStudy redisSetStudy = null;
        private TimeSpan defaultExpiry = TimeSpan.FromSeconds(20);
        private string defaultRedisKey = "RedisStudy:Set:xUnitTest";

        /// <summary>
        /// 构造
        /// </summary>
        public RedisSetStudyTest(ITestOutputHelper output)
        {
            this.testOutput = output;
            redisDatabase = RedisHelper.GetRedisDatabase();
            redisSetStudy = new RedisSetStudy();
        }
        #endregion

        #region SetAdd

        [Fact]
        public void SetAddOneTest()
        {
            var addResult = redisSetStudy.SetAdd(defaultRedisKey, "first");
            Assert.True(addResult);

            addResult = redisSetStudy.SetAdd(defaultRedisKey, "second");
            Assert.True(addResult);

            var setMembers = redisSetStudy.SetMembers(defaultRedisKey);

            Assert.NotEmpty(setMembers);
            Assert.Equal(2, setMembers.Length);
            Assert.Contains("first", setMembers);
            Assert.Contains("second", setMembers);
        }

        [Fact]
        public void SetAddGroupTest()
        {
            RedisValue[] values = new RedisValue[]
            {
                "first",
                "second",
                "third",
                "four",
            };

            var setAddNumber = redisSetStudy.SetAdd(defaultRedisKey, values);
            Assert.Equal(4, setAddNumber);

            //忽略已存在的项
            setAddNumber = redisSetStudy.SetAdd(defaultRedisKey, values);
            Assert.Equal(0, setAddNumber);

            var setMember = redisSetStudy.SetMembers(defaultRedisKey);
            Assert.Equal(4, setMember.Length);

            Assert.Contains(values[0], setMember);
            Assert.Contains(values[1], setMember);
            Assert.Contains(values[2], setMember);
            Assert.Contains(values[3], setMember);
        }
        #endregion

        #region SetContains

        [Fact]
        public void SetContainsNotKeyTest()
        {
            var extis = redisSetStudy.SetContains(defaultRedisKey, "first");
            Assert.False(extis);
        }

        [Fact]
        public void SetContainsTest()
        {
            RedisValue[] values = new RedisValue[] 
            {
                "first",
                "second",
                "third",
                "four",
            };
            redisSetStudy.SetAdd(defaultRedisKey, values);

            var memberExist = redisSetStudy.SetContains(defaultRedisKey, "first");
            Assert.True(memberExist);

            memberExist = redisSetStudy.SetContains(defaultRedisKey, "FIRST");
            Assert.False(memberExist);

            memberExist = redisSetStudy.SetContains(defaultRedisKey, "365Day");
            Assert.False(memberExist);
        }
        #endregion

        #region SetLength

        [Fact]
        public void SetLengthNotKeyTest()
        {
            var setNumber = redisSetStudy.SetLength(defaultRedisKey);
            Assert.Equal(0, setNumber);
        }

        [Fact]
        public void SetLengthTest()
        {
            RedisValue[] values = new RedisValue[] 
            {
                "first",
                "second",
                "third",
                "four",
            };
            redisSetStudy.SetAdd(defaultRedisKey, values);

            var setNumber = redisSetStudy.SetLength(defaultRedisKey);
            Assert.Equal(4, setNumber);

            redisSetStudy.SetAdd(defaultRedisKey, "five");
            setNumber = redisSetStudy.SetLength(defaultRedisKey);
            Assert.Equal(5, setNumber);
        }
        #endregion

        #region SetMembers

        [Fact]
        public void SetMembersNotKeyTest()
        {
            var members = redisSetStudy.SetMembers(defaultRedisKey);
            Assert.Empty(members);
        }

        [Fact]
        public void SetMembersTest()
        {
            RedisValue[] values = new RedisValue[] 
            {
                "first",
                "second",
                "third",
                "four"
            };
            redisSetStudy.SetAdd(defaultRedisKey, values);

            var members = redisSetStudy.SetMembers(defaultRedisKey);
            Assert.Equal(4, members.Length);

            Assert.Contains(values[0], members);
            Assert.Contains(values[1], members);
            Assert.Contains(values[2], members);
            Assert.Contains(values[3], members);
        }
        #endregion

        #region SetRandomMember

        [Fact]
        public void SetRandomMemberTest()
        {
            var member = redisSetStudy.SetRandomMember(defaultRedisKey);
            Assert.False(member.HasValue);

            RedisValue[] values = new RedisValue[] 
            {
                "first","second","third","four",
            };
            redisSetStudy.SetAdd(defaultRedisKey, values);

            member = redisSetStudy.SetRandomMember(defaultRedisKey);
            Assert.True(member.HasValue);
        }
        #endregion

        #region SetRandomMembers
        [Fact]
        public void SetRandomMembersTest()
        {
            var members = redisSetStudy.SetRandomMembers(defaultRedisKey, 200);
            Assert.Empty(members);

            RedisValue[] values = new RedisValue[]
            {"first","second","third","four" };
            redisSetStudy.SetAdd(defaultRedisKey, values);

            members = redisSetStudy.SetRandomMembers(defaultRedisKey, 1);
            Assert.Equal(1, members.Length);

            members = redisSetStudy.SetRandomMembers(defaultRedisKey, 2);
            Assert.Equal(2, members.Length);

            members = redisSetStudy.SetRandomMembers(defaultRedisKey, 3);
            Assert.Equal(3, members.Length);

            members = redisSetStudy.SetRandomMembers(defaultRedisKey, 4);
            Assert.Equal(4, members.Length);

            members = redisSetStudy.SetRandomMembers(defaultRedisKey, 200);
            Assert.Equal(4, members.Length);
        }
        #endregion

        #region SetPop
        [Fact]
        public void SetPopNotKeyTest()
        {
            var member = redisSetStudy.SetPop(defaultRedisKey);
            Assert.False(member.HasValue);
        }

        [Fact]
        public void SetPopTest()
        {
            RedisValue[] values = new RedisValue[] 
            {
                "first","second","third","four"
            };
            redisSetStudy.SetAdd(defaultRedisKey, values);

            var member = redisSetStudy.SetPop(defaultRedisKey);
            Assert.True(member.HasValue);

            member = redisSetStudy.SetPop(defaultRedisKey);
            Assert.True(member.HasValue);

            member = redisSetStudy.SetPop(defaultRedisKey);
            Assert.True(member.HasValue);

            member = redisSetStudy.SetPop(defaultRedisKey);
            Assert.True(member.HasValue);

            member = redisSetStudy.SetPop(defaultRedisKey);
            Assert.False(member.HasValue);
        }
        #endregion

        #region SetRemove

        [Fact]
        public void SetRemoveNotKeyTest()
        {
            var result = redisSetStudy.SetRemove(defaultRedisKey, "first");
            Assert.False(result);

            var removeNumber = redisSetStudy.SetRemove(defaultRedisKey, new RedisValue[] { "first","second"});
            Assert.Equal(0, removeNumber);
        }

        [Fact]
        public void SetRemoveTest()
        {
            RedisValue[] values = new RedisValue[] 
            {
                "first","second","third","four","five"
            };
            redisSetStudy.SetAdd(defaultRedisKey, values);

            var removeOne = redisSetStudy.SetRemove(defaultRedisKey, "first");
            Assert.True(removeOne);

            var removNumber = redisSetStudy.SetRemove(defaultRedisKey, new RedisValue[] { "second", "third" });
            Assert.Equal(2, removNumber);

            removNumber = redisSetStudy.SetRemove(defaultRedisKey, new RedisValue[] { "third", "four" });
            Assert.Equal(1, removNumber);

            Assert.Equal(1, redisSetStudy.SetLength(defaultRedisKey));
        }
        #endregion

        #region SetMove

        [Fact]
        public void SetMoveNotSourceTest()
        {
            var result = redisSetStudy.SetMove(defaultRedisKey, defaultRedisKey + "2", "first");

            Assert.False(result);
        }

        [Fact]
        public void SetMoveNotDestinationTest()
        {
            var source_key = defaultRedisKey;
            var distination_key = defaultRedisKey + "2";

            redisSetStudy.SetAdd(source_key, "first");

            var result = redisSetStudy.SetMove(source_key, distination_key, "first");
            Assert.True(result);

            var first_in_source = redisSetStudy.SetContains(source_key, "first");
            Assert.False(first_in_source);

            var first_in_destonation= redisSetStudy.SetContains(distination_key, "first");
            Assert.True(first_in_destonation);
        }

        [Fact]
        public void SetMoveTest()
        {
            var source_key = defaultRedisKey;
            var distination_key = defaultRedisKey + "2";
            redisSetStudy.SetAdd(source_key, new RedisValue[] { "first","second","third"});
            redisSetStudy.SetAdd(distination_key, "distination");

            var result = redisSetStudy.SetMove(source_key, distination_key, "first");
            Assert.True(result);

            var first_in_source = redisSetStudy.SetContains(source_key, "first");
            Assert.False(first_in_source);

            var first_in_destonation = redisSetStudy.SetContains(distination_key, "first");
            Assert.True(first_in_destonation);
        }
        #endregion

        #region 清理
        public void Dispose()
        {
            redisDatabase.KeyDelete(defaultRedisKey);
        }
        #endregion
    }
}