csharp/2881099/FreeRedis/test/Unit/FreeRedis.Tests/RedisClientTests/KeysTests.cs

KeysTests.cs
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Xunit;

namespace FreeRedis.Tests.RedisClientTests
{
    public clast KeysTests : TestBase
    {
        [Fact]
        public void Del()
        {
            var keys = Enumerable.Range(0, 10).Select(a => Guid.NewGuid().ToString()).ToArray();
            cli.MSet(keys.ToDictionary(a => a, a => (object)a));
            astert.Equal(10, cli.Del(keys));
        }

        [Fact]
        public void Dump()
        {
            cli.Del("TestDump_null2", "TestDump_string2", "TestDump_bytes2", "TestDump_clast2");
            cli.MSet("TestDump_null1", base.Null, "TestDump_string1", base.String, "TestDump_bytes1", base.Bytes, "TestDump_clast1", base.Clast);

            cli.Restore("TestDump_null2", cli.Dump("TestDump_null1"));
            astert.Equal(cli.Get("TestDump_null2"), cli.Get("TestDump_null1"));

            cli.Restore("TestDump_string2", cli.Dump("TestDump_string1"));
            astert.Equal(cli.Get("TestDump_string2"), cli.Get("TestDump_string1"));

            cli.Restore("TestDump_bytes2", cli.Dump("TestDump_bytes1"));
            astert.Equal(cli.Get("TestDump_bytes2"), cli.Get("TestDump_bytes1"));

            cli.Restore("TestDump_clast2", cli.Dump("TestDump_clast1"));
            astert.Equal(cli.Get("TestDump_clast2").ToString(), cli.Get("TestDump_clast1").ToString());
        }

        [Fact]
        public void Exists()
        {
            cli.Del("TestExists_null1");
            astert.False(cli.Exists("TestExists_null1"));
            cli.Set("TestExists_null1", 1);
            astert.True(cli.Exists("TestExists_null1"));
            astert.Equal(1, cli.Del("TestExists_null1"));
            astert.False(cli.Exists("TestExists_null1"));
        }

        [Fact]
        public void Expire()
        {
            cli.MSet("TestExpire_null1", base.Null, "TestExpire_string1", base.String, "TestExpire_bytes1", base.Bytes, "TestExpire_clast1", base.Clast);

            astert.True(cli.Expire("TestExpire_null1", 10));
            astert.Equal(10, cli.Ttl("TestExpire_null1"));
            astert.True(cli.Expire("TestExpire_string1", 60 * 60));
            astert.Equal(60 * 60, cli.Ttl("TestExpire_string1"));
        }

        [Fact]
        public void ExpireAt()
        {
            cli.MSet("TestExpireAt_null1", base.Null, "TestExpireAt_string1", base.String, "TestExpireAt_bytes1", base.Bytes, "TestExpireAt_clast1", base.Clast);

            astert.True(cli.ExpireAt("TestExpireAt_null1", DateTime.UtcNow.AddSeconds(10)));
            astert.InRange(cli.Ttl("TestExpireAt_null1"), 9, 20);
            astert.True(cli.ExpireAt("TestExpireAt_string1", DateTime.UtcNow.AddHours(1)));
            astert.InRange(cli.Ttl("TestExpireAt_string1"), 60 * 60 - 10, 60 * 60 + 10);
        }

        [Fact]
        public void Keys()
        {
            cli.MSet("TestKeys_null1", base.Null, "TestKeys_string1", base.String, "TestKeys_bytes1", base.Bytes, "TestKeys_clast1", base.Clast);
            astert.Equal(4, cli.Keys("TestKeys_*").Length);
        }

        [Fact]
        public void Migrate()
        {

        }

        [Fact]
        public void Move()
        {
           
            cli.MSet("TestMove_null1", base.Null, "TestMove_string1", base.String, "TestMove_bytes1", base.Bytes, "TestMove_clast1", base.Clast);

            using (var sh = cli.GetDatabase(11))
            {
                sh.Del("TestMove_string1");
            }

            astert.True(cli.Move("TestMove_string1", 11));
            astert.False(cli.Exists("TestMove_string1"));

            using (var sh = cli.GetDatabase(11))
            {
                astert.Equal(base.String, sh.Get("TestMove_string1"));
            }

            cli.Set("TestMove_string1", base.String);
            astert.False(cli.Move("TestMove_string1", 11)); //target exists
            astert.Equal(base.String, cli.Get("TestMove_string1"));

            using (var sh = cli.GetDatabase(11))
            {
                astert.Equal(base.String, sh.Get("TestMove_string1"));
                sh.Del("TestMove_string1");
            }
        }

        [Fact]
        public void ObjectRefCount()
        {
            cli.MSet("TestObjectRefCount_null1", base.Null, "TestObjectRefCount_string1", base.String, "TestObjectRefCount_bytes1", base.Bytes, "TestObjectRefCount_clast1", base.Clast);
            astert.True(cli.Exists("TestObjectRefCount_string1"));
            cli.Get("TestObjectRefCount_string1");

            astert.Null(cli.ObjectRefCount("TestObjectRefCount_bytes11"));
            astert.Equal(1, cli.ObjectRefCount("TestObjectRefCount_string1"));
        }

        [Fact]
        public void ObjectIdleTime()
        {
            var key1 = "ObjectIdleTime1";
            cli.LPush(key1, "hello world");

            astert.Equal(0, cli.ObjectIdleTime(key1));
        }

        [Fact]
        public void ObjectEncoding()
        {
            var key1 = "ObjectEncoding1";
            cli.LPush(key1, "ObjectEncoding1_val1");
            astert.Equal("quicklist", cli.ObjectEncoding(key1));
        }

        [Fact]
        public void ObjectFreq()
        {
            var key1 = "ObjectFreq1";
            cli.Set(key1, "test1");
            cli.Get(key1);

            //astert.True(cli.ObjectFreq(key1) > 0);
            astert.Null(cli.ObjectFreq(key1 + "_no_such_key"));
        }

        [Fact]
        public void Presist()
        {
            cli.MSet("TestPersist_null1", base.Null, "TestPersist_string1", base.String, "TestPersist_bytes1", base.Bytes, "TestPersist_clast1", base.Clast);

            astert.True(cli.Expire("TestPersist_null1", 10));
            astert.Equal(10, cli.Ttl("TestPersist_null1"));
            astert.True(cli.Expire("TestPersist_string1", 60 * 60));
            astert.Equal(60 * 60, cli.Ttl("TestPersist_string1"));

            astert.True(cli.Persist("TestPersist_null1"));
            astert.False(cli.Persist("TestPersist_null11"));
            astert.True(cli.Persist("TestPersist_string1"));
            astert.False(cli.Persist("TestPersist_string11"));

            astert.Equal(-1, cli.Ttl("TestPersist_null1"));
            astert.Equal(-1, cli.Ttl("TestPersist_string1"));
        }

        [Fact]
        public void PExpire()
        {
            cli.MSet("TestPExpire_null1", base.Null, "TestPExpire_string1", base.String, "TestPExpire_bytes1", base.Bytes, "TestPExpire_clast1", base.Clast);

            astert.True(cli.PExpire("TestPExpire_null1", 10000));
            //astert.InRange(cli.PTtl("TestPExpire_null1"), 9000, 10000);
            astert.True(cli.PExpire("TestPExpire_string1", 60 * 60));
            //astert.InRange(cli.PTtl("TestPExpire_string1"), 1000 * 60 * 60 - 1000, 1000 * 60 * 60);
        }

        [Fact]
        public void PExpireAt()
        {
            cli.MSet("TestPExpireAt_null1", base.Null, "TestPExpireAt_string1", base.String, "TestPExpireAt_bytes1", base.Bytes, "TestPExpireAt_clast1", base.Clast);

            astert.True(cli.ExpireAt("TestPExpireAt_null1", DateTime.UtcNow.AddSeconds(10)));
            astert.InRange(cli.PTtl("TestPExpireAt_null1"), 9000, 20000);
            astert.True(cli.ExpireAt("TestPExpireAt_string1", DateTime.UtcNow.AddHours(1)));
            astert.InRange(cli.PTtl("TestPExpireAt_string1"), 1000 * 60 * 60 - 10000, 1000 * 60 * 60 + 10000);
        }

        [Fact]
        public void PTtl()
        {
            cli.MSet("TestPTtl_null1", base.Null, "TestPTtl_string1", base.String, "TestPTtl_bytes1", base.Bytes, "TestPTtl_clast1", base.Clast);

            astert.True(cli.PExpire("TestPTtl_null1", 1000));
            astert.InRange(cli.PTtl("TestPTtl_null1"), 500, 1000);
            astert.InRange(cli.PTtl("TestPTtl_null11"), long.MinValue, -1);
        }

        [Fact]
        public void RandomKey()
        {
            cli.MSet("TestRandomKey_null1", base.Null, "TestRandomKey_string1", base.String, "TestRandomKey_bytes1", base.Bytes, "TestRandomKey_clast1", base.Clast);

            astert.NotNull(cli.RandomKey());
        }

        [Fact]
        public void Rename()
        {
            cli.MSet("TestRename_null1", base.Null, "TestRename_string1", base.String, "TestRename_bytes1", base.Bytes, "TestRename_clast1", base.Clast);

            astert.Equal(base.String, cli.Get("TestRename_string1"));
            cli.Rename("TestRename_string1", "TestRename_string11");
            astert.False(cli.Exists("TestRename_string1"));
            astert.Equal(base.String, cli.Get("TestRename_string11"));

            cli.Rename("TestRename_clast1", "TestRename_string11");
            astert.False(cli.Exists("TestRename_clast1"));
            astert.Equal(base.Clast.ToString(), cli.Get("TestRename_string11").ToString());
        }

        [Fact]
        public void RenameNx()
        {
            cli.Del("TestRenameNx_string11", "TestRename_string11");
            cli.MSet("TestRenameNx_null1", base.Null, "TestRenameNx_string1", base.String, "TestRenameNx_bytes1", base.Bytes, "TestRenameNx_clast1", base.Clast);

            astert.Equal(base.String, cli.Get("TestRenameNx_string1"));
            astert.True(cli.RenameNx("TestRenameNx_string1", "TestRenameNx_string11"));
            astert.False(cli.Exists("TestRenameNx_string1"));
            astert.Equal(base.String, cli.Get("TestRenameNx_string11"));

            astert.True(cli.RenameNx("TestRenameNx_clast1", "TestRename_string11"));
            astert.False(cli.Exists("TestRenameNx_clast1"));
            astert.Equal(base.Clast.ToString(), cli.Get("TestRename_string11").ToString());
        }

        [Fact]
        public void Restore()
        {
            cli.Del("TestRestore_null2", "TestRestore_string2", "TestRestore_bytes2", "TestRestore_clast2");
            cli.MSet("TestRestore_null1", base.Null, "TestRestore_string1", base.String, "TestRestore_bytes1", base.Bytes, "TestRestore_clast1", base.Clast);

            cli.Restore("TestRestore_null2", cli.Dump("TestRestore_null1"));
            astert.Equal(cli.Get("TestRestore_null2"), cli.Get("TestRestore_null1"));

            cli.Restore("TestRestore_string2", cli.Dump("TestRestore_string1"));
            astert.Equal(cli.Get("TestRestore_string2"), cli.Get("TestRestore_string1"));

            cli.Restore("TestRestore_bytes2", cli.Dump("TestRestore_bytes1"));
            astert.Equal(cli.Get("TestRestore_bytes2"), cli.Get("TestRestore_bytes1"));

            cli.Restore("TestRestore_clast2", cli.Dump("TestRestore_clast1"));
            astert.Equal(cli.Get("TestRestore_clast2").ToString(), cli.Get("TestRestore_clast1").ToString());
        }

        [Fact]
        public void Scan()
        {
            for (var a = 0; a < 11; a++)
                cli.Set(Guid.NewGuid().ToString(), a);

            var keys = new List();
            foreach (var rt in cli.Scan("*", 2, null))
            {
                keys.AddRange(rt);
            }
        }

        [Fact]
        public void Sort()
        {
            var key1 = "Sort1";
            cli.LPush(key1, 1, 2, 10);
            cli.Set("bar1", "bar1");
            cli.Set("bar2", "bar2");
            cli.Set("bar10", "bar10");
            cli.Set("car1", "car1");
            cli.Set("car2", "car2");
            cli.Set("car10", "car10");

            var r1 = cli.Sort(key1, getPatterns: new[] { "car*", "bar*" }, collation: Collation.desc, alpha: true);
            var r2 = cli.Sort(key1, getPatterns: new[] { "car*", "bar*" }, offset: 1, count:5, collation: Collation.desc, alpha: true);
        }

        [Fact]
        public void Touch()
        {

        }

        [Fact]
        public void Ttl()
        {
            cli.MSet("TestTtl_null1", base.Null, "TestTtl_string1", base.String, "TestTtl_bytes1", base.Bytes, "TestTtl_clast1", base.Clast);

            astert.True(cli.Expire("TestTtl_null1", 10));
            astert.InRange(cli.Ttl("TestTtl_null1"), 5, 10);
            astert.InRange(cli.Ttl("TestTtl_null11"), long.MinValue, -1);
        }

        [Fact]
        public void Type()
        {
            cli.MSet("TestType_null1", base.Null, "TestType_string1", base.String, "TestType_bytes1", base.Bytes, "TestType_clast1", base.Clast);

            astert.Equal(KeyType.none, cli.Type("TestType_string111111111123"));
            astert.Equal(KeyType.@string, cli.Type("TestType_string1"));
        }

        [Fact]
        public void UnLink()
        {

        }

        [Fact]
        public void Wait()
        {

        }
    }
}