public void TryUpdateAndReleaseLockIfLockIdMatch_LargeLockTime_ExpireManuallyTest()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key1"] = "value1";
redisConn.Set(data, 900);
int lockTimeout = 120000;
DateTime lockTime = DateTime.Now;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout));
redisConn.TryUpdateAndReleaseLockIfLockIdMatch(lockId, dataFromRedis, 900);
// Get actual connection and check that lock is released
IDatabase actualConnection = GetRealRedisConnection(redisConn);
Assert.False(actualConnection.KeyExists(redisConn.Keys.LockKey));
actualConnection.KeyDelete(redisConn.Keys.DataKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeWriteLockAndGetData_UnableToLock()
{
string id = "session_id";
DateTime lockTime = DateTime.Now;
int lockTimeout = 90;
object lockId;
ISessionStateItemCollection data;
object[] returnFromRedis = { "Diff-lock-id", "", "15", true };
RedisConnectionWrapper.sharedConnection = A.Fake <RedisSharedConnection>();
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
redisConn.redisConnection = A.Fake <IRedisClientConnection>();
A.CallTo(() => redisConn.redisConnection.Eval(A <string> .Ignored, A <string[]> .That.Matches(s => s.Length == 3),
A <object[]> .That.Matches(o => o.Length == 2))).Returns(returnFromRedis);
A.CallTo(() => redisConn.redisConnection.GetLockId(A <object> .Ignored)).Returns("Diff-lock-id");
A.CallTo(() => redisConn.redisConnection.IsLocked(A <object> .Ignored)).Returns(true);
A.CallTo(() => redisConn.redisConnection.GetSessionTimeout(A <object> .Ignored)).Returns(15);
int sessionTimeout;
Assert.False(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out data, out sessionTimeout));
Assert.Equal("Diff-lock-id", lockId);
Assert.Null(data);
Assert.Equal(15, sessionTimeout);
A.CallTo(() => redisConn.redisConnection.Eval(A <string> .Ignored, A <string[]> .That.Matches(s => s.Length == 3),
A <object[]> .That.Matches(o => o.Length == 2))).MustHaveHappened();
A.CallTo(() => redisConn.redisConnection.GetLockId(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => redisConn.redisConnection.IsLocked(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => redisConn.redisConnection.GetSessionData(A <object> .Ignored)).MustNotHaveHappened();
A.CallTo(() => redisConn.redisConnection.GetSessionTimeout(A <object> .Ignored)).MustHaveHappened();
}
public void TryRemoveIfLockIdMatch_ValidLockIdAndRemove()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key"] = "value";
redisConn.Set(data, 900);
int lockTimeout = 900;
DateTime lockTime = DateTime.Now;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId.ToString());
Assert.Equal(1, dataFromRedis.Count);
redisConn.TryRemoveAndReleaseLockIfLockIdMatch(lockId);
// Get actual connection and get data from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
Assert.False(actualConnection.KeyExists(redisConn.Keys.DataKey));
// check lock removed from redis
Assert.False(actualConnection.KeyExists(redisConn.Keys.LockKey));
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeWriteLockAndGetData_WithNullData()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key"] = null;
redisConn.Set(data, 900);
DateTime lockTime = DateTime.Now;
int lockTimeout = 900;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId.ToString());
Assert.Equal(1, dataFromRedis.Count);
Assert.Null(dataFromRedis["key"]);
// Get actual connection and get data lock from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
string lockValueFromRedis = actualConnection.StringGet(redisConn.Keys.LockKey);
Assert.Equal(lockTime.Ticks.ToString(), lockValueFromRedis);
// remove data and lock from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
actualConnection.KeyDelete(redisConn.Keys.LockKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryReleaseLockIfLockIdMatch_InvalidWriteLockRelease()
{
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection();
data["key"] = "value";
redisConn.Set(data, 900);
int lockTimeout = 900;
DateTime lockTime = DateTime.Now;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId.ToString());
Assert.Equal(1, dataFromRedis.Count);
object wrongLockId = lockTime.AddSeconds(1).Ticks.ToString();
redisConn.TryReleaseLockIfLockIdMatch(wrongLockId, 900);
// Get actual connection and check that lock do not exists
IDatabase actualConnection = GetRealRedisConnection(redisConn);
string lockValueFromRedis = actualConnection.StringGet(redisConn.Keys.LockKey);
Assert.Equal(lockId, lockValueFromRedis);
// remove data from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
actualConnection.KeyDelete(redisConn.Keys.LockKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeWriteLockAndGetData_ExpireWriteLock()
{
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection();
data["key"] = "value";
redisConn.Set(data, 900);
int lockTimeout = 1;
DateTime lockTime = DateTime.Now;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId.ToString());
Assert.Equal(1, dataFromRedis.Count);
// Wait for 2 seconds so that lock will expire
System.Threading.Thread.Sleep(1100);
// Get actual connection and check that lock do not exists
IDatabase actualConnection = GetRealRedisConnection(redisConn);
string lockValueFromRedis = actualConnection.StringGet(redisConn.Keys.LockKey);
Assert.Equal(null, lockValueFromRedis);
// remove data from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeReadLockAndGetData_WithOtherWriteLock()
{
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection();
data["key"] = "value";
redisConn.Set(data, 900);
int lockTimeout = 900;
DateTime lockTime_1 = DateTime.Now;
object lockId_1;
ISessionStateItemCollection dataFromRedis_1;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime_1, lockTimeout, out lockId_1, out dataFromRedis_1, out sessionTimeout));
Assert.Equal(lockTime_1.Ticks.ToString(), lockId_1.ToString());
Assert.Equal(1, dataFromRedis_1.Count);
object lockId_2;
ISessionStateItemCollection dataFromRedis_2;
Assert.False(redisConn.TryCheckWriteLockAndGetData(out lockId_2, out dataFromRedis_2, out sessionTimeout));
Assert.Equal(lockTime_1.Ticks.ToString(), lockId_2.ToString());
Assert.Equal(null, dataFromRedis_2);
// Get actual connection
// remove data and lock from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
actualConnection.KeyDelete(redisConn.Keys.DataKey);
actualConnection.KeyDelete(redisConn.Keys.LockKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeWriteLockAndGetData_WriteLockWithOtherWriteLockWithSameLockId()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key"] = "value";
redisConn.Set(data, 900);
int lockTimeout = 900;
// Same LockId
DateTime lockTime = DateTime.Now;
// Takewrite lock successfully first time
object lockId_1;
ISessionStateItemCollection dataFromRedis_1;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId_1, out dataFromRedis_1, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId_1.ToString());
Assert.Equal(1, dataFromRedis_1.Count);
// try to take write lock and fail and get earlier lock id
object lockId_2;
ISessionStateItemCollection dataFromRedis_2;
Assert.False(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId_2, out dataFromRedis_2, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId_2.ToString());
Assert.Equal(null, dataFromRedis_2);
// Get actual connection
IDatabase actualConnection = GetRealRedisConnection(redisConn);
// remove data and lock from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
actualConnection.KeyDelete(redisConn.Keys.LockKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryUpdateIfLockIdMatch_WithOnlyUpdateAndNoDelete()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key1"] = "value1";
data["key2"] = "value2";
data["key3"] = "value3";
redisConn.Set(data, 900);
int lockTimeout = 900;
DateTime lockTime = DateTime.Now;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId.ToString());
Assert.Equal(3, dataFromRedis.Count);
Assert.Equal("value1", dataFromRedis["key1"]);
Assert.Equal("value2", dataFromRedis["key2"]);
Assert.Equal("value3", dataFromRedis["key3"]);
dataFromRedis["key2"] = "value2-updated";
redisConn.TryUpdateAndReleaseLockIfLockIdMatch(lockId, dataFromRedis, 900);
// Get actual connection and get data from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
HashEntry[] sessionDataFromRedis = actualConnection.HashGetAll(redisConn.Keys.DataKey);
Assert.Equal(3, sessionDataFromRedis.Length);
ChangeTrackingSessionStateItemCollection sessionDataFromRedisAsCollection = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
foreach (HashEntry entry in sessionDataFromRedis)
{
sessionDataFromRedisAsCollection[entry.Name] = RedisUtility.GetObjectFromBytes(entry.Value).ToString();
}
Assert.Equal("value1", sessionDataFromRedisAsCollection["key1"]);
Assert.Equal("value2-updated", sessionDataFromRedisAsCollection["key2"]);
Assert.Equal("value3", sessionDataFromRedisAsCollection["key3"]);
// check lock removed and remove data from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
Assert.False(actualConnection.KeyExists(redisConn.Keys.LockKey));
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeWriteLockAndGetData_WriteLockWithoutAnyOtherLock()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key"] = "value";
redisConn.Set(data, 900);
DateTime lockTime = DateTime.Now;
int lockTimeout = 900;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId.ToString());
ChangeTrackingSessionStateItemCollection dataFromGet = (ChangeTrackingSessionStateItemCollection)dataFromRedis;
Assert.Null(((ValueWrapper)dataFromGet.innerCollection["key"]).GetActualValue());
Assert.NotNull(((ValueWrapper)dataFromGet.innerCollection["key"]).GetSerializedvalue());
Assert.Single(dataFromRedis);
// this will desirialize value
Assert.Equal("value", dataFromRedis["key"]);
Assert.Equal("value", ((ValueWrapper)dataFromGet.innerCollection["key"]).GetActualValue());
// Get actual connection and get data lock from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
string lockValueFromRedis = actualConnection.StringGet(redisConn.Keys.LockKey);
Assert.Equal(lockTime.Ticks.ToString(), lockValueFromRedis);
// remove data and lock from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
actualConnection.KeyDelete(redisConn.Keys.LockKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeWriteLockAndGetData_Valid()
{
string id = "session_id";
DateTime lockTime = DateTime.Now;
int lockTimeout = 90;
object lockId;
ISessionStateItemCollection data;
object[] sessionData = { "Key", RedisUtility.GetBytesFromObject("value") };
object[] returnFromRedis = { lockTime.Ticks.ToString(), sessionData, "15", false };
ChangeTrackingSessionStateItemCollection sessionDataReturn = new ChangeTrackingSessionStateItemCollection();
sessionDataReturn["key"] = "value";
var mockRedisClient = A.Fake <IRedisClientConnection>();
A.CallTo(() => mockRedisClient.Eval(A <string> .Ignored, A <string[]> .That.Matches(s => s.Length == 3),
A <object[]> .That.Matches(o => o.Length == 2))).Returns(returnFromRedis);
A.CallTo(() => mockRedisClient.GetLockId(A <object> .Ignored)).Returns(lockTime.Ticks.ToString());
A.CallTo(() => mockRedisClient.IsLocked(A <object> .Ignored)).Returns(false);
A.CallTo(() => mockRedisClient.GetSessionData(A <object> .Ignored)).Returns(sessionDataReturn);
A.CallTo(() => mockRedisClient.GetSessionTimeout(A <object> .Ignored)).Returns(15);
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out data, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId);
Assert.Equal(1, data.Count);
Assert.Equal(15, sessionTimeout);
A.CallTo(() => mockRedisClient.Eval(A <string> .Ignored, A <string[]> .That.Matches(s => s.Length == 3),
A <object[]> .That.Matches(o => o.Length == 2))).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetLockId(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.IsLocked(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionData(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionTimeout(A <object> .Ignored)).MustHaveHappened();
}
public void TryUpdateIfLockIdMatch_ExpiryTime_OnValidData()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key"] = "value";
data["key1"] = "value1";
redisConn.Set(data, 900);
// Check that data shoud exists
int lockTimeout = 90;
DateTime lockTime = DateTime.Now;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout);
Assert.Equal(2, dataFromRedis.Count);
// Update expiry time to only 1 sec and than verify that.
redisConn.TryUpdateAndReleaseLockIfLockIdMatch(lockId, dataFromRedis, 1);
// Wait for 1.1 seconds so that data will expire
System.Threading.Thread.Sleep(1100);
// Get data blob from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
HashEntry[] sessionDataFromRedisAfterExpire = actualConnection.HashGetAll(redisConn.Keys.DataKey);
// Check that data shoud not be there
Assert.Equal(0, sessionDataFromRedisAfterExpire.Length);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeWriteLockAndGetData_UnableToLock()
{
string id = "session_id";
DateTime lockTime = DateTime.Now;
int lockTimeout = 90;
object lockId;
ISessionStateItemCollection data;
object[] returnFromRedis = { "Diff-lock-id", "", "15", true };
var mockRedisClient = A.Fake<IRedisClientConnection>();
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3),
A<object[]>.That.Matches(o => o.Length == 2))).Returns(returnFromRedis);
A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).Returns("Diff-lock-id");
A.CallTo(() => mockRedisClient.IsLocked(A<object>.Ignored)).Returns(true);
A.CallTo(() => mockRedisClient.GetSessionTimeout(A<object>.Ignored)).Returns(15);
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
int sessionTimeout;
Assert.False(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out data, out sessionTimeout));
Assert.Equal("Diff-lock-id", lockId);
Assert.Null(data);
Assert.Equal(15, sessionTimeout);
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3),
A<object[]>.That.Matches(o => o.Length == 2))).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.IsLocked(A<object>.Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionData(A<object>.Ignored)).MustNotHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionTimeout(A<object>.Ignored)).MustHaveHappened();
}
public void TryTakeWriteLockAndGetData_Valid()
{
string id = "session_id";
DateTime lockTime = DateTime.Now;
int lockTimeout = 90;
object lockId;
ISessionStateItemCollection data;
object[] sessionData = { "Key", RedisUtility.GetBytesFromObject("value") };
object[] returnFromRedis = { lockTime.Ticks.ToString(), sessionData, "15", false };
ChangeTrackingSessionStateItemCollection sessionDataReturn = new ChangeTrackingSessionStateItemCollection();
sessionDataReturn["key"] = "value";
var mockRedisClient = A.Fake<IRedisClientConnection>();
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3),
A<object[]>.That.Matches(o => o.Length == 2))).Returns(returnFromRedis);
A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).Returns(lockTime.Ticks.ToString());
A.CallTo(() => mockRedisClient.IsLocked(A<object>.Ignored)).Returns(false);
A.CallTo(() => mockRedisClient.GetSessionData(A<object>.Ignored)).Returns(sessionDataReturn);
A.CallTo(() => mockRedisClient.GetSessionTimeout(A<object>.Ignored)).Returns(15);
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out data, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId);
Assert.Equal(1, data.Count);
Assert.Equal(15, sessionTimeout);
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3),
A<object[]>.That.Matches(o => o.Length == 2))).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.IsLocked(A<object>.Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionData(A<object>.Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionTimeout(A<object>.Ignored)).MustHaveHappened();
}