public async Task UT_PubSub_SubscribeMultipleTypesAsync(RedisContext context)
{
var ch = $"{TestContext.CurrentContext.Test.MethodName}-{context.GetSerializer().GetType().Name}";
var users = GetUsers();
int objCount = 0;
int iDtoCount = 0;
await context.PubSub.SubscribeAsync <object>(ch, (c, o) => objCount ++);
await context.PubSub.SubscribeAsync <IDto>(ch, (c, o) => iDtoCount ++);
foreach (var t in users)
{
await context.PubSub.PublishAsync(ch, t);
}
await context.PubSub.PublishAsync(ch, new Exception("a different object type"));
await context.PubSub.PublishAsync(ch, users[0].Deparments[0]);
await context.PubSub.PublishAsync(ch, "some string");
await Task.Delay(500);
Assert.AreEqual(users.Count + 3, objCount);
Assert.AreEqual(users.Count + 1, iDtoCount);
await context.PubSub.UnsubscribeAsync(ch);
}
public void UT_PubSub_SubscribeWilcards(RedisContext context)
{
var ch = $"{TestContext.CurrentContext.Test.MethodName}-{context.GetSerializer().GetType().Name}";
var users = GetUsers();
var channels = new List <string>();
var objects = new List <User>();
context.PubSub.Subscribe <User>(ch + ".*", (c, o) =>
{
channels.Add(c);
objects.Add(o);
});
int user0count = 0;
context.PubSub.Subscribe <User>(ch + ".user0", (c, o) =>
{
user0count++;
});
context.PubSub.Publish(ch + ".user0", users[0]);
Thread.Sleep(100);
Thread.Sleep(100);
context.PubSub.Publish(ch + ".user1", users[1]);
Thread.Sleep(100);
Thread.Sleep(100);
Assert.AreEqual(2, channels.Count);
Assert.AreEqual(users[0].Id, objects[0].Id);
Assert.AreEqual(users[1].Id, objects[1].Id);
Assert.AreEqual(1, user0count);
context.PubSub.Unsubscribe(ch + ".*");
Thread.Sleep(1500);
context.PubSub.Publish(ch + ".user2", users[2]);
Assert.AreEqual(2, channels.Count);
Assert.AreEqual(1, user0count);
}
public void UT_PubSub_SingleUnsubscribe(RedisContext context)
{
var ch = $"{TestContext.CurrentContext.Test.MethodName}-{context.GetSerializer().GetType().Name}";
var users = GetUsers();
var usersList = new List <User>();
context.PubSub.Subscribe <User>(ch, (c, o) => usersList.Add(o));
foreach (var t in users)
{
context.PubSub.Publish(ch, t);
}
Thread.Sleep(500);
Assert.AreEqual(users.Count, usersList.Count);
context.PubSub.Unsubscribe(ch);
context.PubSub.Publish(ch, users[0]);
Assert.AreEqual(users.Count, usersList.Count);
}
public async Task UT_PubSub_SingleUnsubscribeAsync(RedisContext context)
{
var ch = $"{TestContext.CurrentContext.Test.MethodName}-{context.GetSerializer().GetType().Name}";
var users = GetUsers();
var usersList = new List <User>();
await context.PubSub.SubscribeAsync <User>(ch, (c, o) => usersList.Add(o));
foreach (var t in users)
{
await context.PubSub.PublishAsync(ch, t);
}
await Task.Delay(500);
Assert.AreEqual(users.Count, usersList.Count);
await context.PubSub.UnsubscribeAsync(ch);
await context.PubSub.PublishAsync(ch, users[0]);
Assert.AreEqual(users.Count, usersList.Count);
}
public void UT_PubSub_SubscribeMultipleTypes(RedisContext context)
{
var ch = $"{TestContext.CurrentContext.Test.MethodName}-{context.GetSerializer().GetType().Name}";
var users = GetUsers();
int objCount = 0;
int iDtoCount = 0;
context.PubSub.Subscribe <object>(ch, (c, o) => objCount++);
context.PubSub.Subscribe <IDto>(ch, (c, o) => iDtoCount++);
foreach (var t in users)
{
context.PubSub.Publish(ch, t);
}
context.PubSub.Publish(ch, new Exception("a different object type"));
context.PubSub.Publish(ch, users[0].Deparments[0]);
context.PubSub.Publish(ch, "some string");
Thread.Sleep(500);
Assert.AreEqual(users.Count + 3, objCount);
Assert.AreEqual(users.Count + 1, iDtoCount);
context.PubSub.Unsubscribe(ch);
}
public async Task UT_PubSub_SubscribeWilcardsAsync(RedisContext context)
{
var ch = $"{TestContext.CurrentContext.Test.MethodName}-{context.GetSerializer().GetType().Name}";
var users = GetUsers();
var channels = new List <string>();
var objects = new List <User>();
await context.PubSub.SubscribeAsync <User>(ch + ".*", (c, o) =>
{
channels.Add(c);
objects.Add(o);
});
int user0count = 0;
await context.PubSub.SubscribeAsync <User>(ch + ".user0", (c, o) =>
{
user0count++;
});
await context.PubSub.PublishAsync(ch + ".user0", users[0]);
await Task.Delay(200);
await context.PubSub.PublishAsync(ch + ".user1", users[1]);
await Task.Delay(200);
Assert.AreEqual(2, channels.Count);
Assert.AreEqual(users[0].Id, objects[0].Id);
Assert.AreEqual(users[1].Id, objects[1].Id);
Assert.AreEqual(1, user0count);
await context.PubSub.UnsubscribeAsync(ch + ".*");
await Task.Delay(1500);
await context.PubSub.PublishAsync(ch + ".user2", users[2]);
Assert.AreEqual(2, channels.Count);
Assert.AreEqual(1, user0count);
}
public void UT_PubSub_SingleSubscribe(RedisContext context)
{
var ch = $"{TestContext.CurrentContext.Test.MethodName}-{context.GetSerializer().GetType().Name}";
var users = GetUsers();
var usersList = new List <User>();
var locker = new object();
context.PubSub.Subscribe <User>(ch, (c, o) =>
{
lock (locker)
{
usersList.Add(o);
}
});
foreach (var t in users)
{
context.PubSub.Publish(ch, t);
}
Thread.Sleep(500);
Assert.AreEqual(users.Count, usersList.Count);
Assert.IsTrue(users.All(u => usersList.Any(ul => ul.Id == u.Id)));
context.PubSub.Unsubscribe(ch);
}
public async Task UT_CacheSerializer_Async(RedisContext context)
{
var kss = "short:string";
var kch = "char";
var kds = "decimal";
var kls = "long:string";
var kpBool = "primitive:bool";
var kpInt = "primitive:int";
var kpLong = "primitive:long";
var kpSingle = "primitive:single";
var kpUInt16 = "primitive:uint16";
var kpUInt32 = "primitive:uint32";
var kpUInt64 = "primitive:uint64";
var kby = "primitive:byte";
var ksby = "primitive:sbyte";
var ki16 = "primitive:int16";
var ki32 = "primitive:int32";
var kuip = "primitive:uintptr";
var kdbl = "primitive:double";
var kdt = "datetime";
context.Cache.Remove(new[] { kss, kls, kpBool, kpInt, kpLong, kpSingle, kpUInt16, kpUInt32, kpUInt64,
kch, kds, kdt, kby, ksby, ki16, ki32, kuip, kdbl });
var ss = "this is a short string";
var ls = @"UTF-8 is a character encoding capable of encoding all possible characters, or code points, in Unicode.
The encoding is variable-length and uses 8-bit code units. It was designed for backward compatibility with ASCII, and to avoid the complications of endianness and byte order marks in the alternative UTF-16 and UTF-32 encodings. The name is derived from: Universal Coded Character Set + Transformation Format—8-bit.";
await context.Cache.SetObjectAsync(kss, ss);
await context.Cache.SetObjectAsync(kls, ls);
await context.Cache.SetObjectAsync <char>(kch, 'c');
await context.Cache.SetObjectAsync <Byte>(kby, Byte.MaxValue);
await context.Cache.SetObjectAsync <SByte>(ksby, SByte.MaxValue);
await context.Cache.SetObjectAsync <Int16>(ki16, Int16.MaxValue);
await context.Cache.SetObjectAsync <Int32>(ki32, Int32.MaxValue);
await context.Cache.SetObjectAsync <UIntPtr>(kuip, UIntPtr.Zero);
await context.Cache.SetObjectAsync <Double>(kdbl, Double.NegativeInfinity);
await context.Cache.SetObjectAsync <bool>(kpBool, true);
await context.Cache.SetObjectAsync <int>(kpInt, int.MaxValue);
await context.Cache.SetObjectAsync <Int64>(kpLong, Int64.MaxValue);
var now = DateTime.Now;
await context.Cache.SetObjectAsync <DateTime>(kdt, now);
await context.Cache.SetObjectAsync <Single>(kpSingle, Single.MaxValue);
await context.Cache.SetObjectAsync <UInt16>(kpUInt16, UInt16.MaxValue);
await context.Cache.SetObjectAsync <UInt32>(kpUInt32, UInt32.MaxValue);
await context.Cache.SetObjectAsync <UInt64>(kpUInt64, UInt64.MaxValue);
await context.Cache.SetObjectAsync <decimal>(kds, decimal.MaxValue);
var ss_ = context.Cache.GetObject <string>(kss);
var ls_ = context.Cache.GetObject <string>(kls);
var pInt_ = context.Cache.GetObject <int>(kpInt);
var pLong_ = context.Cache.GetObject <Int64>(kpLong);
var pSingle_ = context.Cache.GetObject <Single>(kpSingle);
var pUint16_ = context.Cache.GetObject <UInt16>(kpUInt16);
var pUint32_ = context.Cache.GetObject <UInt32>(kpUInt32);
UInt64 pUint64_ = 0;
if (context.GetSerializer().GetType() != typeof(JsonSerializer))
{
pUint64_ = context.Cache.GetObject <UInt64>(kpUInt64);
}
var kch_ = context.Cache.GetObject <char>(kch);
var kds_ = context.Cache.GetObject <decimal>(kds);
var kdt_ = context.Cache.GetObject <DateTime>(kdt);
var kby_ = context.Cache.GetObject <Byte>(kby);
var ksby_ = context.Cache.GetObject <SByte>(ksby);
var ki16_ = context.Cache.GetObject <Int16>(ki16);
var ki32_ = context.Cache.GetObject <Int32>(ki32);
var kuip_ = context.Cache.GetObject <UIntPtr>(kuip);
var kdbl_ = context.Cache.GetObject <Double>(kdbl);
var kpBool_ = context.Cache.GetObject <bool>(kpBool);
Assert.AreEqual(ss, ss_);
Assert.AreEqual(ls, ls_);
Assert.AreEqual('c', kch_);
Assert.IsTrue((now - kdt_).TotalMilliseconds < 0.001);
Assert.AreEqual(decimal.MaxValue, kds_);
Assert.AreEqual(Byte.MaxValue, kby_);
Assert.AreEqual(SByte.MaxValue, ksby_);
Assert.AreEqual(Int16.MaxValue, ki16_);
Assert.AreEqual(Int32.MaxValue, ki32_);
Assert.AreEqual(UIntPtr.Zero, kuip_);
Assert.AreEqual(Double.NegativeInfinity, kdbl_);
Assert.AreEqual(int.MaxValue, pInt_);
Assert.AreEqual(long.MaxValue, pLong_);
Assert.AreEqual(Single.Parse(Single.MaxValue.ToString("F")), Single.Parse(pSingle_.ToString("F")));
Assert.AreEqual(UInt16.MaxValue, pUint16_);
Assert.AreEqual(UInt32.MaxValue, pUint32_);
if (context.GetSerializer().GetType() != typeof(JsonSerializer))
{
Assert.AreEqual(UInt64.MaxValue, pUint64_);
}
Assert.AreEqual(true, kpBool_);
context.Cache.Remove(new[] { kss, kls, kpBool, kpInt, kpLong, kpSingle, kpUInt16, kpUInt32, kpUInt64,
kch, kds, kdt, kby, ksby, ki16, ki32, kuip, kdbl });
}
public async Task UT_Context_Dispose_Async(RedisContext context)
{
var ctx = new RedisContext(context.GetConnectionMultiplexer().Configuration, context.GetSerializer());
await ctx.Cache.SetObjectAsync("key", "value");
ctx.Dispose();
await context.Cache.RemoveAsync("key");
Assert.ThrowsAsync <ObjectDisposedException>(async() => await ctx.Cache.SetObjectAsync("key", "value2"));
}