public RedlockFactoryExtensionsTests()
{
_f = new Mock <IRedlockFactory>(
MockBehavior.Strict);
_defaultTtl = TimeSpan.FromMinutes(10);
_defaultMaxWait = 10;
_impl = TestRedlockImplementation.Create(TestRedlock.Instances(5, MemoryRedlockInstance.Create));
}
public RedlockFactoryTests()
{
var minValidity = TimeSpan.FromSeconds(10);
_mem = TestRedlock.Instances(3, i => new MemoryRedlockInstance(i.ToString(), (ttl, duration) => minValidity));
var now = new DateTime(2020, 07, 08, 1, 2, 3, DateTimeKind.Utc);
var impl = TestRedlockImplementation.Create(_mem);
_expectedValidUntil = new DateTime(2020, 07, 08, 1, 2, 13, DateTimeKind.Utc);
_f = new TestRedlockFactory(impl, () => now, NullLogger <RedlockFactory> .Instance);
}
public async Task TryLockAsync_ExceptionsOnLock_Quorum()
{
var mem = MemInstances(3);
var err = ErrInstances(2);
var l = await Redlock.TryLockAsync("r", "n", Ttl, TestRedlock.Instances(mem, err), _log);
Assert.NotNull(l);
Assert.All(mem, i => i.Contains("r", "n"));
var errorLogs = _log.Logs.Where(x => x.LogLevel == LogLevel.Error).ToArray();
Assert.Equal(2, errorLogs.Length);
Assert.Contains(errorLogs, e => e.Exception == err[0].TryLockAsyncException);
Assert.Contains(errorLogs, e => e.Exception == err[1].TryLockAsyncException);
}
public async Task TryExtendAsync_Quorum_Errors()
{
var err = ErrInstances(2, (ttl, duration) => ttl);
var mem = MemInstances(3, (ttl, duration) => ttl);
Lock("r", "n", mem);
var l = new Redlock("r", "n", Ttl, _now, TestRedlock.Instances(mem, err), _log);
var actualValidUntil = await l.TryExtendAsync(() => _now);
Assert.NotNull(actualValidUntil);
Assert.Equal(_now.Add(Ttl), actualValidUntil);
var errorLogs = _log.Logs.Where(x => x.LogLevel == LogLevel.Error).ToArray();
Assert.Equal(2, errorLogs.Length);
Assert.Contains(errorLogs, e => e.Exception == err[0].TryExtendAsyncException);
Assert.Contains(errorLogs, e => e.Exception == err[1].TryExtendAsyncException);
}
public async Task DisposeAsync_ExceptionsOnUnlock()
{
var mem = MemInstances(3);
var err = ErrInstances(2);
var l = new Redlock("r", "n", Ttl, _now, TestRedlock.Instances(mem, err), _log);
Lock("r", "n", mem);
await l.DisposeAsync();
Assert.All(mem, i => Assert.False(i.Contains("r", "n")));
var errorLogs = _log.Logs.Where(x => x.LogLevel == LogLevel.Error).ToArray();
Assert.Equal(2, errorLogs.Length);
Assert.Contains(errorLogs, e => e.Exception == err[0].UnlockAsyncException);
Assert.Contains(errorLogs, e => e.Exception == err[1].UnlockAsyncException);
}
public void TryLock_ExceptionsOnLock_NoQuorum()
{
var mem = MemInstances(2);
var err = ErrInstances(3);
var l = Redlock.TryLock("r", "n", Ttl, TestRedlock.Instances(mem, err), _log);
Assert.Null(l);
Assert.All(mem, i => Assert.False(i.Contains("r", "n")));
var errorLogs = _log.Logs.Where(x => x.LogLevel == LogLevel.Error).ToArray();
Assert.Equal(6, errorLogs.Length);
Assert.Contains(errorLogs, e => e.Exception == err[0].TryLockException);
Assert.Contains(errorLogs, e => e.Exception == err[1].TryLockException);
Assert.Contains(errorLogs, e => e.Exception == err[2].TryLockException);
Assert.Contains(errorLogs, e => e.Exception == err[0].UnlockException);
Assert.Contains(errorLogs, e => e.Exception == err[1].UnlockException);
Assert.Contains(errorLogs, e => e.Exception == err[2].UnlockException);
}
private static ImmutableArray <T> Instances <T>(int count, Func <int, T> create) => TestRedlock.Instances(count, create);
