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();
}
