public async Task Can_ZRangeByLex_Min_and_Max() { var range = await NativeAsync.ZRangeByLexAsync("zset", "[aaa", "(g"); Assert.That(range.Map(x => x.FromUtf8Bytes()), Is.EquivalentTo(new[] { "b", "c", "d", "e", "f" })); }
public async Task Transaction_can_be_replayed() { string KeySquared = Key + Key; Assert.That(await RedisAsync.GetValueAsync(Key), Is.Null); Assert.That(await RedisAsync.GetValueAsync(KeySquared), Is.Null); await using var trans = await RedisAsync.CreateTransactionAsync(); trans.QueueCommand(r => r.IncrementValueAsync(Key)); trans.QueueCommand(r => r.IncrementValueAsync(KeySquared)); await trans.CommitAsync(); Assert.That(await RedisAsync.GetValueAsync(Key), Is.EqualTo("1")); Assert.That(await RedisAsync.GetValueAsync(KeySquared), Is.EqualTo("1")); await NativeAsync.DelAsync(Key); await NativeAsync.DelAsync(KeySquared); Assert.That(await RedisAsync.GetValueAsync(Key), Is.Null); Assert.That(await RedisAsync.GetValueAsync(KeySquared), Is.Null); await trans.ReplayAsync(); await trans.DisposeAsync(); Assert.That(await RedisAsync.GetValueAsync(Key), Is.EqualTo("1")); Assert.That(await RedisAsync.GetValueAsync(KeySquared), Is.EqualTo("1")); }
public async Task Can_scan_100_collection_over_cursor() { var allKeys = new HashSet <string>(); await RedisAsync.FlushAllAsync(); var keys = 100.Times(x => "KEY" + x); await RedisAsync.SetAllAsync(keys.ToSafeDictionary(x => x)); var i = 0; var ret = new ScanResult(); while (true) { ret = await NativeAsync.ScanAsync(ret.Cursor, 10); i++; ret.AsStrings().ForEach(x => allKeys.Add(x)); if (ret.Cursor == 0) { break; } } Assert.That(i, Is.GreaterThanOrEqualTo(2)); Assert.That(allKeys.Count, Is.EqualTo(keys.Count)); Assert.That(allKeys, Is.EquivalentTo(keys)); }
public virtual async Task TearDown() { foreach (var t in await RedisAsync.SearchKeysAsync(RedisRaw.NamespacePrefix + "*")) { await NativeAsync.DelAsync(t); } }
public async Task Pipeline_can_be_replayed() { string KeySquared = Key + Key; Assert.That(await RedisAsync.GetValueAsync(Key), Is.Null); Assert.That(await RedisAsync.GetValueAsync(KeySquared), Is.Null); await using var pipeline = RedisAsync.CreatePipeline(); pipeline.QueueCommand(r => r.IncrementValueAsync(Key)); pipeline.QueueCommand(r => r.IncrementValueAsync(KeySquared)); await pipeline.FlushAsync(); Assert.That(await RedisAsync.GetValueAsync(Key), Is.EqualTo("1")); Assert.That(await RedisAsync.GetValueAsync(KeySquared), Is.EqualTo("1")); await NativeAsync.DelAsync(Key); await NativeAsync.DelAsync(KeySquared); Assert.That(await RedisAsync.GetValueAsync(Key), Is.Null); Assert.That(await RedisAsync.GetValueAsync(KeySquared), Is.Null); await pipeline.ReplayAsync(); await pipeline.DisposeAsync(); Assert.That(await RedisAsync.GetValueAsync(Key), Is.EqualTo("1")); Assert.That(await RedisAsync.GetValueAsync(KeySquared), Is.EqualTo("1")); }
public async Task Can_Quit() { await NativeAsync.QuitAsync(); RedisRaw.NamespacePrefix = null; CleanMask = null; }
public async Task SetUp() { await RedisAsync.FlushAllAsync(); foreach (var x in values) { await NativeAsync.ZAddAsync("zset", 0, x.ToUtf8Bytes()); } }
public async Task Can_RenameKey() { await RedisAsync.SetValueAsync("oldkey", "val"); await NativeAsync.RenameAsync("oldkey", "newkey"); Assert.That(await RedisAsync.ContainsKeyAsync("oldkey"), Is.False); Assert.That(await RedisAsync.ContainsKeyAsync("newkey"), Is.True); }
public async Task Can_ZlexCount() { var total = await NativeAsync.ZLexCountAsync("zset", "-", "+"); Assert.That(total, Is.EqualTo(values.Length)); Assert.That(await NativeAsync.ZLexCountAsync("zset", "-", "[c"), Is.EqualTo(3)); Assert.That(await NativeAsync.ZLexCountAsync("zset", "-", "(c"), Is.EqualTo(2)); }
public async Task Can_SetBit_And_GetBit_And_BitCount() { const string key = "BitKey"; const int offset = 100; await NativeAsync.SetBitAsync(key, offset, 1); Assert.AreEqual(1, await NativeAsync.GetBitAsync(key, offset)); Assert.AreEqual(1, await NativeAsync.BitCountAsync(key)); }
public async Task Can_hash_set() { var key = HashId + "key"; var field = GetBytes("foo"); var value = GetBytes("value"); Assert.AreEqual(await NativeAsync.HDelAsync(key, field), 0); Assert.AreEqual(await NativeAsync.HSetAsync(key, field, value), 1); Assert.AreEqual(await NativeAsync.HDelAsync(key, field), 1); }
public async Task Can_ZRangeByLex_all_entries() { var results = await NativeAsync.ZRangeByLexAsync("zset", "-", "+"); Assert.That(results.Map(x => x.FromUtf8Bytes()), Is.EquivalentTo(values)); results = await NativeAsync.ZRangeByLexAsync("zset", "-", "+", 1, 3); Assert.That(results.Map(x => x.FromUtf8Bytes()), Is.EquivalentTo(new[] { "b", "c", "d" })); }
public async Task Can_ZRangeByLex_Desc() { var descInclusive = await NativeAsync.ZRangeByLexAsync("zset", "-", "[c"); Assert.That(descInclusive.Map(x => x.FromUtf8Bytes()), Is.EquivalentTo(new[] { "a", "b", "c" })); var descExclusive = await NativeAsync.ZRangeByLexAsync("zset", "-", "(c"); Assert.That(descExclusive.Map(x => x.FromUtf8Bytes()), Is.EquivalentTo(new[] { "a", "b" })); }
public async Task Can_ZRemRangeByLex() { var removed = await NativeAsync.ZRemRangeByLexAsync("zset", "[aaa", "(g"); Assert.That(removed, Is.EqualTo(5)); var remainder = await NativeAsync.ZRangeByLexAsync("zset", "-", "+"); Assert.That(remainder.Map(x => x.FromUtf8Bytes()), Is.EqualTo(new[] { "a", "g" })); }
public async Task Can_Set_and_Get_key_with_space() { await RedisAsync.SetValueAsync("key with space", Value); var valueBytes = await NativeAsync.GetAsync("key with space"); var valueString = GetString(valueBytes); await RedisAsync.RemoveAsync("key with space"); Assert.That(valueString, Is.EqualTo(Value)); }
public async Task Can_scan_and_search_10_collection() { await RedisAsync.FlushAllAsync(); var keys = 11.Times(x => "KEY" + x); await RedisAsync.SetAllAsync(keys.ToSafeDictionary(x => x)); var ret = await NativeAsync.ScanAsync(0, 11, match : "KEY1*"); Assert.That(ret.Cursor, Is.GreaterThanOrEqualTo(0)); Assert.That(ret.AsStrings(), Is.EquivalentTo(new[] { "KEY1", "KEY10" })); }
public async Task Can_scan_10_collection() { await RedisAsync.FlushAllAsync(); var keys = 10.Times(x => "KEY" + x); await RedisAsync.SetAllAsync(keys.ToSafeDictionary(x => x)); var ret = await NativeAsync.ScanAsync(0); Assert.That(ret.Cursor, Is.GreaterThanOrEqualTo(0)); Assert.That(ret.AsStrings(), Is.EquivalentTo(keys)); }
public async Task Can_SScan_10_sets() { await RedisAsync.FlushAllAsync(); var items = 10.Times(x => "item" + x); await items.ForEachAsync(async x => await RedisAsync.AddItemToSetAsync("scanset", x)); var ret = await NativeAsync.SScanAsync("scanset", 0); Assert.That(ret.Cursor, Is.GreaterThanOrEqualTo(0)); Assert.That(ret.AsStrings(), Is.EquivalentTo(items)); }
public async Task Can_Set_and_Get_key_with_spaces() { const string key = "key with spaces"; await RedisAsync.SetValueAsync(key, Value); var valueBytes = await NativeAsync.GetAsync(key); var valueString = GetString(valueBytes); Assert.That(valueString, Is.EqualTo(Value)); }
public async Task Can_get_Role_Info() { var result = await NativeAsync.RoleAsync(); result.PrintDump(); Assert.That(result.Children[0].Text, Is.EqualTo("master")); Assert.That(await RedisAsync.GetServerRoleAsync(), Is.EqualTo(RedisServerRole.Master)); //needs redis-server v3.0 //var replica = new RedisClient("10.0.0.9:6380"); //result = replica.Role(); //result.PrintDump(); }
public async Task Can_GetRange() { const string helloWorld = "Hello, World!"; await RedisAsync.SetValueAsync("key", helloWorld); var fromIndex = "Hello, ".Length; var toIndex = "Hello, World".Length - 1; var expectedString = helloWorld.Substring(fromIndex, toIndex - fromIndex + 1); var world = await NativeAsync.GetRangeAsync("key", fromIndex, toIndex); Assert.That(world.Length, Is.EqualTo(expectedString.Length)); }
public async Task Can_ExpireAt() { await RedisAsync.SetValueAsync("key", "val"); var unixNow = DateTime.Now.ToUnixTime(); var in2Secs = unixNow + 2; await NativeAsync.ExpireAtAsync("key", in2Secs); Assert.That(await RedisAsync.ContainsKeyAsync("key"), Is.True); await Task.Delay(3000); Assert.That(await RedisAsync.ContainsKeyAsync("key"), Is.False); }
public async Task Can_HScan_10_hashes() { await RedisAsync.FlushAllAsync(); var values = 10.Times(x => "VALUE" + x); await RedisAsync.SetRangeInHashAsync("scanhash", values.ToSafeDictionary(x => x.Replace("VALUE", "KEY"))); var ret = await NativeAsync.HScanAsync("scanhash", 0); var keyValues = ret.AsKeyValues(); Assert.That(ret.Cursor, Is.GreaterThanOrEqualTo(0)); Assert.That(keyValues.Keys, Is.EquivalentTo(values.ConvertAll(x => x.Replace("VALUE", "KEY")))); Assert.That(keyValues.Values, Is.EquivalentTo(values)); }
public async Task Can_ZScan_10_sortedsets() { await RedisAsync.FlushAllAsync(); var items = 10.Times(x => "item" + x); var i = 0; await items.ForEachAsync(async x => await RedisAsync.AddItemToSortedSetAsync("scanzset", x, i++)); var ret = await NativeAsync.ZScanAsync("scanzset", 0); var itemsWithScore = ret.AsItemsWithScores(); Assert.That(itemsWithScore.Keys, Is.EqualTo(items)); Assert.That(itemsWithScore.Values, Is.EqualTo(10.Times(x => (double)x))); }
public async Task 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; } await RedisAsync.SetAsync(key, value); var resultValue = await NativeAsync.GetAsync(key); Assert.That(resultValue, Is.EquivalentTo(value)); }
public async Task Can_get_Keys_with_pattern() { for (int i = 0; i < 5; i++) { await RedisAsync.SetValueAsync("k1:" + i, "val"); } for (int i = 0; i < 5; i++) { await RedisAsync.SetValueAsync("k2:" + i, "val"); } var keys = await NativeAsync.KeysAsync("k1:*"); Assert.That(keys.Length, Is.EqualTo(5)); var scanKeys = await RedisAsync.SearchKeysAsync("k1:*"); Assert.That(scanKeys.Count, Is.EqualTo(5)); }
public async Task Can_BgSave() { try { await NativeAsync.BgSaveAsync(); } 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") || e.Message.StartsWith("Another child process is active (AOF?): can't BGSAVE right now")) { return; } throw; } }
public async Task Transaction_can_issue_watch() { await NativeAsync.DelAsync(Key); Assert.That(await RedisAsync.GetValueAsync(Key), Is.Null); string KeySquared = Key + Key; await NativeAsync.DelAsync(KeySquared); await RedisAsync.WatchAsync(new[] { Key, KeySquared }); await RedisAsync.SetAsync(Key, 7); await using (var trans = await RedisAsync.CreateTransactionAsync()) { trans.QueueCommand(r => r.SetAsync(Key, 1).AsValueTask()); trans.QueueCommand(r => r.SetAsync(KeySquared, 2).AsValueTask()); await trans.CommitAsync(); } Assert.That(await RedisAsync.GetValueAsync(Key), Is.EqualTo("7")); Assert.That(await RedisAsync.GetValueAsync(KeySquared), Is.Null); }
public async Task Can_BgRewriteAof() { await NativeAsync.BgRewriteAofAsync(); }
public async Task Can_SlaveOfNoOne() { await NativeAsync.SlaveOfNoOneAsync(); }