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(); }