public void Can_scan_100_collection_over_cursor()
{
var allKeys = new HashSet <string>();
Redis.FlushAll();
var keys = 100.Times(x => "KEY" + x);
Redis.SetAll(keys.ToSafeDictionary(x => x));
var i = 0;
var ret = new ScanResult();
while (true)
{
ret = Redis.Scan(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 void Can_send_complex_types_in_Custom_Commands()
{
Redis.FlushAll();
RedisText ret;
ret = Redis.Custom("SET", "foo", new Poco {
Name = "Bar"
});
Assert.That(ret.Text, Is.EqualTo("OK"));
ret = Redis.Custom("GET", "foo");
var dto = ret.GetResult <Poco>();
Assert.That(dto.Name, Is.EqualTo("Bar"));
Enum.GetNames(typeof(DayOfWeek)).ToList()
.ForEach(x => Redis.Custom("RPUSH", "DaysOfWeek", new Poco {
Name = x
}));
ret = Redis.Custom("LRANGE", "DaysOfWeek", 1, -2);
var weekDays = ret.GetResults <Poco>();
Assert.That(weekDays.First().Name, Is.EqualTo("Monday"));
ret.PrintDump();
}
public void Can_SScan_10_sets()
{
Redis.FlushAll();
var items = 10.Times(x => "item" + x);
items.ForEach(x => Redis.AddItemToSet("scanset", x));
var ret = Redis.SScan("scanset", 0);
Assert.That(ret.Cursor, Is.GreaterThanOrEqualTo(0));
Assert.That(ret.AsStrings(), Is.EquivalentTo(items));
}
public void Can_scan_and_search_10_collection()
{
Redis.FlushAll();
var keys = 11.Times(x => "KEY" + x);
Redis.SetAll(keys.ToSafeDictionary(x => x));
var ret = Redis.Scan(0, 11, match: "KEY1*");
Assert.That(ret.Cursor, Is.GreaterThanOrEqualTo(0));
Assert.That(ret.AsStrings(), Is.EquivalentTo(new[] { "KEY1", "KEY10" }));
}
public void Can_scan_10_collection()
{
Redis.FlushAll();
var keys = 10.Times(x => "KEY" + x);
Redis.SetAll(keys.ToSafeDictionary(x => x));
var ret = Redis.Scan(0);
Assert.That(ret.Cursor, Is.GreaterThanOrEqualTo(0));
Assert.That(ret.AsStrings(), Is.EquivalentTo(keys));
}
public void Can_ZScan_10_sortedsets()
{
Redis.FlushAll();
var items = 10.Times(x => "item" + x);
var i = 0;
items.ForEach(x => Redis.AddItemToSortedSet("scanzset", x, i++));
var ret = Redis.ZScan("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 void Does_lazy_scan_all_set_items()
{
Redis.FlushAll();
var items = 100.Times(x => "item" + x);
items.ForEach(x => Redis.AddItemToSet("scanset", x));
var scanAllItems = Redis.ScanAllSetItems("scanset", pageSize: 10);
var tenKeys = scanAllItems.Take(10).ToList();
Assert.That(tenKeys.Count, Is.EqualTo(10));
Assert.That(scanAllItems.Count(), Is.EqualTo(100));
}
public void Does_lazy_scan_all_keys()
{
Redis.FlushAll();
var keys = 100.Times(x => "KEY" + x);
Redis.SetAll(keys.ToSafeDictionary(x => x));
var scanAllKeys = Redis.ScanAllKeys(pageSize: 10);
var tenKeys = scanAllKeys.Take(10).ToList();
Assert.That(tenKeys.Count, Is.EqualTo(10));
Assert.That(scanAllKeys.Count(), Is.EqualTo(100));
}
public void Can_HScan_10_hashes()
{
Redis.FlushAll();
var values = 10.Times(x => "VALUE" + x);
Redis.SetRangeInHash("scanhash", values.ToSafeDictionary(x => x.Replace("VALUE", "KEY")));
var ret = Redis.HScan("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 void Does_lazy_scan_all_hash_items()
{
Redis.FlushAll();
var values = 100.Times(x => "VALUE" + x);
Redis.SetRangeInHash("scanhash", values.ToSafeDictionary(x => x.Replace("VALUE", "KEY")));
var scanAllItems = Redis.ScanAllHashEntries("scanhash", pageSize: 10);
var tenKeys = scanAllItems.Take(10).ToList();
Assert.That(tenKeys.Count, Is.EqualTo(10));
Assert.That(scanAllItems.Count(), Is.EqualTo(100));
var map = scanAllItems.ToDictionary(x => x.Key, x => x.Value);
Assert.That(map.Values, Is.EquivalentTo(values));
}
public void Does_lazy_scan_all_sortedset_items()
{
Redis.FlushAll();
var items = 100.Times(x => "item" + x);
var i = 0;
items.ForEach(x => Redis.AddItemToSortedSet("scanzset", x, i++));
var scanAllItems = Redis.ScanAllSortedSetItems("scanzset", pageSize: 10);
var tenKeys = scanAllItems.Take(10).ToList();
Assert.That(tenKeys.Count, Is.EqualTo(10));
Assert.That(scanAllItems.Count(), Is.EqualTo(100));
var map = scanAllItems.ToDictionary(x => x.Key, x => x.Value);
Assert.That(map.Keys, Is.EquivalentTo(items));
}
public void Any(Reset request)
{
var fullReset = request.Level == null || request.Level == "full";
if (fullReset || request.Level == "db")
{
Db.DropAndCreateTable <World>();
var worlds = 10000.Times(i => new World {
id = i, randomNumber = rand.Next(0, 10000) + 1
});
Db.InsertAll(worlds);
if (TryResolve <IRedisClientsManager>() != null)
{
Redis.FlushAll();
Redis.StoreAll(worlds);
}
Db.DropAndCreateTable <Fortune>();
new[] {
"A budget is just a method of worrying before you spend money, as well as afterward.",
"A classic is something that everybody wants to have read and nobody wants to read.",
"A conclusion is simply the place where someone got tired of thinking.",
"A diplomat is someone who can tell you to go to hell in such a way that you will look forward to the trip.",
"A psychiatrist is a person who will give you expensive answers that your wife will give you for free.",
}.Each(x => Db.Insert(new Fortune {
message = x
}));
}
if (fullReset || request.Level == "gc")
{
GC.Collect();
}
if (fullReset || request.Level == "pause")
{
Thread.Sleep(2000);
}
}
public void Can_send_custom_commands()
{
Redis.FlushAll();
RedisText ret;
ret = Redis.Custom("SET", "foo", 1);
Assert.That(ret.Text, Is.EqualTo("OK"));
ret = Redis.Custom(Commands.Set, "bar", "b");
ret = Redis.Custom("GET", "foo");
Assert.That(ret.Text, Is.EqualTo("1"));
ret = Redis.Custom(Commands.Get, "bar");
Assert.That(ret.Text, Is.EqualTo("b"));
ret = Redis.Custom(Commands.Keys, "*");
var keys = ret.GetResults();
Assert.That(keys, Is.EquivalentTo(new[] { "foo", "bar" }));
ret = Redis.Custom("MGET", "foo", "bar");
var values = ret.GetResults();
Assert.That(values, Is.EquivalentTo(new[] { "1", "b" }));
Enum.GetNames(typeof(DayOfWeek)).ToList()
.ForEach(x => Redis.Custom("RPUSH", "DaysOfWeek", x));
ret = Redis.Custom("LRANGE", "DaysOfWeek", 1, -2);
var weekDays = ret.GetResults();
Assert.That(weekDays, Is.EquivalentTo(
new[] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" }));
ret.PrintDump();
}
public static void RedisFlushAll()
{
Redis.FlushAll();
}
public void SetUp()
{
Redis.FlushAll();
values.Each(x => Redis.ZAdd("zset", 0, x.ToUtf8Bytes()));
}
public object Any(FlushAll request)
{
Redis.FlushAll();
return(new FlushAllResponse());
}