首先项目NuGet程序包安装ServiceStack.Redis
仅供自己参考。
string
public class RedisClientTestsBase { protected string CleanMask = null; protected RedisClient Redis; protected void Log(string fmt, params object[] args) { Debug.WriteLine("{0}", string.Format(fmt, args).Trim()); } [OneTimeSetUp] public virtual void OnBeforeTestFixture() { RedisClient.NewFactoryFn = () => new RedisClient(TestConfig.SingleHost); using (var redis = RedisClient.New()) { redis.FlushAll(); } } [OneTimeTearDown] public virtual void OnAfterTestFixture() { } [SetUp] public virtual void OnBeforeEachTest() { Redis = RedisClient.New(); } [TearDown] public virtual void OnAfterEachTest() { try { if (Redis.NamespacePrefix != null && CleanMask == null) CleanMask = Redis.NamespacePrefix + "*"; if (CleanMask != null) Redis.SearchKeys(CleanMask).ForEach(t => Redis.Del(t)); Redis.Dispose(); } catch (RedisResponseException e) { // if exception has that message then it still proves that BgSave works as expected. if (e.Message.StartsWith("Can‘t BGSAVE while AOF log rewriting is in progress")) return; throw; } } protected string PrefixedKey(string key) { return string.Concat(Redis.NamespacePrefix, key); } public RedisClient GetRedisClient() { var client = new RedisClient(TestConfig.SingleHost); return client; } public RedisClient CreateRedisClient() { var client = new RedisClient(TestConfig.SingleHost); return client; } public string GetString(byte[] stringBytes) { return Encoding.UTF8.GetString(stringBytes); } public byte[] GetBytes(string stringValue) { return Encoding.UTF8.GetBytes(stringValue); } }
public class RedisClientTests : RedisClientTestsBase { const string Value = "Value"; public override void OnBeforeEachTest() { base.OnBeforeEachTest(); Redis.NamespacePrefix = "RedisClientTests"; } [Test] public void Can_Set_and_Get_string() { Redis.SetValue("key", Value); var valueBytes = Redis.Get("key"); var valueString = GetString(valueBytes); Redis.Remove("key"); Assert.That(valueString, Is.EqualTo(Value)); } [Test] public void Can_Set_and_Get_key_with_space() { Redis.SetValue("key with space", Value); var valueBytes = Redis.Get("key with space"); var valueString = GetString(valueBytes); Redis.Remove("key with space"); Assert.That(valueString, Is.EqualTo(Value)); } [Test] public void Can_Set_and_Get_key_with_spaces() { const string key = "key with spaces"; Redis.SetValue(key, Value); var valueBytes = Redis.Get(key); var valueString = GetString(valueBytes); Assert.That(valueString, Is.EqualTo(Value)); } [Test] public void Can_Set_and_Get_key_with_all_byte_values() { const string key = "bytesKey"; var value = new byte[256]; for (var i = 0; i < value.Length; i++) { value[i] = (byte)i; } Redis.Set(key, value); var resultValue = Redis.Get(key); Assert.That(resultValue, Is.EquivalentTo(value)); } [Test] public void GetKeys_returns_matching_collection() { Redis.Set("ss-tests:a1", "One"); Redis.Set("ss-tests:a2", "One"); Redis.Set("ss-tests:b3", "One"); var matchingKeys = Redis.SearchKeys("ss-tests:a*"); Assert.That(matchingKeys.Count, Is.EqualTo(2)); } [Test] public void GetKeys_on_non_existent_keys_returns_empty_collection() { var matchingKeys = Redis.SearchKeys("ss-tests:NOTEXISTS"); Assert.That(matchingKeys.Count, Is.EqualTo(0)); } [Test] public void Can_get_Types() { Redis.SetValue("string", "string"); Redis.AddItemToList("list", "list"); Redis.AddItemToSet("set", "set"); Redis.AddItemToSortedSet("sortedset", "sortedset"); Redis.SetEntryInHash("hash", "key", "val"); Assert.That(Redis.GetEntryType("nokey"), Is.EqualTo(RedisKeyType.None)); Assert.That(Redis.GetEntryType("string"), Is.EqualTo(RedisKeyType.String)); Assert.That(Redis.GetEntryType("list"), Is.EqualTo(RedisKeyType.List)); Assert.That(Redis.GetEntryType("set"), Is.EqualTo(RedisKeyType.Set)); Assert.That(Redis.GetEntryType("sortedset"), Is.EqualTo(RedisKeyType.SortedSet)); Assert.That(Redis.GetEntryType("hash"), Is.EqualTo(RedisKeyType.Hash)); } [Test] public void Can_delete_keys() { Redis.SetValue("key", "val"); Assert.That(Redis.ContainsKey("key"), Is.True); Redis.Del("key"); Assert.That(Redis.ContainsKey("key"), Is.False); var keysMap = new Dictionary<string, string>(); 10.Times(i => keysMap.Add("key" + i, "val" + i)); Redis.SetAll(keysMap); 10.Times(i => Assert.That(Redis.ContainsKey("key" + i), Is.True)); Redis.Del(keysMap.Keys.ToArray()); 10.Times(i => Assert.That(Redis.ContainsKey("key" + i), Is.False)); } [Test] public void Can_get_RandomKey() { Redis.Db = 15; var keysMap = new Dictionary<string, string>(); 10.Times(i => keysMap.Add(Redis.NamespacePrefix + "key" + i, "val" + i)); Redis.SetAll(keysMap); var randKey = Redis.RandomKey(); Assert.That(keysMap.ContainsKey(randKey), Is.True); } [Test] public void Can_RenameKey() { Redis.SetValue("oldkey", "val"); Redis.Rename("oldkey", "newkey"); Assert.That(Redis.ContainsKey("oldkey"), Is.False); Assert.That(Redis.ContainsKey("newkey"), Is.True); } [Test] public void Can_Expire() { Redis.SetValue("key", "val"); Redis.Expire("key", 1); Assert.That(Redis.ContainsKey("key"), Is.True); Thread.Sleep(2000); Assert.That(Redis.ContainsKey("key"), Is.False); } [Test] public void Can_Expire_Ms() { Redis.SetValue("key", "val"); Redis.ExpireEntryIn("key", TimeSpan.FromMilliseconds(100)); Assert.That(Redis.ContainsKey("key"), Is.True); Thread.Sleep(500); Assert.That(Redis.ContainsKey("key"), Is.False); } [Ignore("Changes in system clock can break test")] [Test] public void Can_ExpireAt() { Redis.SetValue("key", "val"); var unixNow = DateTime.Now.ToUnixTime(); var in2Secs = unixNow + 2; Redis.ExpireAt("key", in2Secs); Assert.That(Redis.ContainsKey("key"), Is.True); Thread.Sleep(3000); Assert.That(Redis.ContainsKey("key"), Is.False); } [Test] public void Can_GetTimeToLive() { Redis.SetValue("key", "val"); Redis.Expire("key", 10); var ttl = Redis.GetTimeToLive("key"); Assert.That(ttl.Value.TotalSeconds, Is.GreaterThanOrEqualTo(9)); Thread.Sleep(1700); ttl = Redis.GetTimeToLive("key"); Assert.That(ttl.Value.TotalSeconds, Is.LessThanOrEqualTo(9)); } [Test] public void Can_GetServerTime() { var now = Redis.GetServerTime(); now.Kind.PrintDump(); now.ToString("D").Print(); now.ToString("T").Print(); "UtcNow".Print(); DateTime.UtcNow.ToString("D").Print(); DateTime.UtcNow.ToString("T").Print(); Assert.That(now.Date, Is.EqualTo(DateTime.UtcNow.Date)); } [Test] public void Can_Ping() { Assert.That(Redis.Ping(), Is.True); } [Test] public void Can_Echo() { Assert.That(Redis.Echo("Hello"), Is.EqualTo("Hello")); } [Test] public void Can_SlaveOfNoOne() { Redis.SlaveOfNoOne(); } [Test] public void Can_Save() { try { Redis.Save(); } catch (RedisResponseException e) { // if exception has that message then it still proves that BgSave works as expected. if (e.Message.StartsWith("Can‘t BGSAVE while AOF log rewriting is in progress") || e.Message.StartsWith("An AOF log rewriting in progress: can‘t BGSAVE right now") || e.Message.StartsWith("Background save already in progress")) return; throw; } } [Test] public void Can_BgSave() { try { Redis.BgSave(); } catch (RedisResponseException e) { // if exception has that message then it still proves that BgSave works as expected. if (e.Message.StartsWith("Can‘t BGSAVE while AOF log rewriting is in progress") || e.Message.StartsWith("An AOF log rewriting in progress: can‘t BGSAVE right now") || e.Message.StartsWith("Background save already in progress")) return; throw; } } [Test] public void Can_Quit() { Redis.Quit(); Redis.NamespacePrefix = null; CleanMask = null; } [Test] public void Can_BgRewriteAof() { Redis.BgRewriteAof(); } [Test] [Ignore("Works too well and shutdown the server")] public void Can_Shutdown() { Redis.Shutdown(); } [Test] public void Can_get_Keys_with_pattern() { 5.Times(i => Redis.SetValue("k1:" + i, "val")); 5.Times(i => Redis.SetValue("k2:" + i, "val")); var keys = Redis.Keys("k1:*"); Assert.That(keys.Length, Is.EqualTo(5)); } [Test] public void Can_GetAll() { var keysMap = new Dictionary<string, string>(); 10.Times(i => keysMap.Add("key" + i, "val" + i)); Redis.SetAll(keysMap); var map = Redis.GetAll<string>(keysMap.Keys); var mapKeys = Redis.GetValues(keysMap.Keys.ToList<string>()); foreach (var entry in keysMap) { Assert.That(map.ContainsKey(entry.Key), Is.True); Assert.That(mapKeys.Contains(entry.Value), Is.True); } } [Test] public void Can_GetValues_JSON_strings() { var val = "{\"AuthorId\":0,\"Created\":\"\\/Date(1345961754013)\\/\",\"Name\":\"test\",\"Base64\":\"BQELAAEBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAViA/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP8BWAFYgP8BWAFYAViA/wFYAVgBWID/AVgBWAFYgP8BWAFYAViA/4D/gP+A/4D/AVgBWID/gP8BWID/gP8BWID/gP+A/wFYgP+A/4D/gP8BWID/gP+A/4D/gP+A/wFYAViA/4D/AViA/4D/AVgBWAFYgP8BWAFYAViA/4D/AViA/4D/gP+A/4D/gP8BWAFYgP+A/wFYgP+A/wFYgP+A/4D/gP+A/wFYgP+A/wFYgP+A/4D/gP+A/4D/AVgBWID/gP8BWID/gP8BWAFYAViA/wFYAVgBWID/gP8BWID/gP+A/4D/gP+A/wFYAViA/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP8BWAFYgP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/AVgBWID/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/wFYAViA/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP8BWAFYgP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/AVgBWID/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/wFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\"}"; Redis.SetValue("UserLevel/1", val); var vals = Redis.GetValues(new List<string>(new[] { "UserLevel/1" })); Assert.That(vals.Count, Is.EqualTo(1)); Assert.That(vals[0], Is.EqualTo(val)); } [Test] public void Can_AcquireLock() { var key = PrefixedKey("AcquireLockKey"); var lockKey = PrefixedKey("Can_AcquireLock"); Redis.IncrementValue(key); //1 var asyncResults = 5.TimesAsync(i => IncrementKeyInsideLock(key, lockKey, i, new RedisClient(TestConfig.SingleHost) { NamespacePrefix = Redis.NamespacePrefix })); asyncResults.WaitAll(TimeSpan.FromSeconds(5)); var val = Redis.Get<int>(key); Assert.That(val, Is.EqualTo(1 + 5)); } private void IncrementKeyInsideLock(String key, String lockKey, int clientNo, IRedisClient client) { using (client.AcquireLock(lockKey)) { Debug.WriteLine(String.Format("client {0} acquired lock", clientNo)); var val = client.Get<int>(key); Thread.Sleep(200); client.Set(key, val + 1); Debug.WriteLine(String.Format("client {0} released lock", clientNo)); } } [Test] public void Can_AcquireLock_TimeOut() { var key = PrefixedKey("AcquireLockKeyTimeOut"); var lockKey = PrefixedKey("Can_AcquireLock_TimeOut"); Redis.IncrementValue(key); //1 var acquiredLock = Redis.AcquireLock(lockKey); var waitFor = TimeSpan.FromMilliseconds(1000); var now = DateTime.Now; try { using (var client = new RedisClient(TestConfig.SingleHost)) { using (client.AcquireLock(lockKey, waitFor)) { Redis.IncrementValue(key); //2 } } } catch (TimeoutException) { var val = Redis.Get<int>(key); Assert.That(val, Is.EqualTo(1)); var timeTaken = DateTime.Now - now; Assert.That(timeTaken.TotalMilliseconds > waitFor.TotalMilliseconds, Is.True); Assert.That(timeTaken.TotalMilliseconds < waitFor.TotalMilliseconds + 1000, Is.True); return; } Assert.Fail("should have Timed out"); } [Test] public void Can_Append() { const string expectedString = "Hello, " + "World!"; Redis.SetValue("key", "Hello, "); var currentLength = Redis.AppendToValue("key", "World!"); Assert.That(currentLength, Is.EqualTo(expectedString.Length)); var val = Redis.GetValue("key"); Assert.That(val, Is.EqualTo(expectedString)); } [Test] public void Can_GetRange() { const string helloWorld = "Hello, World!"; Redis.SetValue("key", helloWorld); var fromIndex = "Hello, ".Length; var toIndex = "Hello, World".Length - 1; var expectedString = helloWorld.Substring(fromIndex, toIndex - fromIndex + 1); var world = Redis.GetRange("key", fromIndex, toIndex); Assert.That(world.Length, Is.EqualTo(expectedString.Length)); } [Test] public void Can_create_distributed_lock() { var key = "lockkey"; int lockTimeout = 2; var distributedLock = new DistributedLock(); long lockExpire; Assert.AreEqual(distributedLock.Lock(key, lockTimeout, lockTimeout, out lockExpire, Redis), DistributedLock.LOCK_ACQUIRED); //can‘t re-lock distributedLock = new DistributedLock(); Assert.AreEqual(distributedLock.Lock(key, lockTimeout, lockTimeout, out lockExpire, Redis), DistributedLock.LOCK_NOT_ACQUIRED); // re-acquire lock after timeout Thread.Sleep(lockTimeout * 1000 + 1000); distributedLock = new DistributedLock(); Assert.AreEqual(distributedLock.Lock(key, lockTimeout, lockTimeout, out lockExpire, Redis), DistributedLock.LOCK_RECOVERED); Assert.IsTrue(distributedLock.Unlock(key, lockExpire, Redis)); //can now lock distributedLock = new DistributedLock(); Assert.AreEqual(distributedLock.Lock(key, lockTimeout, lockTimeout, out lockExpire, Redis), DistributedLock.LOCK_ACQUIRED); //cleanup Assert.IsTrue(distributedLock.Unlock(key, lockExpire, Redis)); } public class MyPoco { public int Id { get; set; } public string Name { get; set; } } [Test] public void Can_StoreObject() { object poco = new MyPoco { Id = 1, Name = "Test" }; Redis.StoreObject(poco); Assert.That(Redis.GetValue(Redis.NamespacePrefix + "urn:mypoco:1"), Is.EqualTo("{\"Id\":1,\"Name\":\"Test\"}")); Assert.That(Redis.PopItemFromSet(Redis.NamespacePrefix + "ids:MyPoco"), Is.EqualTo("1")); } [Test] public void Can_store_multiple_keys() { var keys = 5.Times(x => "key" + x); var vals = 5.Times(x => "val" + x); using (var redis = RedisClient.New()) { redis.SetAll(keys, vals); var all = redis.GetValues(keys); Assert.AreEqual(vals, all); } } [Test] public void Can_store_Dictionary() { var keys = 5.Times(x => "key" + x); var vals = 5.Times(x => "val" + x); var map = new Dictionary<string, string>(); keys.ForEach(x => map[x] = "val" + x); using (var redis = RedisClient.New()) { redis.SetAll(map); var all = redis.GetValuesMap(keys); Assert.AreEqual(map, all); } } [Test] public void Can_store_Dictionary_as_objects() { var map = new Dictionary<string, object>(); map["key_a"] = "123"; map["key_b"] = null; using (var redis = RedisClient.New()) { redis.SetAll(map); Assert.That(redis.Get<string>("key_a"), Is.EqualTo("123")); Assert.That(redis.Get("key_b"), Is.EqualTo("")); } } [Test] public void Can_store_Dictionary_as_bytes() { var map = new Dictionary<string, byte[]>(); map["key_a"] = "123".ToUtf8Bytes(); map["key_b"] = null; using (var redis = RedisClient.New()) { redis.SetAll(map); Assert.That(redis.Get<string>("key_a"), Is.EqualTo("123")); Assert.That(redis.Get("key_b"), Is.EqualTo("")); } } [Test] public void Should_reset_slowlog() { using (var redis = RedisClient.New()) { redis.SlowlogReset(); } } [Test] public void Can_get_showlog() { using (var redis = RedisClient.New()) { var log = redis.GetSlowlog(10); foreach (var t in log) { Console.WriteLine(t.Id); Console.WriteLine(t.Duration); Console.WriteLine(t.Timestamp); Console.WriteLine(string.Join(":", t.Arguments)); } } } [Test] public void Can_change_db_at_runtime() { using (var redis = new RedisClient(TestConfig.SingleHost, TestConfig.RedisPort, db: 1)) { var val = Environment.TickCount; var key = "test" + val; try { redis.Set(key, val); redis.ChangeDb(2); Assert.That(redis.Get<int>(key), Is.EqualTo(0)); redis.ChangeDb(1); Assert.That(redis.Get<int>(key), Is.EqualTo(val)); redis.Dispose(); } finally { redis.ChangeDb(1); redis.Del(key); } } } [Test] public void Can_Set_Expire_Seconds() { Redis.SetValue("key", "val", expireIn: TimeSpan.FromSeconds(1)); Assert.That(Redis.ContainsKey("key"), Is.True); Thread.Sleep(2000); Assert.That(Redis.ContainsKey("key"), Is.False); } [Test] public void Can_Set_Expire_MilliSeconds() { Redis.SetValue("key", "val", expireIn: TimeSpan.FromMilliseconds(1000)); Assert.That(Redis.ContainsKey("key"), Is.True); Thread.Sleep(2000); Assert.That(Redis.ContainsKey("key"), Is.False); } [Test] public void Can_Set_Expire_Seconds_if_exists() { Assert.That(Redis.SetValueIfExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1500)), Is.False); Assert.That(Redis.ContainsKey("key"), Is.False); Redis.SetValue("key", "val"); Assert.That(Redis.SetValueIfExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1000)), Is.True); Assert.That(Redis.ContainsKey("key"), Is.True); Thread.Sleep(2000); Assert.That(Redis.ContainsKey("key"), Is.False); } [Test] public void Can_Set_Expire_Seconds_if_not_exists() { Assert.That(Redis.SetValueIfNotExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1000)), Is.True); Assert.That(Redis.ContainsKey("key"), Is.True); Assert.That(Redis.SetValueIfNotExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1000)), Is.False); Thread.Sleep(2000); Assert.That(Redis.ContainsKey("key"), Is.False); Redis.Remove("key"); Redis.SetValueIfNotExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1000)); Assert.That(Redis.ContainsKey("key"), Is.True); } }
list
public class RedisClientTestsBase { protected string CleanMask = null; protected RedisClient Redis; protected void Log(string fmt, params object[] args) { Debug.WriteLine("{0}", string.Format(fmt, args).Trim()); } [OneTimeSetUp] public virtual void OnBeforeTestFixture() { RedisClient.NewFactoryFn = () => new RedisClient(TestConfig.SingleHost); using (var redis = RedisClient.New()) { redis.FlushAll(); } } [OneTimeTearDown] public virtual void OnAfterTestFixture() { } [SetUp] public virtual void OnBeforeEachTest() { Redis = RedisClient.New(); } [TearDown] public virtual void OnAfterEachTest() { try { if (Redis.NamespacePrefix != null && CleanMask == null) CleanMask = Redis.NamespacePrefix + "*"; if (CleanMask != null) Redis.SearchKeys(CleanMask).ForEach(t => Redis.Del(t)); Redis.Dispose(); } catch (RedisResponseException e) { // if exception has that message then it still proves that BgSave works as expected. if (e.Message.StartsWith("Can‘t BGSAVE while AOF log rewriting is in progress")) return; throw; } } protected string PrefixedKey(string key) { return string.Concat(Redis.NamespacePrefix, key); } public RedisClient GetRedisClient() { var client = new RedisClient(TestConfig.SingleHost); return client; } public RedisClient CreateRedisClient() { var client = new RedisClient(TestConfig.SingleHost); return client; } public string GetString(byte[] stringBytes) { return Encoding.UTF8.GetString(stringBytes); } public byte[] GetBytes(string stringValue) { return Encoding.UTF8.GetBytes(stringValue); } }
public class RedisClientListTests : RedisClientTestsBase { const string ListId = "rcl_testlist"; const string ListId2 = "rcl_testlist2"; private List<string> storeMembers; public RedisClientListTests() { CleanMask = "rcl_testlist*"; } public override void OnBeforeEachTest() { base.OnBeforeEachTest(); storeMembers = new List<string> { "one", "two", "three", "four" }; } private static void AssertAreEqual(List<string> actualList, List<string> expectedList) { Assert.That(actualList, Has.Count.EqualTo(expectedList.Count)); var i = 0; actualList.ForEach(x => Assert.That(x, Is.EqualTo(expectedList[i++]))); } private static void AssertAreEqual(List<string> actualList, Queue<string> expectedList) { Assert.That(actualList, Has.Count.EqualTo(expectedList.Count)); actualList.ForEach(x => Assert.That(x, Is.EqualTo(expectedList.Dequeue()))); } [Test] public void Can_PopAndPushItemBetweenLists() { Redis.AddItemToList(ListId, "1"); Redis.PopAndPushItemBetweenLists(ListId, ListId2); } [Test] public void Can_BlockingPopAndPushItemBetweenLists() { Redis.AddItemToList(ListId, "A"); Redis.AddItemToList(ListId, "B"); var r = Redis.BlockingPopAndPushItemBetweenLists(ListId, ListId2, new TimeSpan(0, 0, 1)); Assert.That(r, Is.EqualTo("B")); } [Test] public void Can_Timeout_BlockingPopAndPushItemBetweenLists() { var r = Redis.BlockingPopAndPushItemBetweenLists(ListId, ListId2, new TimeSpan(0, 0, 1)); Assert.That(r, Is.Null); } [Test] public void Can_AddToList_and_GetAllFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));//添加 var members = Redis.GetAllItemsFromList(ListId);//获取 AssertAreEqual(members, storeMembers);//测试 } [Test] public void Can_AddRangeToList_and_GetAllFromList() { Redis.AddRangeToList(ListId, storeMembers); var members = Redis.GetAllItemsFromList(ListId); AssertAreEqual(members, storeMembers); } [Test] public void Can_PrependRangeToList_and_GetAllFromList() { Redis.PrependRangeToList(ListId, storeMembers); var members = Redis.GetAllItemsFromList(ListId); AssertAreEqual(members, storeMembers); } [Test] public void Can_GetListCount() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var listCount = Redis.GetListCount(ListId); Assert.That(listCount, Is.EqualTo(storeMembers.Count)); } [Test] public void Can_GetItemFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var storeMember3 = storeMembers[2]; var item3 = Redis.GetItemFromList(ListId, 2); Assert.That(item3, Is.EqualTo(storeMember3)); } [Test] public void Can_SetItemInList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); storeMembers[2] = "five"; Redis.SetItemInList(ListId, 2, "five"); var members = Redis.GetAllItemsFromList(ListId); AssertAreEqual(members, storeMembers); } [Test] public void Can_PopFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var item4 = Redis.PopItemFromList(ListId); Assert.That(item4, Is.EqualTo("four")); } [Test] public void Can_EnqueueOnList() { var queue = new Queue<string>(); storeMembers.ForEach(queue.Enqueue); storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x)); while (queue.Count > 0) { var actual = Redis.DequeueItemFromList(ListId); Assert.That(actual, Is.EqualTo(queue.Dequeue())); } } [Test] public void Can_DequeueFromList() { var queue = new Queue<string>(); storeMembers.ForEach(queue.Enqueue); storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x)); var item1 = Redis.DequeueItemFromList(ListId); Assert.That(item1, Is.EqualTo(queue.Dequeue())); } [Test] public void PopAndPushSameAsDequeue() { var queue = new Queue<string>(); storeMembers.ForEach(queue.Enqueue); storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x)); var item1 = Redis.PopAndPushItemBetweenLists(ListId, ListId2); Assert.That(item1, Is.EqualTo(queue.Dequeue())); } [Test] public void Can_BlockingDequeueFromList() { var queue = new Queue<string>(); storeMembers.ForEach(queue.Enqueue); storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x)); var item1 = Redis.BlockingDequeueItemFromList(ListId, null); Assert.That(item1, Is.EqualTo(queue.Dequeue())); } [Test] public void BlockingDequeueFromList_Can_TimeOut() { var item1 = Redis.BlockingDequeueItemFromList(ListId, TimeSpan.FromSeconds(1)); Assert.That(item1, Is.Null); } [Test] public void Can_PushToList() { var stack = new Stack<string>(); storeMembers.ForEach(stack.Push); storeMembers.ForEach(x => Redis.PushItemToList(ListId, x)); while (stack.Count > 0) { var actual = Redis.PopItemFromList(ListId); Assert.That(actual, Is.EqualTo(stack.Pop())); } } [Test] public void Can_BlockingPopFromList() { var stack = new Stack<string>(); storeMembers.ForEach(stack.Push); storeMembers.ForEach(x => Redis.PushItemToList(ListId, x)); var item1 = Redis.BlockingPopItemFromList(ListId, null); Assert.That(item1, Is.EqualTo(stack.Pop())); } [Test] public void BlockingPopFromList_Can_TimeOut() { var item1 = Redis.BlockingPopItemFromList(ListId, TimeSpan.FromSeconds(1)); Assert.That(item1, Is.Null); } [Test] public void Can_RemoveStartFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var item1 = Redis.RemoveStartFromList(ListId); Assert.That(item1, Is.EqualTo(storeMembers.First())); } [Test] public void Can_RemoveEndFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var item1 = Redis.RemoveEndFromList(ListId); Assert.That(item1, Is.EqualTo(storeMembers.Last())); } [Test] public void Can_BlockingRemoveStartFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var item1 = Redis.BlockingRemoveStartFromList(ListId, null); Assert.That(item1, Is.EqualTo(storeMembers.First())); } [Test] public void Can_MoveBetweenLists() { var list1Members = new List<string> { "one", "two", "three", "four" }; var list2Members = new List<string> { "five", "six", "seven" }; const string item4 = "four"; list1Members.ForEach(x => Redis.AddItemToList(ListId, x)); list2Members.ForEach(x => Redis.AddItemToList(ListId2, x)); list1Members.Remove(item4); list2Members.Insert(0, item4); Redis.PopAndPushItemBetweenLists(ListId, ListId2); var readList1 = Redis.GetAllItemsFromList(ListId); var readList2 = Redis.GetAllItemsFromList(ListId2); AssertAreEqual(readList1, list1Members); AssertAreEqual(readList2, list2Members); } [Test] public void Can_enumerate_small_list() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var readMembers = new List<string>(); foreach (var item in Redis.Lists[ListId]) { readMembers.Add(item); } AssertAreEqual(readMembers, storeMembers); } [Test] public void Can_enumerate_large_list() { if (TestConfig.IgnoreLongTests) return; const int listSize = 2500; storeMembers = new List<string>(); listSize.Times(x => { Redis.AddItemToList(ListId, x.ToString()); storeMembers.Add(x.ToString()); }); var members = new List<string>(); foreach (var item in Redis.Lists[ListId]) { members.Add(item); } members.Sort((x, y) => int.Parse(x).CompareTo(int.Parse(y))); Assert.That(members.Count, Is.EqualTo(storeMembers.Count)); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_Add_to_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); var members = list.ToList<string>(); AssertAreEqual(members, storeMembers); } [Test] public void Can_Clear_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); Assert.That(list.Count, Is.EqualTo(storeMembers.Count)); list.Clear(); Assert.That(list.Count, Is.EqualTo(0)); } [Test] public void Can_Test_Contains_in_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); Assert.That(list.Contains("two"), Is.True); Assert.That(list.Contains("five"), Is.False); } [Test] public void Can_Remove_value_from_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); storeMembers.Remove("two"); list.Remove("two"); var members = list.ToList<string>(); AssertAreEqual(members, storeMembers); } [Test] public void Can_RemoveAt_value_from_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); storeMembers.RemoveAt(2); list.RemoveAt(2); var members = list.ToList<string>(); AssertAreEqual(members, storeMembers); } [Test] public void Can_get_default_index_from_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); for (var i = 0; i < storeMembers.Count; i++) { Assert.That(list[i], Is.EqualTo(storeMembers[i])); } } [Test] public void Can_test_for_IndexOf_in_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); foreach (var item in storeMembers) { Assert.That(list.IndexOf(item), Is.EqualTo(storeMembers.IndexOf(item))); } } [Test] public void Can_AddRangeToList_and_GetSortedItems() { Redis.PrependRangeToList(ListId, storeMembers); var members = Redis.GetSortedItemsFromList(ListId, new SortOptions { SortAlpha = true, SortDesc = true, Skip = 1, Take = 2 }); AssertAreEqual(members, storeMembers.OrderByDescending(s => s).Skip(1).Take(2).ToList()); } public class Test { public string A { get; set; } } [Test] public void RemoveAll_removes_all_items_from_Named_List() { var redis = Redis.As<Test>(); var clientesRepo = redis.Lists["repo:Client:Test"]; Assert.IsTrue(clientesRepo.Count == 0, "Count 1 = " + clientesRepo.Count); clientesRepo.Add(new Test() { A = "Test" }); Assert.IsTrue(clientesRepo.Count == 1, "Count 2 = " + clientesRepo.Count); clientesRepo.RemoveAll(); Assert.IsTrue(clientesRepo.Count == 0, "Count 3 = " + clientesRepo.Count); } }
hash
public class RedisClientListTests : RedisClientTestsBase { const string ListId = "rcl_testlist"; const string ListId2 = "rcl_testlist2"; private List<string> storeMembers; public RedisClientListTests() { CleanMask = "rcl_testlist*"; } public override void OnBeforeEachTest() { base.OnBeforeEachTest(); storeMembers = new List<string> { "one", "two", "three", "four" }; } private static void AssertAreEqual(List<string> actualList, List<string> expectedList) { Assert.That(actualList, Has.Count.EqualTo(expectedList.Count)); var i = 0; actualList.ForEach(x => Assert.That(x, Is.EqualTo(expectedList[i++]))); } private static void AssertAreEqual(List<string> actualList, Queue<string> expectedList) { Assert.That(actualList, Has.Count.EqualTo(expectedList.Count)); actualList.ForEach(x => Assert.That(x, Is.EqualTo(expectedList.Dequeue()))); } [Test] public void Can_PopAndPushItemBetweenLists() { Redis.AddItemToList(ListId, "1"); Redis.PopAndPushItemBetweenLists(ListId, ListId2); } [Test] public void Can_BlockingPopAndPushItemBetweenLists() { Redis.AddItemToList(ListId, "A"); Redis.AddItemToList(ListId, "B"); var r = Redis.BlockingPopAndPushItemBetweenLists(ListId, ListId2, new TimeSpan(0, 0, 1)); Assert.That(r, Is.EqualTo("B")); } [Test] public void Can_Timeout_BlockingPopAndPushItemBetweenLists() { var r = Redis.BlockingPopAndPushItemBetweenLists(ListId, ListId2, new TimeSpan(0, 0, 1)); Assert.That(r, Is.Null); } [Test] public void Can_AddToList_and_GetAllFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var members = Redis.GetAllItemsFromList(ListId); AssertAreEqual(members, storeMembers); } [Test] public void Can_AddRangeToList_and_GetAllFromList() { Redis.AddRangeToList(ListId, storeMembers); var members = Redis.GetAllItemsFromList(ListId); AssertAreEqual(members, storeMembers); } [Test] public void Can_PrependRangeToList_and_GetAllFromList() { Redis.PrependRangeToList(ListId, storeMembers); var members = Redis.GetAllItemsFromList(ListId); AssertAreEqual(members, storeMembers); } [Test] public void Can_GetListCount() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var listCount = Redis.GetListCount(ListId); Assert.That(listCount, Is.EqualTo(storeMembers.Count)); } [Test] public void Can_GetItemFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var storeMember3 = storeMembers[2]; var item3 = Redis.GetItemFromList(ListId, 2); Assert.That(item3, Is.EqualTo(storeMember3)); } [Test] public void Can_SetItemInList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); storeMembers[2] = "five"; Redis.SetItemInList(ListId, 2, "five"); var members = Redis.GetAllItemsFromList(ListId); AssertAreEqual(members, storeMembers); } [Test] public void Can_PopFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var item4 = Redis.PopItemFromList(ListId); Assert.That(item4, Is.EqualTo("four")); } [Test] public void Can_EnqueueOnList() { var queue = new Queue<string>(); storeMembers.ForEach(queue.Enqueue); storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x)); while (queue.Count > 0) { var actual = Redis.DequeueItemFromList(ListId); Assert.That(actual, Is.EqualTo(queue.Dequeue())); } } [Test] public void Can_DequeueFromList() { var queue = new Queue<string>(); storeMembers.ForEach(queue.Enqueue); storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x)); var item1 = Redis.DequeueItemFromList(ListId); Assert.That(item1, Is.EqualTo(queue.Dequeue())); } [Test] public void PopAndPushSameAsDequeue() { var queue = new Queue<string>(); storeMembers.ForEach(queue.Enqueue); storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x)); var item1 = Redis.PopAndPushItemBetweenLists(ListId, ListId2); Assert.That(item1, Is.EqualTo(queue.Dequeue())); } [Test] public void Can_BlockingDequeueFromList() { var queue = new Queue<string>(); storeMembers.ForEach(queue.Enqueue); storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x)); var item1 = Redis.BlockingDequeueItemFromList(ListId, null); Assert.That(item1, Is.EqualTo(queue.Dequeue())); } [Test] public void BlockingDequeueFromList_Can_TimeOut() { var item1 = Redis.BlockingDequeueItemFromList(ListId, TimeSpan.FromSeconds(1)); Assert.That(item1, Is.Null); } [Test] public void Can_PushToList() { var stack = new Stack<string>(); storeMembers.ForEach(stack.Push); storeMembers.ForEach(x => Redis.PushItemToList(ListId, x)); while (stack.Count > 0) { var actual = Redis.PopItemFromList(ListId); Assert.That(actual, Is.EqualTo(stack.Pop())); } } [Test] public void Can_BlockingPopFromList() { var stack = new Stack<string>(); storeMembers.ForEach(stack.Push); storeMembers.ForEach(x => Redis.PushItemToList(ListId, x)); var item1 = Redis.BlockingPopItemFromList(ListId, null); Assert.That(item1, Is.EqualTo(stack.Pop())); } [Test] public void BlockingPopFromList_Can_TimeOut() { var item1 = Redis.BlockingPopItemFromList(ListId, TimeSpan.FromSeconds(1)); Assert.That(item1, Is.Null); } [Test] public void Can_RemoveStartFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var item1 = Redis.RemoveStartFromList(ListId); Assert.That(item1, Is.EqualTo(storeMembers.First())); } [Test] public void Can_RemoveEndFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var item1 = Redis.RemoveEndFromList(ListId); Assert.That(item1, Is.EqualTo(storeMembers.Last())); } [Test] public void Can_BlockingRemoveStartFromList() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var item1 = Redis.BlockingRemoveStartFromList(ListId, null); Assert.That(item1, Is.EqualTo(storeMembers.First())); } [Test] public void Can_MoveBetweenLists() { var list1Members = new List<string> { "one", "two", "three", "four" }; var list2Members = new List<string> { "five", "six", "seven" }; const string item4 = "four"; list1Members.ForEach(x => Redis.AddItemToList(ListId, x)); list2Members.ForEach(x => Redis.AddItemToList(ListId2, x)); list1Members.Remove(item4); list2Members.Insert(0, item4); Redis.PopAndPushItemBetweenLists(ListId, ListId2); var readList1 = Redis.GetAllItemsFromList(ListId); var readList2 = Redis.GetAllItemsFromList(ListId2); AssertAreEqual(readList1, list1Members); AssertAreEqual(readList2, list2Members); } [Test] public void Can_enumerate_small_list() { storeMembers.ForEach(x => Redis.AddItemToList(ListId, x)); var readMembers = new List<string>(); foreach (var item in Redis.Lists[ListId]) { readMembers.Add(item); } AssertAreEqual(readMembers, storeMembers); } [Test] public void Can_enumerate_large_list() { if (TestConfig.IgnoreLongTests) return; const int listSize = 2500; storeMembers = new List<string>(); listSize.Times(x => { Redis.AddItemToList(ListId, x.ToString()); storeMembers.Add(x.ToString()); }); var members = new List<string>(); foreach (var item in Redis.Lists[ListId]) { members.Add(item); } members.Sort((x, y) => int.Parse(x).CompareTo(int.Parse(y))); Assert.That(members.Count, Is.EqualTo(storeMembers.Count)); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_Add_to_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); var members = list.ToList<string>(); AssertAreEqual(members, storeMembers); } [Test] public void Can_Clear_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); Assert.That(list.Count, Is.EqualTo(storeMembers.Count)); list.Clear(); Assert.That(list.Count, Is.EqualTo(0)); } [Test] public void Can_Test_Contains_in_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); Assert.That(list.Contains("two"), Is.True); Assert.That(list.Contains("five"), Is.False); } [Test] public void Can_Remove_value_from_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); storeMembers.Remove("two"); list.Remove("two"); var members = list.ToList<string>(); AssertAreEqual(members, storeMembers); } [Test] public void Can_RemoveAt_value_from_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); storeMembers.RemoveAt(2); list.RemoveAt(2); var members = list.ToList<string>(); AssertAreEqual(members, storeMembers); } [Test] public void Can_get_default_index_from_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); for (var i = 0; i < storeMembers.Count; i++) { Assert.That(list[i], Is.EqualTo(storeMembers[i])); } } [Test] public void Can_test_for_IndexOf_in_IList() { var list = Redis.Lists[ListId]; storeMembers.ForEach(list.Add); foreach (var item in storeMembers) { Assert.That(list.IndexOf(item), Is.EqualTo(storeMembers.IndexOf(item))); } } [Test] public void Can_AddRangeToList_and_GetSortedItems() { Redis.PrependRangeToList(ListId, storeMembers); var members = Redis.GetSortedItemsFromList(ListId, new SortOptions { SortAlpha = true, SortDesc = true, Skip = 1, Take = 2 }); AssertAreEqual(members, storeMembers.OrderByDescending(s => s).Skip(1).Take(2).ToList()); } public class Test { public string A { get; set; } } [Test] public void RemoveAll_removes_all_items_from_Named_List() { var redis = Redis.As<Test>(); var clientesRepo = redis.Lists["repo:Client:Test"]; Assert.IsTrue(clientesRepo.Count == 0, "Count 1 = " + clientesRepo.Count); clientesRepo.Add(new Test() { A = "Test" }); Assert.IsTrue(clientesRepo.Count == 1, "Count 2 = " + clientesRepo.Count); clientesRepo.RemoveAll(); Assert.IsTrue(clientesRepo.Count == 0, "Count 3 = " + clientesRepo.Count); } }
set
public class RedisClientSetTests : RedisClientTestsBase { private const string SetIdSuffix = "testset"; private List<string> storeMembers; private string SetId { get { return this.PrefixedKey(SetIdSuffix); } } [SetUp] public override void OnBeforeEachTest() { base.OnBeforeEachTest(); Redis.NamespacePrefix = "RedisClientSetTests"; storeMembers = new List<string> { "one", "two", "three", "four" }; } [Test] public void Can_AddToSet_and_GetAllFromSet() { storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x)); var members = Redis.GetAllItemsFromSet(SetId); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_AddRangeToSet_and_GetAllFromSet() { Redis.AddRangeToSet(SetId, storeMembers); var members = Redis.GetAllItemsFromSet(SetId); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_RemoveFromSet() { const string removeMember = "two"; storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x)); Redis.RemoveItemFromSet(SetId, removeMember); storeMembers.Remove(removeMember); var members = Redis.GetAllItemsFromSet(SetId); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_PopFromSet() { storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x)); var member = Redis.PopItemFromSet(SetId); Assert.That(storeMembers.Contains(member), Is.True); } [Test] public void Can_MoveBetweenSets() { string fromSetId = PrefixedKey("testmovefromset"); string toSetId = PrefixedKey("testmovetoset"); const string moveMember = "four"; var fromSetIdMembers = new List<string> { "one", "two", "three", "four" }; var toSetIdMembers = new List<string> { "five", "six", "seven" }; fromSetIdMembers.ForEach(x => Redis.AddItemToSet(fromSetId, x)); toSetIdMembers.ForEach(x => Redis.AddItemToSet(toSetId, x)); Redis.MoveBetweenSets(fromSetId, toSetId, moveMember); fromSetIdMembers.Remove(moveMember); toSetIdMembers.Add(moveMember); var readFromSetId = Redis.GetAllItemsFromSet(fromSetId); var readToSetId = Redis.GetAllItemsFromSet(toSetId); Assert.That(readFromSetId, Is.EquivalentTo(fromSetIdMembers)); Assert.That(readToSetId, Is.EquivalentTo(toSetIdMembers)); } [Test] public void Can_GetSetCount() { storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x)); var setCount = Redis.GetSetCount(SetId); Assert.That(setCount, Is.EqualTo(storeMembers.Count)); } [Test] public void Does_SetContainsValue() { const string existingMember = "two"; const string nonExistingMember = "five"; storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x)); Assert.That(Redis.SetContainsItem(SetId, existingMember), Is.True); Assert.That(Redis.SetContainsItem(SetId, nonExistingMember), Is.False); } [Test] public void Can_IntersectBetweenSets() { string set1Name = PrefixedKey("testintersectset1"); string set2Name = PrefixedKey("testintersectset2"); var set1Members = new List<string> { "one", "two", "three", "four", "five" }; var set2Members = new List<string> { "four", "five", "six", "seven" }; set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x)); set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x)); var intersectingMembers = Redis.GetIntersectFromSets(set1Name, set2Name); Assert.That(intersectingMembers, Is.EquivalentTo(new List<string> { "four", "five" })); } [Test] public void Can_Store_IntersectBetweenSets() { string set1Name = PrefixedKey("testintersectset1"); string set2Name = PrefixedKey("testintersectset2"); string storeSetName = PrefixedKey("testintersectsetstore"); var set1Members = new List<string> { "one", "two", "three", "four", "five" }; var set2Members = new List<string> { "four", "five", "six", "seven" }; set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x)); set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x)); Redis.StoreIntersectFromSets(storeSetName, set1Name, set2Name); var intersectingMembers = Redis.GetAllItemsFromSet(storeSetName); Assert.That(intersectingMembers, Is.EquivalentTo(new List<string> { "four", "five" })); } [Test] public void Can_UnionBetweenSets() { string set1Name = PrefixedKey("testunionset1"); string set2Name = PrefixedKey("testunionset2"); var set1Members = new List<string> { "one", "two", "three", "four", "five" }; var set2Members = new List<string> { "four", "five", "six", "seven" }; set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x)); set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x)); var unionMembers = Redis.GetUnionFromSets(set1Name, set2Name); Assert.That(unionMembers, Is.EquivalentTo( new List<string> { "one", "two", "three", "four", "five", "six", "seven" })); } [Test] public void Can_Store_UnionBetweenSets() { string set1Name = PrefixedKey("testunionset1"); string set2Name = PrefixedKey("testunionset2"); string storeSetName = PrefixedKey("testunionsetstore"); var set1Members = new List<string> { "one", "two", "three", "four", "five" }; var set2Members = new List<string> { "four", "five", "six", "seven" }; set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x)); set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x)); Redis.StoreUnionFromSets(storeSetName, set1Name, set2Name); var unionMembers = Redis.GetAllItemsFromSet(storeSetName); Assert.That(unionMembers, Is.EquivalentTo( new List<string> { "one", "two", "three", "four", "five", "six", "seven" })); } [Test] public void Can_DiffBetweenSets() { string set1Name = PrefixedKey("testdiffset1"); string set2Name = PrefixedKey("testdiffset2"); string set3Name = PrefixedKey("testdiffset3"); var set1Members = new List<string> { "one", "two", "three", "four", "five" }; var set2Members = new List<string> { "four", "five", "six", "seven" }; var set3Members = new List<string> { "one", "five", "seven", "eleven" }; set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x)); set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x)); set3Members.ForEach(x => Redis.AddItemToSet(set3Name, x)); var diffMembers = Redis.GetDifferencesFromSet(set1Name, set2Name, set3Name); Assert.That(diffMembers, Is.EquivalentTo( new List<string> { "two", "three" })); } [Test] public void Can_Store_DiffBetweenSets() { string set1Name = PrefixedKey("testdiffset1"); string set2Name = PrefixedKey("testdiffset2"); string set3Name = PrefixedKey("testdiffset3"); string storeSetName = PrefixedKey("testdiffsetstore"); var set1Members = new List<string> { "one", "two", "three", "four", "five" }; var set2Members = new List<string> { "four", "five", "six", "seven" }; var set3Members = new List<string> { "one", "five", "seven", "eleven" }; set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x)); set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x)); set3Members.ForEach(x => Redis.AddItemToSet(set3Name, x)); Redis.StoreDifferencesFromSet(storeSetName, set1Name, set2Name, set3Name); var diffMembers = Redis.GetAllItemsFromSet(storeSetName); Assert.That(diffMembers, Is.EquivalentTo( new List<string> { "two", "three" })); } [Test] public void Can_GetRandomEntryFromSet() { storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x)); var randomEntry = Redis.GetRandomItemFromSet(SetId); Assert.That(storeMembers.Contains(randomEntry), Is.True); } [Test] public void Can_enumerate_small_ICollection_Set() { storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x)); var members = new List<string>(); foreach (var item in Redis.Sets[SetId]) { members.Add(item); } members.Sort(); Assert.That(members.Count, Is.EqualTo(storeMembers.Count)); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_enumerate_large_ICollection_Set() { if (TestConfig.IgnoreLongTests) return; const int setSize = 2500; storeMembers = new List<string>(); setSize.Times(x => { Redis.AddItemToSet(SetId, x.ToString()); storeMembers.Add(x.ToString()); }); var members = new List<string>(); foreach (var item in Redis.Sets[SetId]) { members.Add(item); } members.Sort((x, y) => int.Parse(x).CompareTo(int.Parse(y))); Assert.That(members.Count, Is.EqualTo(storeMembers.Count)); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_Add_to_ICollection_Set() { var list = Redis.Sets[SetId]; storeMembers.ForEach(list.Add); var members = list.ToList(); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_Clear_ICollection_Set() { var list = Redis.Sets[SetId]; storeMembers.ForEach(list.Add); Assert.That(list.Count, Is.EqualTo(storeMembers.Count)); list.Clear(); Assert.That(list.Count, Is.EqualTo(0)); } [Test] public void Can_Test_Contains_in_ICollection_Set() { var list = Redis.Sets[SetId]; storeMembers.ForEach(list.Add); Assert.That(list.Contains("two"), Is.True); Assert.That(list.Contains("five"), Is.False); } [Test] public void Can_Remove_value_from_ICollection_Set() { var list = Redis.Sets[SetId]; storeMembers.ForEach(list.Add); storeMembers.Remove("two"); list.Remove("two"); var members = list.ToList(); Assert.That(members, Is.EquivalentTo(storeMembers)); } }
zset
public class RedisClientSortedSetTests : RedisClientTestsBase { private const string SetIdSuffix = "testzset"; private List<string> storeMembers; private string SetId { get { return PrefixedKey(SetIdSuffix); } } Dictionary<string, double> stringDoubleMap; public override void OnBeforeEachTest() { base.OnBeforeEachTest(); Redis.NamespacePrefix = "RedisClientSortedSetTests"; storeMembers = new List<string> { "one", "two", "three", "four" }; stringDoubleMap = new Dictionary<string, double> { {"one",1}, {"two",2}, {"three",3}, {"four",4} }; } [Test] public void Can_AddItemToSortedSet_and_GetAllFromSet() { var i = 0; storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, i++)); var members = Redis.GetAllItemsFromSortedSet(SetId); Assert.That(members.EquivalentTo(storeMembers), Is.True); } [Test] public void Can_AddRangeToSortedSet_and_GetAllFromSet() { var success = Redis.AddRangeToSortedSet(SetId, storeMembers, 1); Assert.That(success, Is.True); var members = Redis.GetAllItemsFromSortedSet(SetId); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void AddToSet_without_score_adds_an_implicit_lexical_order_score() { storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x)); var members = Redis.GetAllItemsFromSortedSet(SetId); storeMembers.Sort((x, y) => x.CompareTo(y)); Assert.That(members.EquivalentTo(storeMembers), Is.True); } [Test] public void AddToSet_with_same_score_is_still_returned_in_lexical_order_score() { storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, 1)); var members = Redis.GetAllItemsFromSortedSet(SetId); storeMembers.Sort((x, y) => x.CompareTo(y)); Assert.That(members.EquivalentTo(storeMembers)); } [Test] public void Can_RemoveFromSet() { const string removeMember = "two"; storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x)); Redis.RemoveItemFromSortedSet(SetId, removeMember); storeMembers.Remove(removeMember); var members = Redis.GetAllItemsFromSortedSet(SetId); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_RemoveItemsFromSortedSet() { var removeMembers = new[] { "two" , "four", "six" }; storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x)); var removeCount = Redis.RemoveItemsFromSortedSet(SetId, removeMembers.ToList()); Assert.That(removeCount, Is.EqualTo(2)); removeMembers.Each(x => storeMembers.Remove(x)); var members = Redis.GetAllItemsFromSortedSet(SetId); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_PopFromSet() { var i = 0; storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, i++)); var member = Redis.PopItemWithHighestScoreFromSortedSet(SetId); Assert.That(member, Is.EqualTo("four")); } [Test] public void Can_GetSetCount() { storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x)); var setCount = Redis.GetSortedSetCount(SetId); Assert.That(setCount, Is.EqualTo(storeMembers.Count)); } [Test] public void Can_GetSetCountByScores() { var scores = new List<double>(); storeMembers.ForEach(x => { Redis.AddItemToSortedSet(SetId, x); scores.Add(RedisClient.GetLexicalScore(x)); }); Assert.That(Redis.GetSortedSetCount(SetId, scores.Min(), scores.Max()), Is.EqualTo(storeMembers.Count())); Assert.That(Redis.GetSortedSetCount(SetId, scores.Min(), scores.Min()), Is.EqualTo(1)); } [Test] public void Does_SortedSetContainsValue() { const string existingMember = "two"; const string nonExistingMember = "five"; storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x)); Assert.That(Redis.SortedSetContainsItem(SetId, existingMember), Is.True); Assert.That(Redis.SortedSetContainsItem(SetId, nonExistingMember), Is.False); } [Test] public void Can_GetItemIndexInSortedSet_in_Asc_and_Desc() { var i = 10; storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, i++)); Assert.That(Redis.GetItemIndexInSortedSet(SetId, "one"), Is.EqualTo(0)); Assert.That(Redis.GetItemIndexInSortedSet(SetId, "two"), Is.EqualTo(1)); Assert.That(Redis.GetItemIndexInSortedSet(SetId, "three"), Is.EqualTo(2)); Assert.That(Redis.GetItemIndexInSortedSet(SetId, "four"), Is.EqualTo(3)); Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "one"), Is.EqualTo(3)); Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "two"), Is.EqualTo(2)); Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "three"), Is.EqualTo(1)); Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "four"), Is.EqualTo(0)); } [Test] public void Can_Store_IntersectBetweenSets() { string set1Name = PrefixedKey("testintersectset1"); string set2Name = PrefixedKey("testintersectset2"); string storeSetName = PrefixedKey("testintersectsetstore"); var set1Members = new List<string> { "one", "two", "three", "four", "five" }; var set2Members = new List<string> { "four", "five", "six", "seven" }; set1Members.ForEach(x => Redis.AddItemToSortedSet(set1Name, x)); set2Members.ForEach(x => Redis.AddItemToSortedSet(set2Name, x)); Redis.StoreIntersectFromSortedSets(storeSetName, set1Name, set2Name); var intersectingMembers = Redis.GetAllItemsFromSortedSet(storeSetName); Assert.That(intersectingMembers, Is.EquivalentTo(new List<string> { "four", "five" })); } [Test] public void Can_Store_UnionBetweenSets() { string set1Name = PrefixedKey("testunionset1"); string set2Name = PrefixedKey("testunionset2"); string storeSetName = PrefixedKey("testunionsetstore"); var set1Members = new List<string> { "one", "two", "three", "four", "five" }; var set2Members = new List<string> { "four", "five", "six", "seven" }; set1Members.ForEach(x => Redis.AddItemToSortedSet(set1Name, x)); set2Members.ForEach(x => Redis.AddItemToSortedSet(set2Name, x)); Redis.StoreUnionFromSortedSets(storeSetName, set1Name, set2Name); var unionMembers = Redis.GetAllItemsFromSortedSet(storeSetName); Assert.That(unionMembers, Is.EquivalentTo( new List<string> { "one", "two", "three", "four", "five", "six", "seven" })); } [Test] public void Can_pop_items_with_lowest_and_highest_scores_from_sorted_set() { storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x)); storeMembers.Sort((x, y) => x.CompareTo(y)); var lowestScore = Redis.PopItemWithLowestScoreFromSortedSet(SetId); Assert.That(lowestScore, Is.EqualTo(storeMembers.First())); var highestScore = Redis.PopItemWithHighestScoreFromSortedSet(SetId); Assert.That(highestScore, Is.EqualTo(storeMembers[storeMembers.Count - 1])); } [Test] public void Can_GetRangeFromSortedSetByLowestScore_from_sorted_set() { storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x)); storeMembers.Sort((x, y) => x.CompareTo(y)); var memberRage = storeMembers.Where(x => x.CompareTo("four") >= 0 && x.CompareTo("three") <= 0).ToList(); var range = Redis.GetRangeFromSortedSetByLowestScore(SetId, "four", "three"); Assert.That(range.EquivalentTo(memberRage)); } [Test] public void Can_IncrementItemInSortedSet() { stringDoubleMap.Each(x => Redis.AddItemToSortedSet(SetId, x.Key, x.Value)); var currentScore = Redis.IncrementItemInSortedSet(SetId, "one", 3); stringDoubleMap["one"] = stringDoubleMap["one"] + 3; Assert.That(currentScore, Is.EqualTo(stringDoubleMap["one"])); currentScore = Redis.IncrementItemInSortedSet(SetId, "four", -3); stringDoubleMap["four"] = stringDoubleMap["four"] - 3; Assert.That(currentScore, Is.EqualTo(stringDoubleMap["four"])); var map = Redis.GetAllWithScoresFromSortedSet(SetId); Assert.That(stringDoubleMap.UnorderedEquivalentTo(map)); } [Test] public void Can_WorkInSortedSetUnderDifferentCulture() { #if NETCORE var prevCulture = CultureInfo.CurrentCulture; CultureInfo.CurrentCulture = new CultureInfo("ru-RU"); #else var prevCulture = Thread.CurrentThread.CurrentCulture; Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("ru-RU"); #endif Redis.AddItemToSortedSet(SetId, "key", 123.22); var map = Redis.GetAllWithScoresFromSortedSet(SetId); Assert.AreEqual(123.22, map["key"]); #if NETCORE CultureInfo.CurrentCulture = prevCulture; #else Thread.CurrentThread.CurrentCulture = prevCulture; #endif } [Ignore("Not implemented yet")] [Test] public void Can_GetRangeFromSortedSetByHighestScore_from_sorted_set() { storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x)); storeMembers.Sort((x, y) => y.CompareTo(x)); var memberRage = storeMembers.Where(x => x.CompareTo("four") >= 0 && x.CompareTo("three") <= 0).ToList(); var range = Redis.GetRangeFromSortedSetByHighestScore(SetId, "four", "three"); Assert.That(range.EquivalentTo(memberRage)); } [Test] public void Can_get_index_and_score_from_SortedSet() { storeMembers = new List<string> { "a", "b", "c", "d" }; const double initialScore = 10d; var i = initialScore; storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, i++)); Assert.That(Redis.GetItemIndexInSortedSet(SetId, "a"), Is.EqualTo(0)); Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "a"), Is.EqualTo(storeMembers.Count - 1)); Assert.That(Redis.GetItemScoreInSortedSet(SetId, "a"), Is.EqualTo(initialScore)); Assert.That(Redis.GetItemScoreInSortedSet(SetId, "d"), Is.EqualTo(initialScore + storeMembers.Count - 1)); } [Test] public void Can_enumerate_small_ICollection_Set() { storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x)); var members = new List<string>(); foreach (var item in Redis.SortedSets[SetId]) { members.Add(item); } members.Sort(); Assert.That(members.Count, Is.EqualTo(storeMembers.Count)); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_enumerate_large_ICollection_Set() { if (TestConfig.IgnoreLongTests) return; const int setSize = 2500; storeMembers = new List<string>(); setSize.Times(x => { Redis.AddItemToSortedSet(SetId, x.ToString()); storeMembers.Add(x.ToString()); }); var members = new List<string>(); foreach (var item in Redis.SortedSets[SetId]) { members.Add(item); } members.Sort((x, y) => int.Parse(x).CompareTo(int.Parse(y))); Assert.That(members.Count, Is.EqualTo(storeMembers.Count)); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_Add_to_ICollection_Set() { var list = Redis.SortedSets[SetId]; storeMembers.ForEach(list.Add); var members = list.ToList<string>(); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Can_Clear_ICollection_Set() { var list = Redis.SortedSets[SetId]; storeMembers.ForEach(list.Add); Assert.That(list.Count, Is.EqualTo(storeMembers.Count)); list.Clear(); Assert.That(list.Count, Is.EqualTo(0)); } [Test] public void Can_Test_Contains_in_ICollection_Set() { var list = Redis.SortedSets[SetId]; storeMembers.ForEach(list.Add); Assert.That(list.Contains("two"), Is.True); Assert.That(list.Contains("five"), Is.False); } [Test] public void Can_Remove_value_from_ICollection_Set() { var list = Redis.SortedSets[SetId]; storeMembers.ForEach(list.Add); storeMembers.Remove("two"); list.Remove("two"); var members = list.ToList(); Assert.That(members, Is.EquivalentTo(storeMembers)); } [Test] public void Score_from_non_existent_item_returns_NaN() { var score = Redis.GetItemScoreInSortedSet("nonexistentset", "value"); Assert.That(score, Is.EqualTo(Double.NaN)); } [Test] public void Can_add_large_score_to_sortedset() { Redis.AddItemToSortedSet(SetId, "value", 12345678901234567890d); var score = Redis.GetItemScoreInSortedSet(SetId, "value"); Assert.That(score, Is.EqualTo(12345678901234567890d)); } public class Article { public int Id { get; set; } public string Title { get; set; } public DateTime ModifiedDate { get; set; } } [Test] public void Can_use_SortedIndex_to_store_articles_by_Date() { var redisArticles = Redis.As<Article>(); var articles = new[] { new Article { Id = 1, Title = "Article 1", ModifiedDate = new DateTime(2015, 01, 02) }, new Article { Id = 2, Title = "Article 2", ModifiedDate = new DateTime(2015, 01, 01) }, new Article { Id = 3, Title = "Article 3", ModifiedDate = new DateTime(2015, 01, 03) }, }; redisArticles.StoreAll(articles); const string LatestArticlesSet = "urn:Article:modified"; foreach (var article in articles) { Redis.AddItemToSortedSet(LatestArticlesSet, article.Id.ToString(), article.ModifiedDate.Ticks); } var articleIds = Redis.GetAllItemsFromSortedSetDesc(LatestArticlesSet); articleIds.PrintDump(); var latestArticles = redisArticles.GetByIds(articleIds); latestArticles.PrintDump(); } }
ConfigTests
public class ConfigTests { [OneTimeSetUp] public void OneTimeSetUp() { RedisConfig.VerifyMasterConnections = false; } [OneTimeTearDown] public void OneTimeTearDown() { RedisConfig.VerifyMasterConnections = true; } [Test] [TestCase("host", "{Host:host,Port:6379}")] [TestCase("redis://host", "{Host:host,Port:6379}")] [TestCase("host:1", "{Host:host,Port:1}")] [TestCase("pass@host:1", "{Host:host,Port:1,Password:pass}")] [TestCase("nunit:pass@host:1", "{Host:host,Port:1,Client:nunit,Password:pass}")] [TestCase("host:1?password=pass&client=nunit", "{Host:host,Port:1,Client:nunit,Password:pass}")] [TestCase("host:1?db=2", "{Host:host,Port:1,Db:2}")] [TestCase("host?ssl=true", "{Host:host,Port:6380,Ssl:True}")] [TestCase("host:6380?ssl=true&password=pass&sslprotocols=Tls12", "{Host:host,Port:6380,Ssl:True,Password:pass,SslProtocols:Tls12}")] [TestCase("host:1?ssl=true", "{Host:host,Port:1,Ssl:True}")] [TestCase("host:1?connectTimeout=1&sendtimeout=2&receiveTimeout=3&idletimeoutsecs=4", "{Host:host,Port:1,ConnectTimeout:1,SendTimeout:2,ReceiveTimeout:3,IdleTimeOutSecs:4}")] [TestCase("redis://nunit:pass@host:1?ssl=true&db=1&connectTimeout=2&sendtimeout=3&receiveTimeout=4&retryTimeout=5&idletimeoutsecs=5&NamespacePrefix=prefix.", "{Host:host,Port:1,Ssl:True,Client:nunit,Password:pass,Db:1,ConnectTimeout:2,SendTimeout:3,ReceiveTimeout:4,RetryTimeout:5,IdleTimeOutSecs:5,NamespacePrefix:prefix.}")] [TestCase("redis://nunit:pass@host:1?ssl=true&sslprotocols=Tls12&db=1&connectTimeout=2&sendtimeout=3&receiveTimeout=4&retryTimeout=5&idletimeoutsecs=5&NamespacePrefix=prefix.", "{Host:host,Port:1,Ssl:True,Client:nunit,Password:pass,SslProtocols:Tls12,Db:1,ConnectTimeout:2,SendTimeout:3,ReceiveTimeout:4,RetryTimeout:5,IdleTimeOutSecs:5,NamespacePrefix:prefix.}")] public void Does_handle_different_connection_strings_settings(string connString, string expectedJsv) { var actual = connString.ToRedisEndpoint(); var expected = expectedJsv.FromJsv<RedisEndpoint>(); Assert.That(actual, Is.EqualTo(expected), "{0} != {1}".Fmt(actual.ToJsv(), expected.ToJsv())); } [Test] [TestCase("host", "host:6379")] [TestCase("redis://host", "host:6379")] [TestCase("host:1", "host:1")] [TestCase("pass@host:1", "host:1?Password=pass")] [TestCase("nunit:pass@host:1", "host:1?Client=nunit&Password=pass")] [TestCase("host:1?password=pass&client=nunit", "host:1?Client=nunit&Password=pass")] [TestCase("host:1?db=2", "host:1?Db=2")] [TestCase("host?ssl=true", "host:6380?Ssl=true")] [TestCase("host:1?ssl=true", "host:1?Ssl=true")] [TestCase("host:1?connectTimeout=1&sendtimeout=2&receiveTimeout=3&idletimeoutsecs=4", "host:1?ConnectTimeout=1&SendTimeout=2&ReceiveTimeout=3&IdleTimeOutSecs=4")] [TestCase("redis://nunit:pass@host:1?ssl=true&db=1&connectTimeout=2&sendtimeout=3&receiveTimeout=4&idletimeoutsecs=5&NamespacePrefix=prefix.", "host:1?Client=nunit&Password=pass&Db=1&Ssl=true&ConnectTimeout=2&SendTimeout=3&ReceiveTimeout=4&IdleTimeOutSecs=5&NamespacePrefix=prefix.")] [TestCase("password@host:6380?ssl=true&sslprotocols=Tls12", "host:6380?Password=password&Ssl=true&SslProtocols=Tls12")] public void Does_Serialize_RedisEndpoint(string connString, string expectedString) { var actual = connString.ToRedisEndpoint(); Assert.That(actual.ToString(), Is.EqualTo(expectedString)); } [Test] public void Does_set_all_properties_on_Client_using_ClientsManagers() { var connStr = "redis://nunit:pass@host:1?ssl=true&sslprotocols=Tls12&db=0&connectTimeout=2&sendtimeout=3&receiveTimeout=4&idletimeoutsecs=5&NamespacePrefix=prefix."; var expected = "{Host:host,Port:1,Ssl:True,SslProtocols:Tls12,Client:nunit,Password:pass,Db:0,ConnectTimeout:2,SendTimeout:3,ReceiveTimeout:4,IdleTimeOutSecs:5,NamespacePrefix:prefix.}" .FromJsv<RedisEndpoint>(); using (var pooledManager = new RedisManagerPool(connStr)) { AssertClientManager(pooledManager, expected); } using (var pooledManager = new PooledRedisClientManager(connStr)) { AssertClientManager(pooledManager, expected); } using (var basicManager = new BasicRedisClientManager(connStr)) { AssertClientManager(basicManager, expected); } } [Test] public void Does_encode_values_when_serializing_to_ConnectionString() { var config = new RedisEndpoint { Host = "host", Port = 1, Password = "p@55W0rd=" }; var connString = config.ToString(); Assert.That(connString, Is.EqualTo("host:1?Password=p%4055W0rd%3d")); var fromConfig = connString.ToRedisEndpoint(); Assert.That(fromConfig.Host, Is.EqualTo(config.Host)); Assert.That(fromConfig.Port, Is.EqualTo(config.Port)); Assert.That(fromConfig.Password, Is.EqualTo(config.Password)); } private static void AssertClientManager(IRedisClientsManager redisManager, RedisEndpoint expected) { using (var readWrite = (RedisClient)redisManager.GetClient()) using (var readOnly = (RedisClient)redisManager.GetReadOnlyClient()) using (var cacheClientWrapper = (RedisClientManagerCacheClient)redisManager.GetCacheClient()) { AssertClient(readWrite, expected); AssertClient(readOnly, expected); using (var cacheClient = (RedisClient)cacheClientWrapper.GetClient()) { AssertClient(cacheClient, expected); } } } private static void AssertClient(RedisClient redis, RedisEndpoint expected) { Assert.That(redis.Host, Is.EqualTo(expected.Host)); Assert.That(redis.Port, Is.EqualTo(expected.Port)); Assert.That(redis.Ssl, Is.EqualTo(expected.Ssl)); Assert.That(redis.SslProtocols, Is.EqualTo(expected.SslProtocols)); Assert.That(redis.Client, Is.EqualTo(expected.Client)); Assert.That(redis.Password, Is.EqualTo(expected.Password)); Assert.That(redis.Db, Is.EqualTo(expected.Db)); Assert.That(redis.ConnectTimeout, Is.EqualTo(expected.ConnectTimeout)); Assert.That(redis.SendTimeout, Is.EqualTo(expected.SendTimeout)); Assert.That(redis.ReceiveTimeout, Is.EqualTo(expected.ReceiveTimeout)); Assert.That(redis.RetryTimeout, Is.EqualTo(expected.RetryTimeout)); Assert.That(redis.IdleTimeOutSecs, Is.EqualTo(expected.IdleTimeOutSecs)); Assert.That(redis.NamespacePrefix, Is.EqualTo(expected.NamespacePrefix)); } [Test] public void Does_set_Client_name_on_Connection() { using (var redis = new RedisClient(TestConfig.SingleHost + "?Client=nunit")) { var clientName = redis.GetClient(); Assert.That(clientName, Is.EqualTo("nunit")); } } [Test] public void Does_set_Client_on_Pooled_Connection() { using (var redisManager = new PooledRedisClientManager(TestConfig.SingleHost + "?Client=nunit")) using (var redis = redisManager.GetClient()) { var clientName = redis.GetClient(); Assert.That(clientName, Is.EqualTo("nunit")); } } }
原文：https://www.cnblogs.com/xyyhcn/p/11612724.html