Skip to content

S
StackExchange.Redis
Commit c72ffa84 authored by Marc Gravell's avatar Marc Gravell
Browse files
Options

mark HighPriority as [Obsolete]; more releaes note updates

parent 135bd613
Hide whitespace changes
Inline Side-by-side
Showing with 585 additions and 582 deletions
docs/ReleaseNotes.md
View file @ c72ffa84
......@@ -15,12 +15,14 @@
the `Subscribe` method has a new overload *without* a handler parameter which returns a `ChannelMessageQueue`, which provides `async` ordered access to messsages)
- internal: the network architecture has moved to use `System.IO.Pipelines`; this has allowed us to simplify and unify a lot of the network code, and in particular
fix a lot of problems relating to how the library worked with TLS and/or .NETStandard
- change: as a result of the `System.IO.Pipelines` change, the error-reporting on timeouts is now much simpler and clearer; the [timeouts documentation](Timeouts.md) has been updated
- removed: the `HighPriority` (queue-jumping) flag is now deprecated
- internal: most buffers internally now make use of pooled memory; `RedisValue` no longer pre-emptively allocates buffers
- added: asynchronous operations now have full support for reporting timeouts
- added: new APIs now exist to work with pooled memory without allocations - `RedisValue.CreateFrom(MemoryStream)` and `operator` support for `Memory<byte>` and `ReadOnlyMemory<byte>`; and `IDatabase.StringGetLease[Async](...)`, `IDatabase.HashGetLease[Async](...)`, `Lease<byte>.AsStream()`)
- added: ["streams"](https://redis.io/topics/streams-intro) support (thanks to [ttingen](https://github.com/ttingen) for their contribution)
- various missing commands / overloads have been added
- a *lot* of general bugs and issues have been resolved
- fix: a *lot* of general bugs and issues have been resolved
a more complete list of issues addressed can be seen in [this tracking issue](https://github.com/StackExchange/StackExchange.Redis/issues/871)
......
src/StackExchange.Redis/Enums/CommandFlags.cs
View file @ c72ffa84
......@@ -12,10 +12,11 @@ public enum CommandFlags
/// Default behaviour.
/// </summary>
None = 0,
/// <summary>
/// From 2.0, this flag is not used
/// </summary>
// [Obsolete("From 2.0, this flag is not used", false)]
[Obsolete("From 2.0, this flag is not used", false)]
HighPriority = 1,
/// <summary>
/// The caller is not interested in the result; the caller will immediately receive a default-value
......
tests/StackExchange.Redis.Tests/DatabaseWrapperTests.cs
View file @ c72ffa84
......@@ -47,8 +47,8 @@ public void CreateTransaction()
[Fact]
public void DebugObject()
{
wrapper.DebugObject("key", CommandFlags.HighPriority);
mock.Verify(_ => _.DebugObject("prefix:key", CommandFlags.HighPriority));
wrapper.DebugObject("key", CommandFlags.None);
mock.Verify(_ => _.DebugObject("prefix:key", CommandFlags.None));
}
[Fact]
......@@ -61,145 +61,145 @@ public void Get_Database()
[Fact]
public void HashDecrement_1()
{
wrapper.HashDecrement("key", "hashField", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.HashDecrement("prefix:key", "hashField", 123, CommandFlags.HighPriority));
wrapper.HashDecrement("key", "hashField", 123, CommandFlags.None);
mock.Verify(_ => _.HashDecrement("prefix:key", "hashField", 123, CommandFlags.None));
}
[Fact]
public void HashDecrement_2()
{
wrapper.HashDecrement("key", "hashField", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.HashDecrement("prefix:key", "hashField", 1.23, CommandFlags.HighPriority));
wrapper.HashDecrement("key", "hashField", 1.23, CommandFlags.None);
mock.Verify(_ => _.HashDecrement("prefix:key", "hashField", 1.23, CommandFlags.None));
}
[Fact]
public void HashDelete_1()
{
wrapper.HashDelete("key", "hashField", CommandFlags.HighPriority);
mock.Verify(_ => _.HashDelete("prefix:key", "hashField", CommandFlags.HighPriority));
wrapper.HashDelete("key", "hashField", CommandFlags.None);
mock.Verify(_ => _.HashDelete("prefix:key", "hashField", CommandFlags.None));
}
[Fact]
public void HashDelete_2()
{
RedisValue[] hashFields = new RedisValue[0];
wrapper.HashDelete("key", hashFields, CommandFlags.HighPriority);
mock.Verify(_ => _.HashDelete("prefix:key", hashFields, CommandFlags.HighPriority));
wrapper.HashDelete("key", hashFields, CommandFlags.None);
mock.Verify(_ => _.HashDelete("prefix:key", hashFields, CommandFlags.None));
}
[Fact]
public void HashExists()
{
wrapper.HashExists("key", "hashField", CommandFlags.HighPriority);
mock.Verify(_ => _.HashExists("prefix:key", "hashField", CommandFlags.HighPriority));
wrapper.HashExists("key", "hashField", CommandFlags.None);
mock.Verify(_ => _.HashExists("prefix:key", "hashField", CommandFlags.None));
}
[Fact]
public void HashGet_1()
{
wrapper.HashGet("key", "hashField", CommandFlags.HighPriority);
mock.Verify(_ => _.HashGet("prefix:key", "hashField", CommandFlags.HighPriority));
wrapper.HashGet("key", "hashField", CommandFlags.None);
mock.Verify(_ => _.HashGet("prefix:key", "hashField", CommandFlags.None));
}
[Fact]
public void HashGet_2()
{
RedisValue[] hashFields = new RedisValue[0];
wrapper.HashGet("key", hashFields, CommandFlags.HighPriority);
mock.Verify(_ => _.HashGet("prefix:key", hashFields, CommandFlags.HighPriority));
wrapper.HashGet("key", hashFields, CommandFlags.None);
mock.Verify(_ => _.HashGet("prefix:key", hashFields, CommandFlags.None));
}
[Fact]
public void HashGetAll()
{
wrapper.HashGetAll("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HashGetAll("prefix:key", CommandFlags.HighPriority));
wrapper.HashGetAll("key", CommandFlags.None);
mock.Verify(_ => _.HashGetAll("prefix:key", CommandFlags.None));
}
[Fact]
public void HashIncrement_1()
{
wrapper.HashIncrement("key", "hashField", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.HashIncrement("prefix:key", "hashField", 123, CommandFlags.HighPriority));
wrapper.HashIncrement("key", "hashField", 123, CommandFlags.None);
mock.Verify(_ => _.HashIncrement("prefix:key", "hashField", 123, CommandFlags.None));
}
[Fact]
public void HashIncrement_2()
{
wrapper.HashIncrement("key", "hashField", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.HashIncrement("prefix:key", "hashField", 1.23, CommandFlags.HighPriority));
wrapper.HashIncrement("key", "hashField", 1.23, CommandFlags.None);
mock.Verify(_ => _.HashIncrement("prefix:key", "hashField", 1.23, CommandFlags.None));
}
[Fact]
public void HashKeys()
{
wrapper.HashKeys("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HashKeys("prefix:key", CommandFlags.HighPriority));
wrapper.HashKeys("key", CommandFlags.None);
mock.Verify(_ => _.HashKeys("prefix:key", CommandFlags.None));
}
[Fact]
public void HashLength()
{
wrapper.HashLength("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HashLength("prefix:key", CommandFlags.HighPriority));
wrapper.HashLength("key", CommandFlags.None);
mock.Verify(_ => _.HashLength("prefix:key", CommandFlags.None));
}
[Fact]
public void HashScan()
{
wrapper.HashScan("key", "pattern", 123, flags: CommandFlags.HighPriority);
mock.Verify(_ => _.HashScan("prefix:key", "pattern", 123, 0, 0, CommandFlags.HighPriority));
wrapper.HashScan("key", "pattern", 123, flags: CommandFlags.None);
mock.Verify(_ => _.HashScan("prefix:key", "pattern", 123, 0, 0, CommandFlags.None));
}
[Fact]
public void HashSet_1()
{
HashEntry[] hashFields = new HashEntry[0];
wrapper.HashSet("key", hashFields, CommandFlags.HighPriority);
mock.Verify(_ => _.HashSet("prefix:key", hashFields, CommandFlags.HighPriority));
wrapper.HashSet("key", hashFields, CommandFlags.None);
mock.Verify(_ => _.HashSet("prefix:key", hashFields, CommandFlags.None));
}
[Fact]
public void HashSet_2()
{
wrapper.HashSet("key", "hashField", "value", When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.HashSet("prefix:key", "hashField", "value", When.Exists, CommandFlags.HighPriority));
wrapper.HashSet("key", "hashField", "value", When.Exists, CommandFlags.None);
mock.Verify(_ => _.HashSet("prefix:key", "hashField", "value", When.Exists, CommandFlags.None));
}
[Fact]
public void HashValues()
{
wrapper.HashValues("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HashValues("prefix:key", CommandFlags.HighPriority));
wrapper.HashValues("key", CommandFlags.None);
mock.Verify(_ => _.HashValues("prefix:key", CommandFlags.None));
}
[Fact]
public void HyperLogLogAdd_1()
{
wrapper.HyperLogLogAdd("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogAdd("prefix:key", "value", CommandFlags.HighPriority));
wrapper.HyperLogLogAdd("key", "value", CommandFlags.None);
mock.Verify(_ => _.HyperLogLogAdd("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void HyperLogLogAdd_2()
{
RedisValue[] values = new RedisValue[0];
wrapper.HyperLogLogAdd("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogAdd("prefix:key", values, CommandFlags.HighPriority));
wrapper.HyperLogLogAdd("key", values, CommandFlags.None);
mock.Verify(_ => _.HyperLogLogAdd("prefix:key", values, CommandFlags.None));
}
[Fact]
public void HyperLogLogLength()
{
wrapper.HyperLogLogLength("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogLength("prefix:key", CommandFlags.HighPriority));
wrapper.HyperLogLogLength("key", CommandFlags.None);
mock.Verify(_ => _.HyperLogLogLength("prefix:key", CommandFlags.None));
}
[Fact]
public void HyperLogLogMerge_1()
{
wrapper.HyperLogLogMerge("destination", "first", "second", CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogMerge("prefix:destination", "prefix:first", "prefix:second", CommandFlags.HighPriority));
wrapper.HyperLogLogMerge("destination", "first", "second", CommandFlags.None);
mock.Verify(_ => _.HyperLogLogMerge("prefix:destination", "prefix:first", "prefix:second", CommandFlags.None));
}
[Fact]
......@@ -207,22 +207,22 @@ public void HyperLogLogMerge_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.HyperLogLogMerge("destination", keys, CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogMerge("prefix:destination", It.Is(valid), CommandFlags.HighPriority));
wrapper.HyperLogLogMerge("destination", keys, CommandFlags.None);
mock.Verify(_ => _.HyperLogLogMerge("prefix:destination", It.Is(valid), CommandFlags.None));
}
[Fact]
public void IdentifyEndpoint()
{
wrapper.IdentifyEndpoint("key", CommandFlags.HighPriority);
mock.Verify(_ => _.IdentifyEndpoint("prefix:key", CommandFlags.HighPriority));
wrapper.IdentifyEndpoint("key", CommandFlags.None);
mock.Verify(_ => _.IdentifyEndpoint("prefix:key", CommandFlags.None));
}
[Fact]
public void KeyDelete_1()
{
wrapper.KeyDelete("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyDelete("prefix:key", CommandFlags.HighPriority));
wrapper.KeyDelete("key", CommandFlags.None);
mock.Verify(_ => _.KeyDelete("prefix:key", CommandFlags.None));
}
[Fact]
......@@ -230,60 +230,60 @@ public void KeyDelete_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.KeyDelete(keys, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyDelete(It.Is(valid), CommandFlags.HighPriority));
wrapper.KeyDelete(keys, CommandFlags.None);
mock.Verify(_ => _.KeyDelete(It.Is(valid), CommandFlags.None));
}
[Fact]
public void KeyDump()
{
wrapper.KeyDump("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyDump("prefix:key", CommandFlags.HighPriority));
wrapper.KeyDump("key", CommandFlags.None);
mock.Verify(_ => _.KeyDump("prefix:key", CommandFlags.None));
}
[Fact]
public void KeyExists()
{
wrapper.KeyExists("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyExists("prefix:key", CommandFlags.HighPriority));
wrapper.KeyExists("key", CommandFlags.None);
mock.Verify(_ => _.KeyExists("prefix:key", CommandFlags.None));
}
[Fact]
public void KeyExpire_1()
{
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.KeyExpire("key", expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyExpire("prefix:key", expiry, CommandFlags.HighPriority));
wrapper.KeyExpire("key", expiry, CommandFlags.None);
mock.Verify(_ => _.KeyExpire("prefix:key", expiry, CommandFlags.None));
}
[Fact]
public void KeyExpire_2()
{
DateTime expiry = DateTime.Now;
wrapper.KeyExpire("key", expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyExpire("prefix:key", expiry, CommandFlags.HighPriority));
wrapper.KeyExpire("key", expiry, CommandFlags.None);
mock.Verify(_ => _.KeyExpire("prefix:key", expiry, CommandFlags.None));
}
[Fact]
public void KeyMigrate()
{
EndPoint toServer = new IPEndPoint(IPAddress.Loopback, 123);
wrapper.KeyMigrate("key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyMigrate("prefix:key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.HighPriority));
wrapper.KeyMigrate("key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.None);
mock.Verify(_ => _.KeyMigrate("prefix:key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.None));
}
[Fact]
public void KeyMove()
{
wrapper.KeyMove("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyMove("prefix:key", 123, CommandFlags.HighPriority));
wrapper.KeyMove("key", 123, CommandFlags.None);
mock.Verify(_ => _.KeyMove("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void KeyPersist()
{
wrapper.KeyPersist("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyPersist("prefix:key", CommandFlags.HighPriority));
wrapper.KeyPersist("key", CommandFlags.None);
mock.Verify(_ => _.KeyPersist("prefix:key", CommandFlags.None));
}
[Fact]
......@@ -295,8 +295,8 @@ public void KeyRandom()
[Fact]
public void KeyRename()
{
wrapper.KeyRename("key", "newKey", When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyRename("prefix:key", "prefix:newKey", When.Exists, CommandFlags.HighPriority));
wrapper.KeyRename("key", "newKey", When.Exists, CommandFlags.None);
mock.Verify(_ => _.KeyRename("prefix:key", "prefix:newKey", When.Exists, CommandFlags.None));
}
[Fact]
......@@ -304,166 +304,166 @@ public void KeyRestore()
{
byte[] value = new byte[0];
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.KeyRestore("key", value, expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyRestore("prefix:key", value, expiry, CommandFlags.HighPriority));
wrapper.KeyRestore("key", value, expiry, CommandFlags.None);
mock.Verify(_ => _.KeyRestore("prefix:key", value, expiry, CommandFlags.None));
}
[Fact]
public void KeyTimeToLive()
{
wrapper.KeyTimeToLive("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyTimeToLive("prefix:key", CommandFlags.HighPriority));
wrapper.KeyTimeToLive("key", CommandFlags.None);
mock.Verify(_ => _.KeyTimeToLive("prefix:key", CommandFlags.None));
}
[Fact]
public void KeyType()
{
wrapper.KeyType("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyType("prefix:key", CommandFlags.HighPriority));
wrapper.KeyType("key", CommandFlags.None);
mock.Verify(_ => _.KeyType("prefix:key", CommandFlags.None));
}
[Fact]
public void ListGetByIndex()
{
wrapper.ListGetByIndex("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.ListGetByIndex("prefix:key", 123, CommandFlags.HighPriority));
wrapper.ListGetByIndex("key", 123, CommandFlags.None);
mock.Verify(_ => _.ListGetByIndex("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void ListInsertAfter()
{
wrapper.ListInsertAfter("key", "pivot", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.ListInsertAfter("prefix:key", "pivot", "value", CommandFlags.HighPriority));
wrapper.ListInsertAfter("key", "pivot", "value", CommandFlags.None);
mock.Verify(_ => _.ListInsertAfter("prefix:key", "pivot", "value", CommandFlags.None));
}
[Fact]
public void ListInsertBefore()
{
wrapper.ListInsertBefore("key", "pivot", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.ListInsertBefore("prefix:key", "pivot", "value", CommandFlags.HighPriority));
wrapper.ListInsertBefore("key", "pivot", "value", CommandFlags.None);
mock.Verify(_ => _.ListInsertBefore("prefix:key", "pivot", "value", CommandFlags.None));
}
[Fact]
public void ListLeftPop()
{
wrapper.ListLeftPop("key", CommandFlags.HighPriority);
mock.Verify(_ => _.ListLeftPop("prefix:key", CommandFlags.HighPriority));
wrapper.ListLeftPop("key", CommandFlags.None);
mock.Verify(_ => _.ListLeftPop("prefix:key", CommandFlags.None));
}
[Fact]
public void ListLeftPush_1()
{
wrapper.ListLeftPush("key", "value", When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.ListLeftPush("prefix:key", "value", When.Exists, CommandFlags.HighPriority));
wrapper.ListLeftPush("key", "value", When.Exists, CommandFlags.None);
mock.Verify(_ => _.ListLeftPush("prefix:key", "value", When.Exists, CommandFlags.None));
}
[Fact]
public void ListLeftPush_2()
{
RedisValue[] values = new RedisValue[0];
wrapper.ListLeftPush("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.ListLeftPush("prefix:key", values, CommandFlags.HighPriority));
wrapper.ListLeftPush("key", values, CommandFlags.None);
mock.Verify(_ => _.ListLeftPush("prefix:key", values, CommandFlags.None));
}
[Fact]
public void ListLength()
{
wrapper.ListLength("key", CommandFlags.HighPriority);
mock.Verify(_ => _.ListLength("prefix:key", CommandFlags.HighPriority));
wrapper.ListLength("key", CommandFlags.None);
mock.Verify(_ => _.ListLength("prefix:key", CommandFlags.None));
}
[Fact]
public void ListRange()
{
wrapper.ListRange("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.ListRange("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.ListRange("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.ListRange("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void ListRemove()
{
wrapper.ListRemove("key", "value", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.ListRemove("prefix:key", "value", 123, CommandFlags.HighPriority));
wrapper.ListRemove("key", "value", 123, CommandFlags.None);
mock.Verify(_ => _.ListRemove("prefix:key", "value", 123, CommandFlags.None));
}
[Fact]
public void ListRightPop()
{
wrapper.ListRightPop("key", CommandFlags.HighPriority);
mock.Verify(_ => _.ListRightPop("prefix:key", CommandFlags.HighPriority));
wrapper.ListRightPop("key", CommandFlags.None);
mock.Verify(_ => _.ListRightPop("prefix:key", CommandFlags.None));
}
[Fact]
public void ListRightPopLeftPush()
{
wrapper.ListRightPopLeftPush("source", "destination", CommandFlags.HighPriority);
mock.Verify(_ => _.ListRightPopLeftPush("prefix:source", "prefix:destination", CommandFlags.HighPriority));
wrapper.ListRightPopLeftPush("source", "destination", CommandFlags.None);
mock.Verify(_ => _.ListRightPopLeftPush("prefix:source", "prefix:destination", CommandFlags.None));
}
[Fact]
public void ListRightPush_1()
{
wrapper.ListRightPush("key", "value", When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.ListRightPush("prefix:key", "value", When.Exists, CommandFlags.HighPriority));
wrapper.ListRightPush("key", "value", When.Exists, CommandFlags.None);
mock.Verify(_ => _.ListRightPush("prefix:key", "value", When.Exists, CommandFlags.None));
}
[Fact]
public void ListRightPush_2()
{
RedisValue[] values = new RedisValue[0];
wrapper.ListRightPush("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.ListRightPush("prefix:key", values, CommandFlags.HighPriority));
wrapper.ListRightPush("key", values, CommandFlags.None);
mock.Verify(_ => _.ListRightPush("prefix:key", values, CommandFlags.None));
}
[Fact]
public void ListSetByIndex()
{
wrapper.ListSetByIndex("key", 123, "value", CommandFlags.HighPriority);
mock.Verify(_ => _.ListSetByIndex("prefix:key", 123, "value", CommandFlags.HighPriority));
wrapper.ListSetByIndex("key", 123, "value", CommandFlags.None);
mock.Verify(_ => _.ListSetByIndex("prefix:key", 123, "value", CommandFlags.None));
}
[Fact]
public void ListTrim()
{
wrapper.ListTrim("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.ListTrim("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.ListTrim("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.ListTrim("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void LockExtend()
{
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.LockExtend("key", "value", expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.LockExtend("prefix:key", "value", expiry, CommandFlags.HighPriority));
wrapper.LockExtend("key", "value", expiry, CommandFlags.None);
mock.Verify(_ => _.LockExtend("prefix:key", "value", expiry, CommandFlags.None));
}
[Fact]
public void LockQuery()
{
wrapper.LockQuery("key", CommandFlags.HighPriority);
mock.Verify(_ => _.LockQuery("prefix:key", CommandFlags.HighPriority));
wrapper.LockQuery("key", CommandFlags.None);
mock.Verify(_ => _.LockQuery("prefix:key", CommandFlags.None));
}
[Fact]
public void LockRelease()
{
wrapper.LockRelease("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.LockRelease("prefix:key", "value", CommandFlags.HighPriority));
wrapper.LockRelease("key", "value", CommandFlags.None);
mock.Verify(_ => _.LockRelease("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void LockTake()
{
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.LockTake("key", "value", expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.LockTake("prefix:key", "value", expiry, CommandFlags.HighPriority));
wrapper.LockTake("key", "value", expiry, CommandFlags.None);
mock.Verify(_ => _.LockTake("prefix:key", "value", expiry, CommandFlags.None));
}
[Fact]
public void Publish()
{
wrapper.Publish("channel", "message", CommandFlags.HighPriority);
mock.Verify(_ => _.Publish("prefix:channel", "message", CommandFlags.HighPriority));
wrapper.Publish("channel", "message", CommandFlags.None);
mock.Verify(_ => _.Publish("prefix:channel", "message", CommandFlags.None));
}
[Fact]
......@@ -473,8 +473,8 @@ public void ScriptEvaluate_1()
RedisValue[] values = new RedisValue[0];
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.ScriptEvaluate(hash, keys, values, CommandFlags.HighPriority);
mock.Verify(_ => _.ScriptEvaluate(hash, It.Is(valid), values, CommandFlags.HighPriority));
wrapper.ScriptEvaluate(hash, keys, values, CommandFlags.None);
mock.Verify(_ => _.ScriptEvaluate(hash, It.Is(valid), values, CommandFlags.None));
}
[Fact]
......@@ -483,30 +483,30 @@ public void ScriptEvaluate_2()
RedisValue[] values = new RedisValue[0];
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.ScriptEvaluate("script", keys, values, CommandFlags.HighPriority);
mock.Verify(_ => _.ScriptEvaluate("script", It.Is(valid), values, CommandFlags.HighPriority));
wrapper.ScriptEvaluate("script", keys, values, CommandFlags.None);
mock.Verify(_ => _.ScriptEvaluate("script", It.Is(valid), values, CommandFlags.None));
}
[Fact]
public void SetAdd_1()
{
wrapper.SetAdd("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.SetAdd("prefix:key", "value", CommandFlags.HighPriority));
wrapper.SetAdd("key", "value", CommandFlags.None);
mock.Verify(_ => _.SetAdd("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void SetAdd_2()
{
RedisValue[] values = new RedisValue[0];
wrapper.SetAdd("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.SetAdd("prefix:key", values, CommandFlags.HighPriority));
wrapper.SetAdd("key", values, CommandFlags.None);
mock.Verify(_ => _.SetAdd("prefix:key", values, CommandFlags.None));
}
[Fact]
public void SetCombine_1()
{
wrapper.SetCombine(SetOperation.Intersect, "first", "second", CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombine(SetOperation.Intersect, "prefix:first", "prefix:second", CommandFlags.HighPriority));
wrapper.SetCombine(SetOperation.Intersect, "first", "second", CommandFlags.None);
mock.Verify(_ => _.SetCombine(SetOperation.Intersect, "prefix:first", "prefix:second", CommandFlags.None));
}
[Fact]
......@@ -514,15 +514,15 @@ public void SetCombine_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.SetCombine(SetOperation.Intersect, keys, CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombine(SetOperation.Intersect, It.Is(valid), CommandFlags.HighPriority));
wrapper.SetCombine(SetOperation.Intersect, keys, CommandFlags.None);
mock.Verify(_ => _.SetCombine(SetOperation.Intersect, It.Is(valid), CommandFlags.None));
}
[Fact]
public void SetCombineAndStore_1()
{
wrapper.SetCombineAndStore(SetOperation.Intersect, "destination", "first", "second", CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombineAndStore(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.HighPriority));
wrapper.SetCombineAndStore(SetOperation.Intersect, "destination", "first", "second", CommandFlags.None);
mock.Verify(_ => _.SetCombineAndStore(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.None));
}
[Fact]
......@@ -530,89 +530,89 @@ public void SetCombineAndStore_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.SetCombineAndStore(SetOperation.Intersect, "destination", keys, CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombineAndStore(SetOperation.Intersect, "prefix:destination", It.Is(valid), CommandFlags.HighPriority));
wrapper.SetCombineAndStore(SetOperation.Intersect, "destination", keys, CommandFlags.None);
mock.Verify(_ => _.SetCombineAndStore(SetOperation.Intersect, "prefix:destination", It.Is(valid), CommandFlags.None));
}
[Fact]
public void SetContains()
{
wrapper.SetContains("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.SetContains("prefix:key", "value", CommandFlags.HighPriority));
wrapper.SetContains("key", "value", CommandFlags.None);
mock.Verify(_ => _.SetContains("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void SetLength()
{
wrapper.SetLength("key", CommandFlags.HighPriority);
mock.Verify(_ => _.SetLength("prefix:key", CommandFlags.HighPriority));
wrapper.SetLength("key", CommandFlags.None);
mock.Verify(_ => _.SetLength("prefix:key", CommandFlags.None));
}
[Fact]
public void SetMembers()
{
wrapper.SetMembers("key", CommandFlags.HighPriority);
mock.Verify(_ => _.SetMembers("prefix:key", CommandFlags.HighPriority));
wrapper.SetMembers("key", CommandFlags.None);
mock.Verify(_ => _.SetMembers("prefix:key", CommandFlags.None));
}
[Fact]
public void SetMove()
{
wrapper.SetMove("source", "destination", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.SetMove("prefix:source", "prefix:destination", "value", CommandFlags.HighPriority));
wrapper.SetMove("source", "destination", "value", CommandFlags.None);
mock.Verify(_ => _.SetMove("prefix:source", "prefix:destination", "value", CommandFlags.None));
}
[Fact]
public void SetPop_1()
{
wrapper.SetPop("key", CommandFlags.HighPriority);
mock.Verify(_ => _.SetPop("prefix:key", CommandFlags.HighPriority));
wrapper.SetPop("key", CommandFlags.None);
mock.Verify(_ => _.SetPop("prefix:key", CommandFlags.None));
wrapper.SetPop("key", 5, CommandFlags.HighPriority);
mock.Verify(_ => _.SetPop("prefix:key", 5, CommandFlags.HighPriority));
wrapper.SetPop("key", 5, CommandFlags.None);
mock.Verify(_ => _.SetPop("prefix:key", 5, CommandFlags.None));
}
[Fact]
public void SetPop_2()
{
wrapper.SetPop("key", 5, CommandFlags.HighPriority);
mock.Verify(_ => _.SetPop("prefix:key", 5, CommandFlags.HighPriority));
wrapper.SetPop("key", 5, CommandFlags.None);
mock.Verify(_ => _.SetPop("prefix:key", 5, CommandFlags.None));
}
[Fact]
public void SetRandomMember()
{
wrapper.SetRandomMember("key", CommandFlags.HighPriority);
mock.Verify(_ => _.SetRandomMember("prefix:key", CommandFlags.HighPriority));
wrapper.SetRandomMember("key", CommandFlags.None);
mock.Verify(_ => _.SetRandomMember("prefix:key", CommandFlags.None));
}
[Fact]
public void SetRandomMembers()
{
wrapper.SetRandomMembers("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.SetRandomMembers("prefix:key", 123, CommandFlags.HighPriority));
wrapper.SetRandomMembers("key", 123, CommandFlags.None);
mock.Verify(_ => _.SetRandomMembers("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void SetRemove_1()
{
wrapper.SetRemove("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.SetRemove("prefix:key", "value", CommandFlags.HighPriority));
wrapper.SetRemove("key", "value", CommandFlags.None);
mock.Verify(_ => _.SetRemove("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void SetRemove_2()
{
RedisValue[] values = new RedisValue[0];
wrapper.SetRemove("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.SetRemove("prefix:key", values, CommandFlags.HighPriority));
wrapper.SetRemove("key", values, CommandFlags.None);
mock.Verify(_ => _.SetRemove("prefix:key", values, CommandFlags.None));
}
[Fact]
public void SetScan()
{
wrapper.SetScan("key", "pattern", 123, flags: CommandFlags.HighPriority);
mock.Verify(_ => _.SetScan("prefix:key", "pattern", 123, 0, 0, CommandFlags.HighPriority));
wrapper.SetScan("key", "pattern", 123, flags: CommandFlags.None);
mock.Verify(_ => _.SetScan("prefix:key", "pattern", 123, 0, 0, CommandFlags.None));
}
[Fact]
......@@ -621,11 +621,11 @@ public void Sort()
RedisValue[] get = new RedisValue[] { "a", "#" };
Expression<Func<RedisValue[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "#";
wrapper.Sort("key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.HighPriority);
wrapper.Sort("key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.HighPriority);
wrapper.Sort("key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.None);
wrapper.Sort("key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.None);
mock.Verify(_ => _.Sort("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", It.Is(valid), CommandFlags.HighPriority));
mock.Verify(_ => _.Sort("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", It.Is(valid), CommandFlags.HighPriority));
mock.Verify(_ => _.Sort("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", It.Is(valid), CommandFlags.None));
mock.Verify(_ => _.Sort("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", It.Is(valid), CommandFlags.None));
}
[Fact]
......@@ -634,33 +634,33 @@ public void SortAndStore()
RedisValue[] get = new RedisValue[] { "a", "#" };
Expression<Func<RedisValue[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "#";
wrapper.SortAndStore("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.HighPriority);
wrapper.SortAndStore("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.HighPriority);
wrapper.SortAndStore("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.None);
wrapper.SortAndStore("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.None);
mock.Verify(_ => _.SortAndStore("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", It.Is(valid), CommandFlags.HighPriority));
mock.Verify(_ => _.SortAndStore("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", It.Is(valid), CommandFlags.HighPriority));
mock.Verify(_ => _.SortAndStore("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", It.Is(valid), CommandFlags.None));
mock.Verify(_ => _.SortAndStore("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", It.Is(valid), CommandFlags.None));
}
[Fact]
public void SortedSetAdd_1()
{
wrapper.SortedSetAdd("key", "member", 1.23, When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetAdd("prefix:key", "member", 1.23, When.Exists, CommandFlags.HighPriority));
wrapper.SortedSetAdd("key", "member", 1.23, When.Exists, CommandFlags.None);
mock.Verify(_ => _.SortedSetAdd("prefix:key", "member", 1.23, When.Exists, CommandFlags.None));
}
[Fact]
public void SortedSetAdd_2()
{
SortedSetEntry[] values = new SortedSetEntry[0];
wrapper.SortedSetAdd("key", values, When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetAdd("prefix:key", values, When.Exists, CommandFlags.HighPriority));
wrapper.SortedSetAdd("key", values, When.Exists, CommandFlags.None);
mock.Verify(_ => _.SortedSetAdd("prefix:key", values, When.Exists, CommandFlags.None));
}
[Fact]
public void SortedSetCombineAndStore_1()
{
wrapper.SortedSetCombineAndStore(SetOperation.Intersect, "destination", "first", "second", Aggregate.Max, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetCombineAndStore(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", Aggregate.Max, CommandFlags.HighPriority));
wrapper.SortedSetCombineAndStore(SetOperation.Intersect, "destination", "first", "second", Aggregate.Max, CommandFlags.None);
mock.Verify(_ => _.SortedSetCombineAndStore(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", Aggregate.Max, CommandFlags.None));
}
[Fact]
......@@ -668,324 +668,324 @@ public void SortedSetCombineAndStore_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.SetCombineAndStore(SetOperation.Intersect, "destination", keys, CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombineAndStore(SetOperation.Intersect, "prefix:destination", It.Is(valid), CommandFlags.HighPriority));
wrapper.SetCombineAndStore(SetOperation.Intersect, "destination", keys, CommandFlags.None);
mock.Verify(_ => _.SetCombineAndStore(SetOperation.Intersect, "prefix:destination", It.Is(valid), CommandFlags.None));
}
[Fact]
public void SortedSetDecrement()
{
wrapper.SortedSetDecrement("key", "member", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetDecrement("prefix:key", "member", 1.23, CommandFlags.HighPriority));
wrapper.SortedSetDecrement("key", "member", 1.23, CommandFlags.None);
mock.Verify(_ => _.SortedSetDecrement("prefix:key", "member", 1.23, CommandFlags.None));
}
[Fact]
public void SortedSetIncrement()
{
wrapper.SortedSetIncrement("key", "member", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetIncrement("prefix:key", "member", 1.23, CommandFlags.HighPriority));
wrapper.SortedSetIncrement("key", "member", 1.23, CommandFlags.None);
mock.Verify(_ => _.SortedSetIncrement("prefix:key", "member", 1.23, CommandFlags.None));
}
[Fact]
public void SortedSetLength()
{
wrapper.SortedSetLength("key", 1.23, 1.23, Exclude.Start, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetLength("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.HighPriority));
wrapper.SortedSetLength("key", 1.23, 1.23, Exclude.Start, CommandFlags.None);
mock.Verify(_ => _.SortedSetLength("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.None));
}
[Fact]
public void SortedSetLengthByValue()
{
wrapper.SortedSetLengthByValue("key", "min", "max", Exclude.Start, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetLengthByValue("prefix:key", "min", "max", Exclude.Start, CommandFlags.HighPriority));
wrapper.SortedSetLengthByValue("key", "min", "max", Exclude.Start, CommandFlags.None);
mock.Verify(_ => _.SortedSetLengthByValue("prefix:key", "min", "max", Exclude.Start, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByRank()
{
wrapper.SortedSetRangeByRank("key", 123, 456, Order.Descending, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByRank("prefix:key", 123, 456, Order.Descending, CommandFlags.HighPriority));
wrapper.SortedSetRangeByRank("key", 123, 456, Order.Descending, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByRank("prefix:key", 123, 456, Order.Descending, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByRankWithScores()
{
wrapper.SortedSetRangeByRankWithScores("key", 123, 456, Order.Descending, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByRankWithScores("prefix:key", 123, 456, Order.Descending, CommandFlags.HighPriority));
wrapper.SortedSetRangeByRankWithScores("key", 123, 456, Order.Descending, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByRankWithScores("prefix:key", 123, 456, Order.Descending, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByScore()
{
wrapper.SortedSetRangeByScore("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByScore("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRangeByScore("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByScore("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByScoreWithScores()
{
wrapper.SortedSetRangeByScoreWithScores("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByScoreWithScores("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRangeByScoreWithScores("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByScoreWithScores("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByValue()
{
wrapper.SortedSetRangeByValue("key", "min", "max", Exclude.Start, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByValue("prefix:key", "min", "max", Exclude.Start, Order.Ascending, 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRangeByValue("key", "min", "max", Exclude.Start, 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByValue("prefix:key", "min", "max", Exclude.Start, Order.Ascending, 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByValueDesc()
{
wrapper.SortedSetRangeByValue("key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByValue("prefix:key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRangeByValue("key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByValue("prefix:key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRank()
{
wrapper.SortedSetRank("key", "member", Order.Descending, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRank("prefix:key", "member", Order.Descending, CommandFlags.HighPriority));
wrapper.SortedSetRank("key", "member", Order.Descending, CommandFlags.None);
mock.Verify(_ => _.SortedSetRank("prefix:key", "member", Order.Descending, CommandFlags.None));
}
[Fact]
public void SortedSetRemove_1()
{
wrapper.SortedSetRemove("key", "member", CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemove("prefix:key", "member", CommandFlags.HighPriority));
wrapper.SortedSetRemove("key", "member", CommandFlags.None);
mock.Verify(_ => _.SortedSetRemove("prefix:key", "member", CommandFlags.None));
}
[Fact]
public void SortedSetRemove_2()
{
RedisValue[] members = new RedisValue[0];
wrapper.SortedSetRemove("key", members, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemove("prefix:key", members, CommandFlags.HighPriority));
wrapper.SortedSetRemove("key", members, CommandFlags.None);
mock.Verify(_ => _.SortedSetRemove("prefix:key", members, CommandFlags.None));
}
[Fact]
public void SortedSetRemoveRangeByRank()
{
wrapper.SortedSetRemoveRangeByRank("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemoveRangeByRank("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRemoveRangeByRank("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRemoveRangeByRank("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRemoveRangeByScore()
{
wrapper.SortedSetRemoveRangeByScore("key", 1.23, 1.23, Exclude.Start, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemoveRangeByScore("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.HighPriority));
wrapper.SortedSetRemoveRangeByScore("key", 1.23, 1.23, Exclude.Start, CommandFlags.None);
mock.Verify(_ => _.SortedSetRemoveRangeByScore("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.None));
}
[Fact]
public void SortedSetRemoveRangeByValue()
{
wrapper.SortedSetRemoveRangeByValue("key", "min", "max", Exclude.Start, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemoveRangeByValue("prefix:key", "min", "max", Exclude.Start, CommandFlags.HighPriority));
wrapper.SortedSetRemoveRangeByValue("key", "min", "max", Exclude.Start, CommandFlags.None);
mock.Verify(_ => _.SortedSetRemoveRangeByValue("prefix:key", "min", "max", Exclude.Start, CommandFlags.None));
}
[Fact]
public void SortedSetScan()
{
wrapper.SortedSetScan("key", "pattern", 123, flags: CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetScan("prefix:key", "pattern", 123, 0, 0, CommandFlags.HighPriority));
wrapper.SortedSetScan("key", "pattern", 123, flags: CommandFlags.None);
mock.Verify(_ => _.SortedSetScan("prefix:key", "pattern", 123, 0, 0, CommandFlags.None));
}
[Fact]
public void SortedSetScore()
{
wrapper.SortedSetScore("key", "member", CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetScore("prefix:key", "member", CommandFlags.HighPriority));
wrapper.SortedSetScore("key", "member", CommandFlags.None);
mock.Verify(_ => _.SortedSetScore("prefix:key", "member", CommandFlags.None));
}
[Fact]
public void StreamAcknowledge_1()
{
wrapper.StreamAcknowledge("key", "group", "0-0", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamAcknowledge("prefix:key", "group", "0-0", CommandFlags.HighPriority));
wrapper.StreamAcknowledge("key", "group", "0-0", CommandFlags.None);
mock.Verify(_ => _.StreamAcknowledge("prefix:key", "group", "0-0", CommandFlags.None));
}
[Fact]
public void StreamAcknowledge_2()
{
var messageIds = new RedisValue[] { "0-0", "0-1", "0-2" };
wrapper.StreamAcknowledge("key", "group", messageIds, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamAcknowledge("prefix:key", "group", messageIds, CommandFlags.HighPriority));
wrapper.StreamAcknowledge("key", "group", messageIds, CommandFlags.None);
mock.Verify(_ => _.StreamAcknowledge("prefix:key", "group", messageIds, CommandFlags.None));
}
[Fact]
public void StreamAdd_1()
{
wrapper.StreamAdd("key", "field1", "value1", "*", 1000, true, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamAdd("prefix:key", "field1", "value1", "*", 1000, true, CommandFlags.HighPriority));
wrapper.StreamAdd("key", "field1", "value1", "*", 1000, true, CommandFlags.None);
mock.Verify(_ => _.StreamAdd("prefix:key", "field1", "value1", "*", 1000, true, CommandFlags.None));
}
[Fact]
public void StreamAdd_2()
{
var fields = new NameValueEntry[0];
wrapper.StreamAdd("key", fields, "*", 1000, true, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamAdd("prefix:key", fields, "*", 1000, true, CommandFlags.HighPriority));
wrapper.StreamAdd("key", fields, "*", 1000, true, CommandFlags.None);
mock.Verify(_ => _.StreamAdd("prefix:key", fields, "*", 1000, true, CommandFlags.None));
}
[Fact]
public void StreamClaimMessages()
{
var messageIds = new RedisValue[0];
wrapper.StreamClaim("key", "group", "consumer", 1000, messageIds, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamClaim("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.HighPriority));
wrapper.StreamClaim("key", "group", "consumer", 1000, messageIds, CommandFlags.None);
mock.Verify(_ => _.StreamClaim("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.None));
}
[Fact]
public void StreamClaimMessagesReturningIds()
{
var messageIds = new RedisValue[0];
wrapper.StreamClaimIdsOnly("key", "group", "consumer", 1000, messageIds, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamClaimIdsOnly("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.HighPriority));
wrapper.StreamClaimIdsOnly("key", "group", "consumer", 1000, messageIds, CommandFlags.None);
mock.Verify(_ => _.StreamClaimIdsOnly("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.None));
}
[Fact]
public void StreamConsumerGroupSetPosition()
{
wrapper.StreamConsumerGroupSetPosition("key", "group", StreamPosition.Beginning, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamConsumerGroupSetPosition("prefix:key", "group", StreamPosition.Beginning, CommandFlags.HighPriority));
wrapper.StreamConsumerGroupSetPosition("key", "group", StreamPosition.Beginning, CommandFlags.None);
mock.Verify(_ => _.StreamConsumerGroupSetPosition("prefix:key", "group", StreamPosition.Beginning, CommandFlags.None));
}
[Fact]
public void StreamConsumerInfoGet()
{
wrapper.StreamConsumerInfo("key", "group", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamConsumerInfo("prefix:key", "group", CommandFlags.HighPriority));
wrapper.StreamConsumerInfo("key", "group", CommandFlags.None);
mock.Verify(_ => _.StreamConsumerInfo("prefix:key", "group", CommandFlags.None));
}
[Fact]
public void StreamCreateConsumerGroup()
{
wrapper.StreamCreateConsumerGroup("key", "group", StreamPosition.Beginning, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamCreateConsumerGroup("prefix:key", "group", StreamPosition.Beginning, CommandFlags.HighPriority));
wrapper.StreamCreateConsumerGroup("key", "group", StreamPosition.Beginning, CommandFlags.None);
mock.Verify(_ => _.StreamCreateConsumerGroup("prefix:key", "group", StreamPosition.Beginning, CommandFlags.None));
}
[Fact]
public void StreamGroupInfoGet()
{
wrapper.StreamGroupInfo("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamGroupInfo("prefix:key", CommandFlags.HighPriority));
wrapper.StreamGroupInfo("key", CommandFlags.None);
mock.Verify(_ => _.StreamGroupInfo("prefix:key", CommandFlags.None));
}
[Fact]
public void StreamInfoGet()
{
wrapper.StreamInfo("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamInfo("prefix:key", CommandFlags.HighPriority));
wrapper.StreamInfo("key", CommandFlags.None);
mock.Verify(_ => _.StreamInfo("prefix:key", CommandFlags.None));
}
[Fact]
public void StreamLength()
{
wrapper.StreamLength("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamLength("prefix:key", CommandFlags.HighPriority));
wrapper.StreamLength("key", CommandFlags.None);
mock.Verify(_ => _.StreamLength("prefix:key", CommandFlags.None));
}
[Fact]
public void StreamMessagesDelete()
{
var messageIds = new RedisValue[0] { };
wrapper.StreamDelete("key", messageIds, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamDelete("prefix:key", messageIds, CommandFlags.HighPriority));
wrapper.StreamDelete("key", messageIds, CommandFlags.None);
mock.Verify(_ => _.StreamDelete("prefix:key", messageIds, CommandFlags.None));
}
[Fact]
public void StreamDeleteConsumer()
{
wrapper.StreamDeleteConsumer("key", "group", "consumer", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamDeleteConsumer("prefix:key", "group", "consumer", CommandFlags.HighPriority));
wrapper.StreamDeleteConsumer("key", "group", "consumer", CommandFlags.None);
mock.Verify(_ => _.StreamDeleteConsumer("prefix:key", "group", "consumer", CommandFlags.None));
}
[Fact]
public void StreamDeleteConsumerGroup()
{
wrapper.StreamDeleteConsumerGroup("key", "group", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamDeleteConsumerGroup("prefix:key", "group", CommandFlags.HighPriority));
wrapper.StreamDeleteConsumerGroup("key", "group", CommandFlags.None);
mock.Verify(_ => _.StreamDeleteConsumerGroup("prefix:key", "group", CommandFlags.None));
}
[Fact]
public void StreamPendingInfoGet()
{
wrapper.StreamPending("key", "group", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamPending("prefix:key", "group", CommandFlags.HighPriority));
wrapper.StreamPending("key", "group", CommandFlags.None);
mock.Verify(_ => _.StreamPending("prefix:key", "group", CommandFlags.None));
}
[Fact]
public void StreamPendingMessageInfoGet()
{
wrapper.StreamPendingMessages("key", "group", 10, RedisValue.Null, "-", "+", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamPendingMessages("prefix:key", "group", 10, RedisValue.Null, "-", "+", CommandFlags.HighPriority));
wrapper.StreamPendingMessages("key", "group", 10, RedisValue.Null, "-", "+", CommandFlags.None);
mock.Verify(_ => _.StreamPendingMessages("prefix:key", "group", 10, RedisValue.Null, "-", "+", CommandFlags.None));
}
[Fact]
public void StreamRange()
{
wrapper.StreamRange("key", "-", "+", null, Order.Ascending, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamRange("prefix:key", "-", "+", null, Order.Ascending, CommandFlags.HighPriority));
wrapper.StreamRange("key", "-", "+", null, Order.Ascending, CommandFlags.None);
mock.Verify(_ => _.StreamRange("prefix:key", "-", "+", null, Order.Ascending, CommandFlags.None));
}
[Fact]
public void StreamRead_1()
{
var streamPositions = new StreamPosition[0] { };
wrapper.StreamRead(streamPositions, null, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamRead(streamPositions, null, CommandFlags.HighPriority));
wrapper.StreamRead(streamPositions, null, CommandFlags.None);
mock.Verify(_ => _.StreamRead(streamPositions, null, CommandFlags.None));
}
[Fact]
public void StreamRead_2()
{
wrapper.StreamRead("key", "0-0", null, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamRead("prefix:key", "0-0", null, CommandFlags.HighPriority));
wrapper.StreamRead("key", "0-0", null, CommandFlags.None);
mock.Verify(_ => _.StreamRead("prefix:key", "0-0", null, CommandFlags.None));
}
[Fact]
public void StreamStreamReadGroup_1()
{
wrapper.StreamReadGroup("key", "group", "consumer", "0-0", 10, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamReadGroup("prefix:key", "group", "consumer", "0-0", 10, CommandFlags.HighPriority));
wrapper.StreamReadGroup("key", "group", "consumer", "0-0", 10, CommandFlags.None);
mock.Verify(_ => _.StreamReadGroup("prefix:key", "group", "consumer", "0-0", 10, CommandFlags.None));
}
[Fact]
public void StreamStreamReadGroup_2()
{
var streamPositions = new StreamPosition[0] { };
wrapper.StreamReadGroup(streamPositions, "group", "consumer", 10, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamReadGroup(streamPositions, "group", "consumer", 10, CommandFlags.HighPriority));
wrapper.StreamReadGroup(streamPositions, "group", "consumer", 10, CommandFlags.None);
mock.Verify(_ => _.StreamReadGroup(streamPositions, "group", "consumer", 10, CommandFlags.None));
}
[Fact]
public void StreamTrim()
{
wrapper.StreamTrim("key", 1000, true, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamTrim("prefix:key", 1000, true, CommandFlags.HighPriority));
wrapper.StreamTrim("key", 1000, true, CommandFlags.None);
mock.Verify(_ => _.StreamTrim("prefix:key", 1000, true, CommandFlags.None));
}
[Fact]
public void StringAppend()
{
wrapper.StringAppend("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.StringAppend("prefix:key", "value", CommandFlags.HighPriority));
wrapper.StringAppend("key", "value", CommandFlags.None);
mock.Verify(_ => _.StringAppend("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void StringBitCount()
{
wrapper.StringBitCount("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.StringBitCount("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.StringBitCount("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.StringBitCount("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void StringBitOperation_1()
{
wrapper.StringBitOperation(Bitwise.Xor, "destination", "first", "second", CommandFlags.HighPriority);
mock.Verify(_ => _.StringBitOperation(Bitwise.Xor, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.HighPriority));
wrapper.StringBitOperation(Bitwise.Xor, "destination", "first", "second", CommandFlags.None);
mock.Verify(_ => _.StringBitOperation(Bitwise.Xor, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.None));
}
[Fact]
......@@ -993,36 +993,36 @@ public void StringBitOperation_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.StringBitOperation(Bitwise.Xor, "destination", keys, CommandFlags.HighPriority);
mock.Verify(_ => _.StringBitOperation(Bitwise.Xor, "prefix:destination", It.Is(valid), CommandFlags.HighPriority));
wrapper.StringBitOperation(Bitwise.Xor, "destination", keys, CommandFlags.None);
mock.Verify(_ => _.StringBitOperation(Bitwise.Xor, "prefix:destination", It.Is(valid), CommandFlags.None));
}
[Fact]
public void StringBitPosition()
{
wrapper.StringBitPosition("key", true, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.StringBitPosition("prefix:key", true, 123, 456, CommandFlags.HighPriority));
wrapper.StringBitPosition("key", true, 123, 456, CommandFlags.None);
mock.Verify(_ => _.StringBitPosition("prefix:key", true, 123, 456, CommandFlags.None));
}
[Fact]
public void StringDecrement_1()
{
wrapper.StringDecrement("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.StringDecrement("prefix:key", 123, CommandFlags.HighPriority));
wrapper.StringDecrement("key", 123, CommandFlags.None);
mock.Verify(_ => _.StringDecrement("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void StringDecrement_2()
{
wrapper.StringDecrement("key", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.StringDecrement("prefix:key", 1.23, CommandFlags.HighPriority));
wrapper.StringDecrement("key", 1.23, CommandFlags.None);
mock.Verify(_ => _.StringDecrement("prefix:key", 1.23, CommandFlags.None));
}
[Fact]
public void StringGet_1()
{
wrapper.StringGet("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StringGet("prefix:key", CommandFlags.HighPriority));
wrapper.StringGet("key", CommandFlags.None);
mock.Verify(_ => _.StringGet("prefix:key", CommandFlags.None));
}
[Fact]
......@@ -1030,65 +1030,65 @@ public void StringGet_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.StringGet(keys, CommandFlags.HighPriority);
mock.Verify(_ => _.StringGet(It.Is(valid), CommandFlags.HighPriority));
wrapper.StringGet(keys, CommandFlags.None);
mock.Verify(_ => _.StringGet(It.Is(valid), CommandFlags.None));
}
[Fact]
public void StringGetBit()
{
wrapper.StringGetBit("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetBit("prefix:key", 123, CommandFlags.HighPriority));
wrapper.StringGetBit("key", 123, CommandFlags.None);
mock.Verify(_ => _.StringGetBit("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void StringGetRange()
{
wrapper.StringGetRange("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetRange("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.StringGetRange("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.StringGetRange("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void StringGetSet()
{
wrapper.StringGetSet("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetSet("prefix:key", "value", CommandFlags.HighPriority));
wrapper.StringGetSet("key", "value", CommandFlags.None);
mock.Verify(_ => _.StringGetSet("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void StringGetWithExpiry()
{
wrapper.StringGetWithExpiry("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetWithExpiry("prefix:key", CommandFlags.HighPriority));
wrapper.StringGetWithExpiry("key", CommandFlags.None);
mock.Verify(_ => _.StringGetWithExpiry("prefix:key", CommandFlags.None));
}
[Fact]
public void StringIncrement_1()
{
wrapper.StringIncrement("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.StringIncrement("prefix:key", 123, CommandFlags.HighPriority));
wrapper.StringIncrement("key", 123, CommandFlags.None);
mock.Verify(_ => _.StringIncrement("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void StringIncrement_2()
{
wrapper.StringIncrement("key", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.StringIncrement("prefix:key", 1.23, CommandFlags.HighPriority));
wrapper.StringIncrement("key", 1.23, CommandFlags.None);
mock.Verify(_ => _.StringIncrement("prefix:key", 1.23, CommandFlags.None));
}
[Fact]
public void StringLength()
{
wrapper.StringLength("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StringLength("prefix:key", CommandFlags.HighPriority));
wrapper.StringLength("key", CommandFlags.None);
mock.Verify(_ => _.StringLength("prefix:key", CommandFlags.None));
}
[Fact]
public void StringSet_1()
{
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.StringSet("key", "value", expiry, When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.StringSet("prefix:key", "value", expiry, When.Exists, CommandFlags.HighPriority));
wrapper.StringSet("key", "value", expiry, When.Exists, CommandFlags.None);
mock.Verify(_ => _.StringSet("prefix:key", "value", expiry, When.Exists, CommandFlags.None));
}
[Fact]
......@@ -1096,22 +1096,22 @@ public void StringSet_2()
{
KeyValuePair<RedisKey, RedisValue>[] values = new KeyValuePair<RedisKey, RedisValue>[] { new KeyValuePair<RedisKey, RedisValue>("a", "x"), new KeyValuePair<RedisKey, RedisValue>("b", "y") };
Expression<Func<KeyValuePair<RedisKey, RedisValue>[], bool>> valid = _ => _.Length == 2 && _[0].Key == "prefix:a" && _[0].Value == "x" && _[1].Key == "prefix:b" && _[1].Value == "y";
wrapper.StringSet(values, When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.StringSet(It.Is(valid), When.Exists, CommandFlags.HighPriority));
wrapper.StringSet(values, When.Exists, CommandFlags.None);
mock.Verify(_ => _.StringSet(It.Is(valid), When.Exists, CommandFlags.None));
}
[Fact]
public void StringSetBit()
{
wrapper.StringSetBit("key", 123, true, CommandFlags.HighPriority);
mock.Verify(_ => _.StringSetBit("prefix:key", 123, true, CommandFlags.HighPriority));
wrapper.StringSetBit("key", 123, true, CommandFlags.None);
mock.Verify(_ => _.StringSetBit("prefix:key", 123, true, CommandFlags.None));
}
[Fact]
public void StringSetRange()
{
wrapper.StringSetRange("key", 123, "value", CommandFlags.HighPriority);
mock.Verify(_ => _.StringSetRange("prefix:key", 123, "value", CommandFlags.HighPriority));
wrapper.StringSetRange("key", 123, "value", CommandFlags.None);
mock.Verify(_ => _.StringSetRange("prefix:key", 123, "value", CommandFlags.None));
}
}
}
tests/StackExchange.Redis.Tests/TransactionWrapperTests.cs
View file @ c72ffa84
......@@ -75,15 +75,15 @@ public void AddCondition_StringNotEqual()
[Fact]
public void ExecuteAsync()
{
wrapper.ExecuteAsync(CommandFlags.HighPriority);
mock.Verify(_ => _.ExecuteAsync(CommandFlags.HighPriority), Times.Once());
wrapper.ExecuteAsync(CommandFlags.None);
mock.Verify(_ => _.ExecuteAsync(CommandFlags.None), Times.Once());
}
[Fact]
public void Execute()
{
wrapper.Execute(CommandFlags.HighPriority);
mock.Verify(_ => _.Execute(CommandFlags.HighPriority), Times.Once());
wrapper.Execute(CommandFlags.None);
mock.Verify(_ => _.Execute(CommandFlags.None), Times.Once());
}
}
#pragma warning restore RCS1047 // Non-asynchronous method name should not end with 'Async'.
......
tests/StackExchange.Redis.Tests/WrapperBaseTests.cs
View file @ c72ffa84
......@@ -26,145 +26,145 @@ public WrapperBaseTests()
[Fact]
public void DebugObjectAsync()
{
wrapper.DebugObjectAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.DebugObjectAsync("prefix:key", CommandFlags.HighPriority));
wrapper.DebugObjectAsync("key", CommandFlags.None);
mock.Verify(_ => _.DebugObjectAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void HashDecrementAsync_1()
{
wrapper.HashDecrementAsync("key", "hashField", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.HashDecrementAsync("prefix:key", "hashField", 123, CommandFlags.HighPriority));
wrapper.HashDecrementAsync("key", "hashField", 123, CommandFlags.None);
mock.Verify(_ => _.HashDecrementAsync("prefix:key", "hashField", 123, CommandFlags.None));
}
[Fact]
public void HashDecrementAsync_2()
{
wrapper.HashDecrementAsync("key", "hashField", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.HashDecrementAsync("prefix:key", "hashField", 1.23, CommandFlags.HighPriority));
wrapper.HashDecrementAsync("key", "hashField", 1.23, CommandFlags.None);
mock.Verify(_ => _.HashDecrementAsync("prefix:key", "hashField", 1.23, CommandFlags.None));
}
[Fact]
public void HashDeleteAsync_1()
{
wrapper.HashDeleteAsync("key", "hashField", CommandFlags.HighPriority);
mock.Verify(_ => _.HashDeleteAsync("prefix:key", "hashField", CommandFlags.HighPriority));
wrapper.HashDeleteAsync("key", "hashField", CommandFlags.None);
mock.Verify(_ => _.HashDeleteAsync("prefix:key", "hashField", CommandFlags.None));
}
[Fact]
public void HashDeleteAsync_2()
{
RedisValue[] hashFields = new RedisValue[0];
wrapper.HashDeleteAsync("key", hashFields, CommandFlags.HighPriority);
mock.Verify(_ => _.HashDeleteAsync("prefix:key", hashFields, CommandFlags.HighPriority));
wrapper.HashDeleteAsync("key", hashFields, CommandFlags.None);
mock.Verify(_ => _.HashDeleteAsync("prefix:key", hashFields, CommandFlags.None));
}
[Fact]
public void HashExistsAsync()
{
wrapper.HashExistsAsync("key", "hashField", CommandFlags.HighPriority);
mock.Verify(_ => _.HashExistsAsync("prefix:key", "hashField", CommandFlags.HighPriority));
wrapper.HashExistsAsync("key", "hashField", CommandFlags.None);
mock.Verify(_ => _.HashExistsAsync("prefix:key", "hashField", CommandFlags.None));
}
[Fact]
public void HashGetAllAsync()
{
wrapper.HashGetAllAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HashGetAllAsync("prefix:key", CommandFlags.HighPriority));
wrapper.HashGetAllAsync("key", CommandFlags.None);
mock.Verify(_ => _.HashGetAllAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void HashGetAsync_1()
{
wrapper.HashGetAsync("key", "hashField", CommandFlags.HighPriority);
mock.Verify(_ => _.HashGetAsync("prefix:key", "hashField", CommandFlags.HighPriority));
wrapper.HashGetAsync("key", "hashField", CommandFlags.None);
mock.Verify(_ => _.HashGetAsync("prefix:key", "hashField", CommandFlags.None));
}
[Fact]
public void HashGetAsync_2()
{
RedisValue[] hashFields = new RedisValue[0];
wrapper.HashGetAsync("key", hashFields, CommandFlags.HighPriority);
mock.Verify(_ => _.HashGetAsync("prefix:key", hashFields, CommandFlags.HighPriority));
wrapper.HashGetAsync("key", hashFields, CommandFlags.None);
mock.Verify(_ => _.HashGetAsync("prefix:key", hashFields, CommandFlags.None));
}
[Fact]
public void HashIncrementAsync_1()
{
wrapper.HashIncrementAsync("key", "hashField", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.HashIncrementAsync("prefix:key", "hashField", 123, CommandFlags.HighPriority));
wrapper.HashIncrementAsync("key", "hashField", 123, CommandFlags.None);
mock.Verify(_ => _.HashIncrementAsync("prefix:key", "hashField", 123, CommandFlags.None));
}
[Fact]
public void HashIncrementAsync_2()
{
wrapper.HashIncrementAsync("key", "hashField", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.HashIncrementAsync("prefix:key", "hashField", 1.23, CommandFlags.HighPriority));
wrapper.HashIncrementAsync("key", "hashField", 1.23, CommandFlags.None);
mock.Verify(_ => _.HashIncrementAsync("prefix:key", "hashField", 1.23, CommandFlags.None));
}
[Fact]
public void HashKeysAsync()
{
wrapper.HashKeysAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HashKeysAsync("prefix:key", CommandFlags.HighPriority));
wrapper.HashKeysAsync("key", CommandFlags.None);
mock.Verify(_ => _.HashKeysAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void HashLengthAsync()
{
wrapper.HashLengthAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HashLengthAsync("prefix:key", CommandFlags.HighPriority));
wrapper.HashLengthAsync("key", CommandFlags.None);
mock.Verify(_ => _.HashLengthAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void HashSetAsync_1()
{
HashEntry[] hashFields = new HashEntry[0];
wrapper.HashSetAsync("key", hashFields, CommandFlags.HighPriority);
mock.Verify(_ => _.HashSetAsync("prefix:key", hashFields, CommandFlags.HighPriority));
wrapper.HashSetAsync("key", hashFields, CommandFlags.None);
mock.Verify(_ => _.HashSetAsync("prefix:key", hashFields, CommandFlags.None));
}
[Fact]
public void HashSetAsync_2()
{
wrapper.HashSetAsync("key", "hashField", "value", When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.HashSetAsync("prefix:key", "hashField", "value", When.Exists, CommandFlags.HighPriority));
wrapper.HashSetAsync("key", "hashField", "value", When.Exists, CommandFlags.None);
mock.Verify(_ => _.HashSetAsync("prefix:key", "hashField", "value", When.Exists, CommandFlags.None));
}
[Fact]
public void HashValuesAsync()
{
wrapper.HashValuesAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HashValuesAsync("prefix:key", CommandFlags.HighPriority));
wrapper.HashValuesAsync("key", CommandFlags.None);
mock.Verify(_ => _.HashValuesAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void HyperLogLogAddAsync_1()
{
wrapper.HyperLogLogAddAsync("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogAddAsync("prefix:key", "value", CommandFlags.HighPriority));
wrapper.HyperLogLogAddAsync("key", "value", CommandFlags.None);
mock.Verify(_ => _.HyperLogLogAddAsync("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void HyperLogLogAddAsync_2()
{
var values = new RedisValue[0];
wrapper.HyperLogLogAddAsync("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogAddAsync("prefix:key", values, CommandFlags.HighPriority));
wrapper.HyperLogLogAddAsync("key", values, CommandFlags.None);
mock.Verify(_ => _.HyperLogLogAddAsync("prefix:key", values, CommandFlags.None));
}
[Fact]
public void HyperLogLogLengthAsync()
{
wrapper.HyperLogLogLengthAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogLengthAsync("prefix:key", CommandFlags.HighPriority));
wrapper.HyperLogLogLengthAsync("key", CommandFlags.None);
mock.Verify(_ => _.HyperLogLogLengthAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void HyperLogLogMergeAsync_1()
{
wrapper.HyperLogLogMergeAsync("destination", "first", "second", CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogMergeAsync("prefix:destination", "prefix:first", "prefix:second", CommandFlags.HighPriority));
wrapper.HyperLogLogMergeAsync("destination", "first", "second", CommandFlags.None);
mock.Verify(_ => _.HyperLogLogMergeAsync("prefix:destination", "prefix:first", "prefix:second", CommandFlags.None));
}
[Fact]
......@@ -172,29 +172,29 @@ public void HyperLogLogMergeAsync_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.HyperLogLogMergeAsync("destination", keys, CommandFlags.HighPriority);
mock.Verify(_ => _.HyperLogLogMergeAsync("prefix:destination", It.Is(valid), CommandFlags.HighPriority));
wrapper.HyperLogLogMergeAsync("destination", keys, CommandFlags.None);
mock.Verify(_ => _.HyperLogLogMergeAsync("prefix:destination", It.Is(valid), CommandFlags.None));
}
[Fact]
public void IdentifyEndpointAsync()
{
wrapper.IdentifyEndpointAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.IdentifyEndpointAsync("prefix:key", CommandFlags.HighPriority));
wrapper.IdentifyEndpointAsync("key", CommandFlags.None);
mock.Verify(_ => _.IdentifyEndpointAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void IsConnected()
{
wrapper.IsConnected("key", CommandFlags.HighPriority);
mock.Verify(_ => _.IsConnected("prefix:key", CommandFlags.HighPriority));
wrapper.IsConnected("key", CommandFlags.None);
mock.Verify(_ => _.IsConnected("prefix:key", CommandFlags.None));
}
[Fact]
public void KeyDeleteAsync_1()
{
wrapper.KeyDeleteAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyDeleteAsync("prefix:key", CommandFlags.HighPriority));
wrapper.KeyDeleteAsync("key", CommandFlags.None);
mock.Verify(_ => _.KeyDeleteAsync("prefix:key", CommandFlags.None));
}
[Fact]
......@@ -202,60 +202,60 @@ public void KeyDeleteAsync_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.KeyDeleteAsync(keys, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyDeleteAsync(It.Is(valid), CommandFlags.HighPriority));
wrapper.KeyDeleteAsync(keys, CommandFlags.None);
mock.Verify(_ => _.KeyDeleteAsync(It.Is(valid), CommandFlags.None));
}
[Fact]
public void KeyDumpAsync()
{
wrapper.KeyDumpAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyDumpAsync("prefix:key", CommandFlags.HighPriority));
wrapper.KeyDumpAsync("key", CommandFlags.None);
mock.Verify(_ => _.KeyDumpAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void KeyExistsAsync()
{
wrapper.KeyExistsAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyExistsAsync("prefix:key", CommandFlags.HighPriority));
wrapper.KeyExistsAsync("key", CommandFlags.None);
mock.Verify(_ => _.KeyExistsAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void KeyExpireAsync_1()
{
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.KeyExpireAsync("key", expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyExpireAsync("prefix:key", expiry, CommandFlags.HighPriority));
wrapper.KeyExpireAsync("key", expiry, CommandFlags.None);
mock.Verify(_ => _.KeyExpireAsync("prefix:key", expiry, CommandFlags.None));
}
[Fact]
public void KeyExpireAsync_2()
{
DateTime expiry = DateTime.Now;
wrapper.KeyExpireAsync("key", expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyExpireAsync("prefix:key", expiry, CommandFlags.HighPriority));
wrapper.KeyExpireAsync("key", expiry, CommandFlags.None);
mock.Verify(_ => _.KeyExpireAsync("prefix:key", expiry, CommandFlags.None));
}
[Fact]
public void KeyMigrateAsync()
{
EndPoint toServer = new IPEndPoint(IPAddress.Loopback, 123);
wrapper.KeyMigrateAsync("key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyMigrateAsync("prefix:key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.HighPriority));
wrapper.KeyMigrateAsync("key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.None);
mock.Verify(_ => _.KeyMigrateAsync("prefix:key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.None));
}
[Fact]
public void KeyMoveAsync()
{
wrapper.KeyMoveAsync("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyMoveAsync("prefix:key", 123, CommandFlags.HighPriority));
wrapper.KeyMoveAsync("key", 123, CommandFlags.None);
mock.Verify(_ => _.KeyMoveAsync("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void KeyPersistAsync()
{
wrapper.KeyPersistAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyPersistAsync("prefix:key", CommandFlags.HighPriority));
wrapper.KeyPersistAsync("key", CommandFlags.None);
mock.Verify(_ => _.KeyPersistAsync("prefix:key", CommandFlags.None));
}
[Fact]
......@@ -267,8 +267,8 @@ public Task KeyRandomAsync()
[Fact]
public void KeyRenameAsync()
{
wrapper.KeyRenameAsync("key", "newKey", When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyRenameAsync("prefix:key", "prefix:newKey", When.Exists, CommandFlags.HighPriority));
wrapper.KeyRenameAsync("key", "newKey", When.Exists, CommandFlags.None);
mock.Verify(_ => _.KeyRenameAsync("prefix:key", "prefix:newKey", When.Exists, CommandFlags.None));
}
[Fact]
......@@ -276,166 +276,166 @@ public void KeyRestoreAsync()
{
byte[] value = new byte[0];
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.KeyRestoreAsync("key", value, expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.KeyRestoreAsync("prefix:key", value, expiry, CommandFlags.HighPriority));
wrapper.KeyRestoreAsync("key", value, expiry, CommandFlags.None);
mock.Verify(_ => _.KeyRestoreAsync("prefix:key", value, expiry, CommandFlags.None));
}
[Fact]
public void KeyTimeToLiveAsync()
{
wrapper.KeyTimeToLiveAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyTimeToLiveAsync("prefix:key", CommandFlags.HighPriority));
wrapper.KeyTimeToLiveAsync("key", CommandFlags.None);
mock.Verify(_ => _.KeyTimeToLiveAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void KeyTypeAsync()
{
wrapper.KeyTypeAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.KeyTypeAsync("prefix:key", CommandFlags.HighPriority));
wrapper.KeyTypeAsync("key", CommandFlags.None);
mock.Verify(_ => _.KeyTypeAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void ListGetByIndexAsync()
{
wrapper.ListGetByIndexAsync("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.ListGetByIndexAsync("prefix:key", 123, CommandFlags.HighPriority));
wrapper.ListGetByIndexAsync("key", 123, CommandFlags.None);
mock.Verify(_ => _.ListGetByIndexAsync("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void ListInsertAfterAsync()
{
wrapper.ListInsertAfterAsync("key", "pivot", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.ListInsertAfterAsync("prefix:key", "pivot", "value", CommandFlags.HighPriority));
wrapper.ListInsertAfterAsync("key", "pivot", "value", CommandFlags.None);
mock.Verify(_ => _.ListInsertAfterAsync("prefix:key", "pivot", "value", CommandFlags.None));
}
[Fact]
public void ListInsertBeforeAsync()
{
wrapper.ListInsertBeforeAsync("key", "pivot", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.ListInsertBeforeAsync("prefix:key", "pivot", "value", CommandFlags.HighPriority));
wrapper.ListInsertBeforeAsync("key", "pivot", "value", CommandFlags.None);
mock.Verify(_ => _.ListInsertBeforeAsync("prefix:key", "pivot", "value", CommandFlags.None));
}
[Fact]
public void ListLeftPopAsync()
{
wrapper.ListLeftPopAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.ListLeftPopAsync("prefix:key", CommandFlags.HighPriority));
wrapper.ListLeftPopAsync("key", CommandFlags.None);
mock.Verify(_ => _.ListLeftPopAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void ListLeftPushAsync_1()
{
wrapper.ListLeftPushAsync("key", "value", When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.ListLeftPushAsync("prefix:key", "value", When.Exists, CommandFlags.HighPriority));
wrapper.ListLeftPushAsync("key", "value", When.Exists, CommandFlags.None);
mock.Verify(_ => _.ListLeftPushAsync("prefix:key", "value", When.Exists, CommandFlags.None));
}
[Fact]
public void ListLeftPushAsync_2()
{
RedisValue[] values = new RedisValue[0];
wrapper.ListLeftPushAsync("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.ListLeftPushAsync("prefix:key", values, CommandFlags.HighPriority));
wrapper.ListLeftPushAsync("key", values, CommandFlags.None);
mock.Verify(_ => _.ListLeftPushAsync("prefix:key", values, CommandFlags.None));
}
[Fact]
public void ListLengthAsync()
{
wrapper.ListLengthAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.ListLengthAsync("prefix:key", CommandFlags.HighPriority));
wrapper.ListLengthAsync("key", CommandFlags.None);
mock.Verify(_ => _.ListLengthAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void ListRangeAsync()
{
wrapper.ListRangeAsync("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.ListRangeAsync("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.ListRangeAsync("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.ListRangeAsync("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void ListRemoveAsync()
{
wrapper.ListRemoveAsync("key", "value", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.ListRemoveAsync("prefix:key", "value", 123, CommandFlags.HighPriority));
wrapper.ListRemoveAsync("key", "value", 123, CommandFlags.None);
mock.Verify(_ => _.ListRemoveAsync("prefix:key", "value", 123, CommandFlags.None));
}
[Fact]
public void ListRightPopAsync()
{
wrapper.ListRightPopAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.ListRightPopAsync("prefix:key", CommandFlags.HighPriority));
wrapper.ListRightPopAsync("key", CommandFlags.None);
mock.Verify(_ => _.ListRightPopAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void ListRightPopLeftPushAsync()
{
wrapper.ListRightPopLeftPushAsync("source", "destination", CommandFlags.HighPriority);
mock.Verify(_ => _.ListRightPopLeftPushAsync("prefix:source", "prefix:destination", CommandFlags.HighPriority));
wrapper.ListRightPopLeftPushAsync("source", "destination", CommandFlags.None);
mock.Verify(_ => _.ListRightPopLeftPushAsync("prefix:source", "prefix:destination", CommandFlags.None));
}
[Fact]
public void ListRightPushAsync_1()
{
wrapper.ListRightPushAsync("key", "value", When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.ListRightPushAsync("prefix:key", "value", When.Exists, CommandFlags.HighPriority));
wrapper.ListRightPushAsync("key", "value", When.Exists, CommandFlags.None);
mock.Verify(_ => _.ListRightPushAsync("prefix:key", "value", When.Exists, CommandFlags.None));
}
[Fact]
public void ListRightPushAsync_2()
{
RedisValue[] values = new RedisValue[0];
wrapper.ListRightPushAsync("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.ListRightPushAsync("prefix:key", values, CommandFlags.HighPriority));
wrapper.ListRightPushAsync("key", values, CommandFlags.None);
mock.Verify(_ => _.ListRightPushAsync("prefix:key", values, CommandFlags.None));
}
[Fact]
public void ListSetByIndexAsync()
{
wrapper.ListSetByIndexAsync("key", 123, "value", CommandFlags.HighPriority);
mock.Verify(_ => _.ListSetByIndexAsync("prefix:key", 123, "value", CommandFlags.HighPriority));
wrapper.ListSetByIndexAsync("key", 123, "value", CommandFlags.None);
mock.Verify(_ => _.ListSetByIndexAsync("prefix:key", 123, "value", CommandFlags.None));
}
[Fact]
public void ListTrimAsync()
{
wrapper.ListTrimAsync("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.ListTrimAsync("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.ListTrimAsync("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.ListTrimAsync("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void LockExtendAsync()
{
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.LockExtendAsync("key", "value", expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.LockExtendAsync("prefix:key", "value", expiry, CommandFlags.HighPriority));
wrapper.LockExtendAsync("key", "value", expiry, CommandFlags.None);
mock.Verify(_ => _.LockExtendAsync("prefix:key", "value", expiry, CommandFlags.None));
}
[Fact]
public void LockQueryAsync()
{
wrapper.LockQueryAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.LockQueryAsync("prefix:key", CommandFlags.HighPriority));
wrapper.LockQueryAsync("key", CommandFlags.None);
mock.Verify(_ => _.LockQueryAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void LockReleaseAsync()
{
wrapper.LockReleaseAsync("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.LockReleaseAsync("prefix:key", "value", CommandFlags.HighPriority));
wrapper.LockReleaseAsync("key", "value", CommandFlags.None);
mock.Verify(_ => _.LockReleaseAsync("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void LockTakeAsync()
{
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.LockTakeAsync("key", "value", expiry, CommandFlags.HighPriority);
mock.Verify(_ => _.LockTakeAsync("prefix:key", "value", expiry, CommandFlags.HighPriority));
wrapper.LockTakeAsync("key", "value", expiry, CommandFlags.None);
mock.Verify(_ => _.LockTakeAsync("prefix:key", "value", expiry, CommandFlags.None));
}
[Fact]
public void PublishAsync()
{
wrapper.PublishAsync("channel", "message", CommandFlags.HighPriority);
mock.Verify(_ => _.PublishAsync("prefix:channel", "message", CommandFlags.HighPriority));
wrapper.PublishAsync("channel", "message", CommandFlags.None);
mock.Verify(_ => _.PublishAsync("prefix:channel", "message", CommandFlags.None));
}
[Fact]
......@@ -445,8 +445,8 @@ public void ScriptEvaluateAsync_1()
RedisValue[] values = new RedisValue[0];
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.ScriptEvaluateAsync(hash, keys, values, CommandFlags.HighPriority);
mock.Verify(_ => _.ScriptEvaluateAsync(hash, It.Is(valid), values, CommandFlags.HighPriority));
wrapper.ScriptEvaluateAsync(hash, keys, values, CommandFlags.None);
mock.Verify(_ => _.ScriptEvaluateAsync(hash, It.Is(valid), values, CommandFlags.None));
}
[Fact]
......@@ -455,30 +455,30 @@ public void ScriptEvaluateAsync_2()
RedisValue[] values = new RedisValue[0];
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.ScriptEvaluateAsync("script", keys, values, CommandFlags.HighPriority);
mock.Verify(_ => _.ScriptEvaluateAsync("script", It.Is(valid), values, CommandFlags.HighPriority));
wrapper.ScriptEvaluateAsync("script", keys, values, CommandFlags.None);
mock.Verify(_ => _.ScriptEvaluateAsync("script", It.Is(valid), values, CommandFlags.None));
}
[Fact]
public void SetAddAsync_1()
{
wrapper.SetAddAsync("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.SetAddAsync("prefix:key", "value", CommandFlags.HighPriority));
wrapper.SetAddAsync("key", "value", CommandFlags.None);
mock.Verify(_ => _.SetAddAsync("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void SetAddAsync_2()
{
RedisValue[] values = new RedisValue[0];
wrapper.SetAddAsync("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.SetAddAsync("prefix:key", values, CommandFlags.HighPriority));
wrapper.SetAddAsync("key", values, CommandFlags.None);
mock.Verify(_ => _.SetAddAsync("prefix:key", values, CommandFlags.None));
}
[Fact]
public void SetCombineAndStoreAsync_1()
{
wrapper.SetCombineAndStoreAsync(SetOperation.Intersect, "destination", "first", "second", CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.HighPriority));
wrapper.SetCombineAndStoreAsync(SetOperation.Intersect, "destination", "first", "second", CommandFlags.None);
mock.Verify(_ => _.SetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.None));
}
[Fact]
......@@ -486,15 +486,15 @@ public void SetCombineAndStoreAsync_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.SetCombineAndStoreAsync(SetOperation.Intersect, "destination", keys, CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", It.Is(valid), CommandFlags.HighPriority));
wrapper.SetCombineAndStoreAsync(SetOperation.Intersect, "destination", keys, CommandFlags.None);
mock.Verify(_ => _.SetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", It.Is(valid), CommandFlags.None));
}
[Fact]
public void SetCombineAsync_1()
{
wrapper.SetCombineAsync(SetOperation.Intersect, "first", "second", CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombineAsync(SetOperation.Intersect, "prefix:first", "prefix:second", CommandFlags.HighPriority));
wrapper.SetCombineAsync(SetOperation.Intersect, "first", "second", CommandFlags.None);
mock.Verify(_ => _.SetCombineAsync(SetOperation.Intersect, "prefix:first", "prefix:second", CommandFlags.None));
}
[Fact]
......@@ -502,82 +502,82 @@ public void SetCombineAsync_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.SetCombineAsync(SetOperation.Intersect, keys, CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombineAsync(SetOperation.Intersect, It.Is(valid), CommandFlags.HighPriority));
wrapper.SetCombineAsync(SetOperation.Intersect, keys, CommandFlags.None);
mock.Verify(_ => _.SetCombineAsync(SetOperation.Intersect, It.Is(valid), CommandFlags.None));
}
[Fact]
public void SetContainsAsync()
{
wrapper.SetContainsAsync("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.SetContainsAsync("prefix:key", "value", CommandFlags.HighPriority));
wrapper.SetContainsAsync("key", "value", CommandFlags.None);
mock.Verify(_ => _.SetContainsAsync("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void SetLengthAsync()
{
wrapper.SetLengthAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.SetLengthAsync("prefix:key", CommandFlags.HighPriority));
wrapper.SetLengthAsync("key", CommandFlags.None);
mock.Verify(_ => _.SetLengthAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void SetMembersAsync()
{
wrapper.SetMembersAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.SetMembersAsync("prefix:key", CommandFlags.HighPriority));
wrapper.SetMembersAsync("key", CommandFlags.None);
mock.Verify(_ => _.SetMembersAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void SetMoveAsync()
{
wrapper.SetMoveAsync("source", "destination", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.SetMoveAsync("prefix:source", "prefix:destination", "value", CommandFlags.HighPriority));
wrapper.SetMoveAsync("source", "destination", "value", CommandFlags.None);
mock.Verify(_ => _.SetMoveAsync("prefix:source", "prefix:destination", "value", CommandFlags.None));
}
[Fact]
public void SetPopAsync_1()
{
wrapper.SetPopAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.SetPopAsync("prefix:key", CommandFlags.HighPriority));
wrapper.SetPopAsync("key", CommandFlags.None);
mock.Verify(_ => _.SetPopAsync("prefix:key", CommandFlags.None));
wrapper.SetPopAsync("key", 5, CommandFlags.HighPriority);
mock.Verify(_ => _.SetPopAsync("prefix:key", 5, CommandFlags.HighPriority));
wrapper.SetPopAsync("key", 5, CommandFlags.None);
mock.Verify(_ => _.SetPopAsync("prefix:key", 5, CommandFlags.None));
}
[Fact]
public void SetPopAsync_2()
{
wrapper.SetPopAsync("key", 5, CommandFlags.HighPriority);
mock.Verify(_ => _.SetPopAsync("prefix:key", 5, CommandFlags.HighPriority));
wrapper.SetPopAsync("key", 5, CommandFlags.None);
mock.Verify(_ => _.SetPopAsync("prefix:key", 5, CommandFlags.None));
}
[Fact]
public void SetRandomMemberAsync()
{
wrapper.SetRandomMemberAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.SetRandomMemberAsync("prefix:key", CommandFlags.HighPriority));
wrapper.SetRandomMemberAsync("key", CommandFlags.None);
mock.Verify(_ => _.SetRandomMemberAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void SetRandomMembersAsync()
{
wrapper.SetRandomMembersAsync("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.SetRandomMembersAsync("prefix:key", 123, CommandFlags.HighPriority));
wrapper.SetRandomMembersAsync("key", 123, CommandFlags.None);
mock.Verify(_ => _.SetRandomMembersAsync("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void SetRemoveAsync_1()
{
wrapper.SetRemoveAsync("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.SetRemoveAsync("prefix:key", "value", CommandFlags.HighPriority));
wrapper.SetRemoveAsync("key", "value", CommandFlags.None);
mock.Verify(_ => _.SetRemoveAsync("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void SetRemoveAsync_2()
{
RedisValue[] values = new RedisValue[0];
wrapper.SetRemoveAsync("key", values, CommandFlags.HighPriority);
mock.Verify(_ => _.SetRemoveAsync("prefix:key", values, CommandFlags.HighPriority));
wrapper.SetRemoveAsync("key", values, CommandFlags.None);
mock.Verify(_ => _.SetRemoveAsync("prefix:key", values, CommandFlags.None));
}
[Fact]
......@@ -586,11 +586,11 @@ public void SortAndStoreAsync()
RedisValue[] get = new RedisValue[] { "a", "#" };
Expression<Func<RedisValue[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "#";
wrapper.SortAndStoreAsync("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.HighPriority);
wrapper.SortAndStoreAsync("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.HighPriority);
wrapper.SortAndStoreAsync("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.None);
wrapper.SortAndStoreAsync("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.None);
mock.Verify(_ => _.SortAndStoreAsync("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", It.Is(valid), CommandFlags.HighPriority));
mock.Verify(_ => _.SortAndStoreAsync("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", It.Is(valid), CommandFlags.HighPriority));
mock.Verify(_ => _.SortAndStoreAsync("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", It.Is(valid), CommandFlags.None));
mock.Verify(_ => _.SortAndStoreAsync("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", It.Is(valid), CommandFlags.None));
}
[Fact]
......@@ -599,33 +599,33 @@ public void SortAsync()
RedisValue[] get = new RedisValue[] { "a", "#" };
Expression<Func<RedisValue[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "#";
wrapper.SortAsync("key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.HighPriority);
wrapper.SortAsync("key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.HighPriority);
wrapper.SortAsync("key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.None);
wrapper.SortAsync("key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.None);
mock.Verify(_ => _.SortAsync("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", It.Is(valid), CommandFlags.HighPriority));
mock.Verify(_ => _.SortAsync("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", It.Is(valid), CommandFlags.HighPriority));
mock.Verify(_ => _.SortAsync("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", It.Is(valid), CommandFlags.None));
mock.Verify(_ => _.SortAsync("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", It.Is(valid), CommandFlags.None));
}
[Fact]
public void SortedSetAddAsync_1()
{
wrapper.SortedSetAddAsync("key", "member", 1.23, When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetAddAsync("prefix:key", "member", 1.23, When.Exists, CommandFlags.HighPriority));
wrapper.SortedSetAddAsync("key", "member", 1.23, When.Exists, CommandFlags.None);
mock.Verify(_ => _.SortedSetAddAsync("prefix:key", "member", 1.23, When.Exists, CommandFlags.None));
}
[Fact]
public void SortedSetAddAsync_2()
{
SortedSetEntry[] values = new SortedSetEntry[0];
wrapper.SortedSetAddAsync("key", values, When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetAddAsync("prefix:key", values, When.Exists, CommandFlags.HighPriority));
wrapper.SortedSetAddAsync("key", values, When.Exists, CommandFlags.None);
mock.Verify(_ => _.SortedSetAddAsync("prefix:key", values, When.Exists, CommandFlags.None));
}
[Fact]
public void SortedSetCombineAndStoreAsync_1()
{
wrapper.SortedSetCombineAndStoreAsync(SetOperation.Intersect, "destination", "first", "second", Aggregate.Max, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", Aggregate.Max, CommandFlags.HighPriority));
wrapper.SortedSetCombineAndStoreAsync(SetOperation.Intersect, "destination", "first", "second", Aggregate.Max, CommandFlags.None);
mock.Verify(_ => _.SortedSetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", Aggregate.Max, CommandFlags.None));
}
[Fact]
......@@ -633,317 +633,317 @@ public void SortedSetCombineAndStoreAsync_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.SetCombineAndStoreAsync(SetOperation.Intersect, "destination", keys, CommandFlags.HighPriority);
mock.Verify(_ => _.SetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", It.Is(valid), CommandFlags.HighPriority));
wrapper.SetCombineAndStoreAsync(SetOperation.Intersect, "destination", keys, CommandFlags.None);
mock.Verify(_ => _.SetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", It.Is(valid), CommandFlags.None));
}
[Fact]
public void SortedSetDecrementAsync()
{
wrapper.SortedSetDecrementAsync("key", "member", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetDecrementAsync("prefix:key", "member", 1.23, CommandFlags.HighPriority));
wrapper.SortedSetDecrementAsync("key", "member", 1.23, CommandFlags.None);
mock.Verify(_ => _.SortedSetDecrementAsync("prefix:key", "member", 1.23, CommandFlags.None));
}
[Fact]
public void SortedSetIncrementAsync()
{
wrapper.SortedSetIncrementAsync("key", "member", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetIncrementAsync("prefix:key", "member", 1.23, CommandFlags.HighPriority));
wrapper.SortedSetIncrementAsync("key", "member", 1.23, CommandFlags.None);
mock.Verify(_ => _.SortedSetIncrementAsync("prefix:key", "member", 1.23, CommandFlags.None));
}
[Fact]
public void SortedSetLengthAsync()
{
wrapper.SortedSetLengthAsync("key", 1.23, 1.23, Exclude.Start, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetLengthAsync("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.HighPriority));
wrapper.SortedSetLengthAsync("key", 1.23, 1.23, Exclude.Start, CommandFlags.None);
mock.Verify(_ => _.SortedSetLengthAsync("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.None));
}
[Fact]
public void SortedSetLengthByValueAsync()
{
wrapper.SortedSetLengthByValueAsync("key", "min", "max", Exclude.Start, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetLengthByValueAsync("prefix:key", "min", "max", Exclude.Start, CommandFlags.HighPriority));
wrapper.SortedSetLengthByValueAsync("key", "min", "max", Exclude.Start, CommandFlags.None);
mock.Verify(_ => _.SortedSetLengthByValueAsync("prefix:key", "min", "max", Exclude.Start, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByRankAsync()
{
wrapper.SortedSetRangeByRankAsync("key", 123, 456, Order.Descending, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByRankAsync("prefix:key", 123, 456, Order.Descending, CommandFlags.HighPriority));
wrapper.SortedSetRangeByRankAsync("key", 123, 456, Order.Descending, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByRankAsync("prefix:key", 123, 456, Order.Descending, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByRankWithScoresAsync()
{
wrapper.SortedSetRangeByRankWithScoresAsync("key", 123, 456, Order.Descending, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByRankWithScoresAsync("prefix:key", 123, 456, Order.Descending, CommandFlags.HighPriority));
wrapper.SortedSetRangeByRankWithScoresAsync("key", 123, 456, Order.Descending, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByRankWithScoresAsync("prefix:key", 123, 456, Order.Descending, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByScoreAsync()
{
wrapper.SortedSetRangeByScoreAsync("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByScoreAsync("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRangeByScoreAsync("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByScoreAsync("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByScoreWithScoresAsync()
{
wrapper.SortedSetRangeByScoreWithScoresAsync("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByScoreWithScoresAsync("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRangeByScoreWithScoresAsync("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByScoreWithScoresAsync("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByValueAsync()
{
wrapper.SortedSetRangeByValueAsync("key", "min", "max", Exclude.Start, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByValueAsync("prefix:key", "min", "max", Exclude.Start, Order.Ascending, 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRangeByValueAsync("key", "min", "max", Exclude.Start, 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByValueAsync("prefix:key", "min", "max", Exclude.Start, Order.Ascending, 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRangeByValueDescAsync()
{
wrapper.SortedSetRangeByValueAsync("key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRangeByValueAsync("prefix:key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRangeByValueAsync("key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRangeByValueAsync("prefix:key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRankAsync()
{
wrapper.SortedSetRankAsync("key", "member", Order.Descending, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRankAsync("prefix:key", "member", Order.Descending, CommandFlags.HighPriority));
wrapper.SortedSetRankAsync("key", "member", Order.Descending, CommandFlags.None);
mock.Verify(_ => _.SortedSetRankAsync("prefix:key", "member", Order.Descending, CommandFlags.None));
}
[Fact]
public void SortedSetRemoveAsync_1()
{
wrapper.SortedSetRemoveAsync("key", "member", CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemoveAsync("prefix:key", "member", CommandFlags.HighPriority));
wrapper.SortedSetRemoveAsync("key", "member", CommandFlags.None);
mock.Verify(_ => _.SortedSetRemoveAsync("prefix:key", "member", CommandFlags.None));
}
[Fact]
public void SortedSetRemoveAsync_2()
{
RedisValue[] members = new RedisValue[0];
wrapper.SortedSetRemoveAsync("key", members, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemoveAsync("prefix:key", members, CommandFlags.HighPriority));
wrapper.SortedSetRemoveAsync("key", members, CommandFlags.None);
mock.Verify(_ => _.SortedSetRemoveAsync("prefix:key", members, CommandFlags.None));
}
[Fact]
public void SortedSetRemoveRangeByRankAsync()
{
wrapper.SortedSetRemoveRangeByRankAsync("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemoveRangeByRankAsync("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.SortedSetRemoveRangeByRankAsync("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.SortedSetRemoveRangeByRankAsync("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void SortedSetRemoveRangeByScoreAsync()
{
wrapper.SortedSetRemoveRangeByScoreAsync("key", 1.23, 1.23, Exclude.Start, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemoveRangeByScoreAsync("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.HighPriority));
wrapper.SortedSetRemoveRangeByScoreAsync("key", 1.23, 1.23, Exclude.Start, CommandFlags.None);
mock.Verify(_ => _.SortedSetRemoveRangeByScoreAsync("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.None));
}
[Fact]
public void SortedSetRemoveRangeByValueAsync()
{
wrapper.SortedSetRemoveRangeByValueAsync("key", "min", "max", Exclude.Start, CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetRemoveRangeByValueAsync("prefix:key", "min", "max", Exclude.Start, CommandFlags.HighPriority));
wrapper.SortedSetRemoveRangeByValueAsync("key", "min", "max", Exclude.Start, CommandFlags.None);
mock.Verify(_ => _.SortedSetRemoveRangeByValueAsync("prefix:key", "min", "max", Exclude.Start, CommandFlags.None));
}
[Fact]
public void SortedSetScoreAsync()
{
wrapper.SortedSetScoreAsync("key", "member", CommandFlags.HighPriority);
mock.Verify(_ => _.SortedSetScoreAsync("prefix:key", "member", CommandFlags.HighPriority));
wrapper.SortedSetScoreAsync("key", "member", CommandFlags.None);
mock.Verify(_ => _.SortedSetScoreAsync("prefix:key", "member", CommandFlags.None));
}
[Fact]
public void StreamAcknowledgeAsync_1()
{
wrapper.StreamAcknowledgeAsync("key", "group", "0-0", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamAcknowledgeAsync("prefix:key", "group", "0-0", CommandFlags.HighPriority));
wrapper.StreamAcknowledgeAsync("key", "group", "0-0", CommandFlags.None);
mock.Verify(_ => _.StreamAcknowledgeAsync("prefix:key", "group", "0-0", CommandFlags.None));
}
[Fact]
public void StreamAcknowledgeAsync_2()
{
var messageIds = new RedisValue[] { "0-0", "0-1", "0-2" };
wrapper.StreamAcknowledgeAsync("key", "group", messageIds, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamAcknowledgeAsync("prefix:key", "group", messageIds, CommandFlags.HighPriority));
wrapper.StreamAcknowledgeAsync("key", "group", messageIds, CommandFlags.None);
mock.Verify(_ => _.StreamAcknowledgeAsync("prefix:key", "group", messageIds, CommandFlags.None));
}
[Fact]
public void StreamAddAsync_1()
{
wrapper.StreamAddAsync("key", "field1", "value1", "*", 1000, true, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamAddAsync("prefix:key", "field1", "value1", "*", 1000, true, CommandFlags.HighPriority));
wrapper.StreamAddAsync("key", "field1", "value1", "*", 1000, true, CommandFlags.None);
mock.Verify(_ => _.StreamAddAsync("prefix:key", "field1", "value1", "*", 1000, true, CommandFlags.None));
}
[Fact]
public void StreamAddAsync_2()
{
var fields = new NameValueEntry[0];
wrapper.StreamAddAsync("key", fields, "*", 1000, true, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamAddAsync("prefix:key", fields, "*", 1000, true, CommandFlags.HighPriority));
wrapper.StreamAddAsync("key", fields, "*", 1000, true, CommandFlags.None);
mock.Verify(_ => _.StreamAddAsync("prefix:key", fields, "*", 1000, true, CommandFlags.None));
}
[Fact]
public void StreamClaimMessagesAsync()
{
var messageIds = new RedisValue[0];
wrapper.StreamClaimAsync("key", "group", "consumer", 1000, messageIds, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamClaimAsync("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.HighPriority));
wrapper.StreamClaimAsync("key", "group", "consumer", 1000, messageIds, CommandFlags.None);
mock.Verify(_ => _.StreamClaimAsync("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.None));
}
[Fact]
public void StreamClaimMessagesReturningIdsAsync()
{
var messageIds = new RedisValue[0];
wrapper.StreamClaimIdsOnlyAsync("key", "group", "consumer", 1000, messageIds, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamClaimIdsOnlyAsync("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.HighPriority));
wrapper.StreamClaimIdsOnlyAsync("key", "group", "consumer", 1000, messageIds, CommandFlags.None);
mock.Verify(_ => _.StreamClaimIdsOnlyAsync("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.None));
}
[Fact]
public void StreamConsumerInfoGetAsync()
{
wrapper.StreamConsumerInfoAsync("key", "group", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamConsumerInfoAsync("prefix:key", "group", CommandFlags.HighPriority));
wrapper.StreamConsumerInfoAsync("key", "group", CommandFlags.None);
mock.Verify(_ => _.StreamConsumerInfoAsync("prefix:key", "group", CommandFlags.None));
}
[Fact]
public void StreamConsumerGroupSetPositionAsync()
{
wrapper.StreamConsumerGroupSetPositionAsync("key", "group", StreamPosition.Beginning, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamConsumerGroupSetPositionAsync("prefix:key", "group", StreamPosition.Beginning, CommandFlags.HighPriority));
wrapper.StreamConsumerGroupSetPositionAsync("key", "group", StreamPosition.Beginning, CommandFlags.None);
mock.Verify(_ => _.StreamConsumerGroupSetPositionAsync("prefix:key", "group", StreamPosition.Beginning, CommandFlags.None));
}
[Fact]
public void StreamCreateConsumerGroupAsync()
{
wrapper.StreamCreateConsumerGroupAsync("key", "group", "0-0", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamCreateConsumerGroupAsync("prefix:key", "group", "0-0", CommandFlags.HighPriority));
wrapper.StreamCreateConsumerGroupAsync("key", "group", "0-0", CommandFlags.None);
mock.Verify(_ => _.StreamCreateConsumerGroupAsync("prefix:key", "group", "0-0", CommandFlags.None));
}
[Fact]
public void StreamGroupInfoGetAsync()
{
wrapper.StreamGroupInfoAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamGroupInfoAsync("prefix:key", CommandFlags.HighPriority));
wrapper.StreamGroupInfoAsync("key", CommandFlags.None);
mock.Verify(_ => _.StreamGroupInfoAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void StreamInfoGetAsync()
{
wrapper.StreamInfoAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamInfoAsync("prefix:key", CommandFlags.HighPriority));
wrapper.StreamInfoAsync("key", CommandFlags.None);
mock.Verify(_ => _.StreamInfoAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void StreamLengthAsync()
{
wrapper.StreamLengthAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamLengthAsync("prefix:key", CommandFlags.HighPriority));
wrapper.StreamLengthAsync("key", CommandFlags.None);
mock.Verify(_ => _.StreamLengthAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void StreamMessagesDeleteAsync()
{
var messageIds = new RedisValue[0] { };
wrapper.StreamDeleteAsync("key", messageIds, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamDeleteAsync("prefix:key", messageIds, CommandFlags.HighPriority));
wrapper.StreamDeleteAsync("key", messageIds, CommandFlags.None);
mock.Verify(_ => _.StreamDeleteAsync("prefix:key", messageIds, CommandFlags.None));
}
[Fact]
public void StreamDeleteConsumerAsync()
{
wrapper.StreamDeleteConsumerAsync("key", "group", "consumer", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamDeleteConsumerAsync("prefix:key", "group", "consumer", CommandFlags.HighPriority));
wrapper.StreamDeleteConsumerAsync("key", "group", "consumer", CommandFlags.None);
mock.Verify(_ => _.StreamDeleteConsumerAsync("prefix:key", "group", "consumer", CommandFlags.None));
}
[Fact]
public void StreamDeleteConsumerGroupAsync()
{
wrapper.StreamDeleteConsumerGroupAsync("key", "group", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamDeleteConsumerGroupAsync("prefix:key", "group", CommandFlags.HighPriority));
wrapper.StreamDeleteConsumerGroupAsync("key", "group", CommandFlags.None);
mock.Verify(_ => _.StreamDeleteConsumerGroupAsync("prefix:key", "group", CommandFlags.None));
}
[Fact]
public void StreamPendingInfoGetAsync()
{
wrapper.StreamPendingAsync("key", "group", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamPendingAsync("prefix:key", "group", CommandFlags.HighPriority));
wrapper.StreamPendingAsync("key", "group", CommandFlags.None);
mock.Verify(_ => _.StreamPendingAsync("prefix:key", "group", CommandFlags.None));
}
[Fact]
public void StreamPendingMessageInfoGetAsync()
{
wrapper.StreamPendingMessagesAsync("key", "group", 10, RedisValue.Null, "-", "+", CommandFlags.HighPriority);
mock.Verify(_ => _.StreamPendingMessagesAsync("prefix:key", "group", 10, RedisValue.Null, "-", "+", CommandFlags.HighPriority));
wrapper.StreamPendingMessagesAsync("key", "group", 10, RedisValue.Null, "-", "+", CommandFlags.None);
mock.Verify(_ => _.StreamPendingMessagesAsync("prefix:key", "group", 10, RedisValue.Null, "-", "+", CommandFlags.None));
}
[Fact]
public void StreamRangeAsync()
{
wrapper.StreamRangeAsync("key", "-", "+", null, Order.Ascending, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamRangeAsync("prefix:key", "-", "+", null, Order.Ascending, CommandFlags.HighPriority));
wrapper.StreamRangeAsync("key", "-", "+", null, Order.Ascending, CommandFlags.None);
mock.Verify(_ => _.StreamRangeAsync("prefix:key", "-", "+", null, Order.Ascending, CommandFlags.None));
}
[Fact]
public void StreamReadAsync_1()
{
var streamPositions = new StreamPosition[0] { };
wrapper.StreamReadAsync(streamPositions, null, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamReadAsync(streamPositions, null, CommandFlags.HighPriority));
wrapper.StreamReadAsync(streamPositions, null, CommandFlags.None);
mock.Verify(_ => _.StreamReadAsync(streamPositions, null, CommandFlags.None));
}
[Fact]
public void StreamReadAsync_2()
{
wrapper.StreamReadAsync("key", "0-0", null, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamReadAsync("prefix:key", "0-0", null, CommandFlags.HighPriority));
wrapper.StreamReadAsync("key", "0-0", null, CommandFlags.None);
mock.Verify(_ => _.StreamReadAsync("prefix:key", "0-0", null, CommandFlags.None));
}
[Fact]
public void StreamReadGroupAsync_1()
{
wrapper.StreamReadGroupAsync("key", "group", "consumer", StreamPosition.Beginning, 10, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamReadGroupAsync("prefix:key", "group", "consumer", StreamPosition.Beginning, 10, CommandFlags.HighPriority));
wrapper.StreamReadGroupAsync("key", "group", "consumer", StreamPosition.Beginning, 10, CommandFlags.None);
mock.Verify(_ => _.StreamReadGroupAsync("prefix:key", "group", "consumer", StreamPosition.Beginning, 10, CommandFlags.None));
}
[Fact]
public void StreamStreamReadGroupAsync_2()
{
var streamPositions = new StreamPosition[0] { };
wrapper.StreamReadGroupAsync(streamPositions, "group", "consumer", 10, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamReadGroupAsync(streamPositions, "group", "consumer", 10, CommandFlags.HighPriority));
wrapper.StreamReadGroupAsync(streamPositions, "group", "consumer", 10, CommandFlags.None);
mock.Verify(_ => _.StreamReadGroupAsync(streamPositions, "group", "consumer", 10, CommandFlags.None));
}
[Fact]
public void StreamTrimAsync()
{
wrapper.StreamTrimAsync("key", 1000, true, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamTrimAsync("prefix:key", 1000, true, CommandFlags.HighPriority));
wrapper.StreamTrimAsync("key", 1000, true, CommandFlags.None);
mock.Verify(_ => _.StreamTrimAsync("prefix:key", 1000, true, CommandFlags.None));
}
[Fact]
public void StringAppendAsync()
{
wrapper.StringAppendAsync("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.StringAppendAsync("prefix:key", "value", CommandFlags.HighPriority));
wrapper.StringAppendAsync("key", "value", CommandFlags.None);
mock.Verify(_ => _.StringAppendAsync("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void StringBitCountAsync()
{
wrapper.StringBitCountAsync("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.StringBitCountAsync("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.StringBitCountAsync("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.StringBitCountAsync("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void StringBitOperationAsync_1()
{
wrapper.StringBitOperationAsync(Bitwise.Xor, "destination", "first", "second", CommandFlags.HighPriority);
mock.Verify(_ => _.StringBitOperationAsync(Bitwise.Xor, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.HighPriority));
wrapper.StringBitOperationAsync(Bitwise.Xor, "destination", "first", "second", CommandFlags.None);
mock.Verify(_ => _.StringBitOperationAsync(Bitwise.Xor, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.None));
}
[Fact]
......@@ -951,36 +951,36 @@ public void StringBitOperationAsync_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.StringBitOperationAsync(Bitwise.Xor, "destination", keys, CommandFlags.HighPriority);
mock.Verify(_ => _.StringBitOperationAsync(Bitwise.Xor, "prefix:destination", It.Is(valid), CommandFlags.HighPriority));
wrapper.StringBitOperationAsync(Bitwise.Xor, "destination", keys, CommandFlags.None);
mock.Verify(_ => _.StringBitOperationAsync(Bitwise.Xor, "prefix:destination", It.Is(valid), CommandFlags.None));
}
[Fact]
public void StringBitPositionAsync()
{
wrapper.StringBitPositionAsync("key", true, 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.StringBitPositionAsync("prefix:key", true, 123, 456, CommandFlags.HighPriority));
wrapper.StringBitPositionAsync("key", true, 123, 456, CommandFlags.None);
mock.Verify(_ => _.StringBitPositionAsync("prefix:key", true, 123, 456, CommandFlags.None));
}
[Fact]
public void StringDecrementAsync_1()
{
wrapper.StringDecrementAsync("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.StringDecrementAsync("prefix:key", 123, CommandFlags.HighPriority));
wrapper.StringDecrementAsync("key", 123, CommandFlags.None);
mock.Verify(_ => _.StringDecrementAsync("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void StringDecrementAsync_2()
{
wrapper.StringDecrementAsync("key", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.StringDecrementAsync("prefix:key", 1.23, CommandFlags.HighPriority));
wrapper.StringDecrementAsync("key", 1.23, CommandFlags.None);
mock.Verify(_ => _.StringDecrementAsync("prefix:key", 1.23, CommandFlags.None));
}
[Fact]
public void StringGetAsync_1()
{
wrapper.StringGetAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetAsync("prefix:key", CommandFlags.HighPriority));
wrapper.StringGetAsync("key", CommandFlags.None);
mock.Verify(_ => _.StringGetAsync("prefix:key", CommandFlags.None));
}
[Fact]
......@@ -988,65 +988,65 @@ public void StringGetAsync_2()
{
RedisKey[] keys = new RedisKey[] { "a", "b" };
Expression<Func<RedisKey[], bool>> valid = _ => _.Length == 2 && _[0] == "prefix:a" && _[1] == "prefix:b";
wrapper.StringGetAsync(keys, CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetAsync(It.Is(valid), CommandFlags.HighPriority));
wrapper.StringGetAsync(keys, CommandFlags.None);
mock.Verify(_ => _.StringGetAsync(It.Is(valid), CommandFlags.None));
}
[Fact]
public void StringGetBitAsync()
{
wrapper.StringGetBitAsync("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetBitAsync("prefix:key", 123, CommandFlags.HighPriority));
wrapper.StringGetBitAsync("key", 123, CommandFlags.None);
mock.Verify(_ => _.StringGetBitAsync("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void StringGetRangeAsync()
{
wrapper.StringGetRangeAsync("key", 123, 456, CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetRangeAsync("prefix:key", 123, 456, CommandFlags.HighPriority));
wrapper.StringGetRangeAsync("key", 123, 456, CommandFlags.None);
mock.Verify(_ => _.StringGetRangeAsync("prefix:key", 123, 456, CommandFlags.None));
}
[Fact]
public void StringGetSetAsync()
{
wrapper.StringGetSetAsync("key", "value", CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetSetAsync("prefix:key", "value", CommandFlags.HighPriority));
wrapper.StringGetSetAsync("key", "value", CommandFlags.None);
mock.Verify(_ => _.StringGetSetAsync("prefix:key", "value", CommandFlags.None));
}
[Fact]
public void StringGetWithExpiryAsync()
{
wrapper.StringGetWithExpiryAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StringGetWithExpiryAsync("prefix:key", CommandFlags.HighPriority));
wrapper.StringGetWithExpiryAsync("key", CommandFlags.None);
mock.Verify(_ => _.StringGetWithExpiryAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void StringIncrementAsync_1()
{
wrapper.StringIncrementAsync("key", 123, CommandFlags.HighPriority);
mock.Verify(_ => _.StringIncrementAsync("prefix:key", 123, CommandFlags.HighPriority));
wrapper.StringIncrementAsync("key", 123, CommandFlags.None);
mock.Verify(_ => _.StringIncrementAsync("prefix:key", 123, CommandFlags.None));
}
[Fact]
public void StringIncrementAsync_2()
{
wrapper.StringIncrementAsync("key", 1.23, CommandFlags.HighPriority);
mock.Verify(_ => _.StringIncrementAsync("prefix:key", 1.23, CommandFlags.HighPriority));
wrapper.StringIncrementAsync("key", 1.23, CommandFlags.None);
mock.Verify(_ => _.StringIncrementAsync("prefix:key", 1.23, CommandFlags.None));
}
[Fact]
public void StringLengthAsync()
{
wrapper.StringLengthAsync("key", CommandFlags.HighPriority);
mock.Verify(_ => _.StringLengthAsync("prefix:key", CommandFlags.HighPriority));
wrapper.StringLengthAsync("key", CommandFlags.None);
mock.Verify(_ => _.StringLengthAsync("prefix:key", CommandFlags.None));
}
[Fact]
public void StringSetAsync_1()
{
TimeSpan expiry = TimeSpan.FromSeconds(123);
wrapper.StringSetAsync("key", "value", expiry, When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.StringSetAsync("prefix:key", "value", expiry, When.Exists, CommandFlags.HighPriority));
wrapper.StringSetAsync("key", "value", expiry, When.Exists, CommandFlags.None);
mock.Verify(_ => _.StringSetAsync("prefix:key", "value", expiry, When.Exists, CommandFlags.None));
}
[Fact]
......@@ -1054,22 +1054,22 @@ public void StringSetAsync_2()
{
KeyValuePair<RedisKey, RedisValue>[] values = new KeyValuePair<RedisKey, RedisValue>[] { new KeyValuePair<RedisKey, RedisValue>("a", "x"), new KeyValuePair<RedisKey, RedisValue>("b", "y") };
Expression<Func<KeyValuePair<RedisKey, RedisValue>[], bool>> valid = _ => _.Length == 2 && _[0].Key == "prefix:a" && _[0].Value == "x" && _[1].Key == "prefix:b" && _[1].Value == "y";
wrapper.StringSetAsync(values, When.Exists, CommandFlags.HighPriority);
mock.Verify(_ => _.StringSetAsync(It.Is(valid), When.Exists, CommandFlags.HighPriority));
wrapper.StringSetAsync(values, When.Exists, CommandFlags.None);
mock.Verify(_ => _.StringSetAsync(It.Is(valid), When.Exists, CommandFlags.None));
}
[Fact]
public void StringSetBitAsync()
{
wrapper.StringSetBitAsync("key", 123, true, CommandFlags.HighPriority);
mock.Verify(_ => _.StringSetBitAsync("prefix:key", 123, true, CommandFlags.HighPriority));
wrapper.StringSetBitAsync("key", 123, true, CommandFlags.None);
mock.Verify(_ => _.StringSetBitAsync("prefix:key", 123, true, CommandFlags.None));
}
[Fact]
public void StringSetRangeAsync()
{
wrapper.StringSetRangeAsync("key", 123, "value", CommandFlags.HighPriority);
mock.Verify(_ => _.StringSetRangeAsync("prefix:key", 123, "value", CommandFlags.HighPriority));
wrapper.StringSetRangeAsync("key", 123, "value", CommandFlags.None);
mock.Verify(_ => _.StringSetRangeAsync("prefix:key", 123, "value", CommandFlags.None));
}
#pragma warning restore RCS1047 // Non-asynchronous method name should not end with 'Async'.
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment