public void GetItemExclusive_RecordFound() { Utility.SetConfigUtilityToDefault(); string id = "session-id"; bool locked; TimeSpan lockAge; object lockId = null; SessionStateActions actions; ISessionStateItemCollection sessionStateItemCollection = new ChangeTrackingSessionStateItemCollection(); sessionStateItemCollection["session-key"] = "session-value"; SessionStateStoreData sssd = new SessionStateStoreData(sessionStateItemCollection, null, 15); ISessionStateItemCollection sessionData = new ChangeTrackingSessionStateItemCollection(); sessionData["session-key"] = "session-value"; ISessionStateItemCollection mockSessionData = null; object mockLockId = 0; int mockSessionTimeout; int sessionTimeout = (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes; var mockCache = A.Fake<ICacheConnection>(); A.CallTo(() => mockCache.TryTakeWriteLockAndGetData(A<DateTime>.Ignored, 90, out mockLockId, out mockSessionData, out mockSessionTimeout)).Returns(true).AssignsOutAndRefParameters(0, sessionData, (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes); RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider(); sessionStateStore.cache = mockCache; SessionStateStoreData sessionStateStoreData = sessionStateStore.GetItemExclusive(null, id, out locked, out lockAge, out lockId, out actions); A.CallTo(() => mockCache.TryTakeWriteLockAndGetData(A<DateTime>.Ignored, 90, out mockLockId, out sessionData, out sessionTimeout)).MustHaveHappened(); Assert.Equal(true, Utility.CompareSessionStateStoreData(sessionStateStoreData, sssd)); Assert.Equal(false, locked); Assert.Equal(TimeSpan.Zero, lockAge); Assert.Equal(actions, SessionStateActions.None); }
public void AppendUpdatedOrNewItemsInList_NothingUpdated() { ChangeTrackingSessionStateItemCollection sessionItems = new ChangeTrackingSessionStateItemCollection(); sessionItems["key"] = "val"; sessionItems.Remove("key"); Assert.Equal(0, RedisUtility.AppendUpdatedOrNewItemsInList(sessionItems, null)); }
public void TryCheckWriteLockAndGetData_Valid() { string id = "session_id"; object lockId; ISessionStateItemCollection data; object[] sessionData = { "Key", RedisUtility.GetBytesFromObject("value") }; object[] returnFromRedis = { "", sessionData, "15" }; 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 == 0))).Returns(returnFromRedis); A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).Returns(""); 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.TryCheckWriteLockAndGetData(out lockId, out data, out sessionTimeout)); Assert.Equal(null, 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 == 0))).MustHaveHappened(); A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).MustHaveHappened(); A.CallTo(() => mockRedisClient.GetSessionData(A<object>.Ignored)).MustHaveHappened(); A.CallTo(() => mockRedisClient.GetSessionTimeout(A<object>.Ignored)).MustHaveHappened(); }
public void AppendUpdatedOrNewItemsInList_SuccessfulUpdated() { ChangeTrackingSessionStateItemCollection sessionItems = new ChangeTrackingSessionStateItemCollection(); List<object> list = new List<object>(); sessionItems["key"] = "val"; Assert.Equal(1, RedisUtility.AppendUpdatedOrNewItemsInList(sessionItems, list)); Assert.Equal(2, list.Count); }
public void SetItem_NewItem() { ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); items["key"] = "value"; items[0] = "value2"; Assert.Equal(1, items.Count); Assert.Equal(1, items.GetModifiedKeys().Count); }
public void GetNewItemsAsList_WithSessionData() { ChangeTrackingSessionStateItemCollection sessionItems = new ChangeTrackingSessionStateItemCollection(); sessionItems["key"] = "val"; sessionItems["key1"] = "val1"; List<object> list = RedisUtility.GetNewItemsAsList(sessionItems); Assert.Equal(4, list.Count); }
public void RemoveAt_WrongKeyIndex() { ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); items["key"] = "value"; Assert.Equal(1, items.Count); Assert.Equal(0, items.GetDeletedKeys().Count); Assert.Equal(1, items.GetModifiedKeys().Count); Assert.Throws<ArgumentOutOfRangeException>(() => items.RemoveAt(1)); }
public void Clear_EmptyCollection() { ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); Assert.Equal(0, items.Count); Assert.Equal(0, items.GetDeletedKeys().Count); Assert.Equal(0, items.GetModifiedKeys().Count); items.Clear(); Assert.Equal(0, items.Count); Assert.Equal(0, items.GetDeletedKeys().Count); Assert.Equal(0, items.GetModifiedKeys().Count); }
public void RemoveAt_Successful() { ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); items["key"] = "value"; Assert.Equal(1, items.Count); Assert.Equal(0, items.GetDeletedKeys().Count); Assert.Equal(1, items.GetModifiedKeys().Count); items.RemoveAt(0); Assert.Equal(0, items.Count); Assert.Equal(1, items.GetDeletedKeys().Count); Assert.Equal(0, items.GetModifiedKeys().Count); }
public void Set_ValidData() { string sessionId = "session_id"; var mockRedisClient = A.Fake<IRedisClientConnection>(); RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null); RedisConnectionWrapper.sharedConnection.connection = mockRedisClient; RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), sessionId); ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(); data["key"] = "value"; redisConn.Set(data, 90); A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 2), A<object[]>.That.Matches(o => o.Length == 4))).MustHaveHappened(); }
public void Dirty_SetTrue() { ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); items["key1"] = "value1"; items["key2"] = "value2"; items["key3"] = "value3"; Assert.Equal(3, items.Count); Assert.Equal(0, items.GetDeletedKeys().Count); Assert.Equal(3, items.GetModifiedKeys().Count); items.Dirty = true; Assert.Equal(3, items.Count); Assert.Equal(0, items.GetDeletedKeys().Count); Assert.Equal(3, items.GetModifiedKeys().Count); }
public void Clear_Successful() { ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); items["key1"] = "value1"; items["key2"] = "value2"; items["key3"] = "value3"; Assert.Equal(3, items.Count); Assert.Equal(0, items.GetDeletedKeys().Count); Assert.Equal(3, items.GetModifiedKeys().Count); items.Clear(); Assert.Equal(0, items.Count); Assert.Equal(3, items.GetDeletedKeys().Count); Assert.Equal(0, items.GetModifiedKeys().Count); }
private bool SetPrepare(ISessionStateItemCollection data, int sessionTimeout, out string[] keyArgs, out object[] valueArgs) { keyArgs = null; valueArgs = null; if (data != null && data.Count > 0) { ChangeTrackingSessionStateItemCollection sessionItems = (ChangeTrackingSessionStateItemCollection)data; List <object> list = redisUtility.GetNewItemsAsList(sessionItems); if (list.Count > 0) { keyArgs = new string[] { Keys.DataKey, Keys.InternalKey }; valueArgs = new object[list.Count + 2]; // this +2 is for first 2 values in ARGV that we will add now valueArgs[0] = list.Count + 2; valueArgs[1] = sessionTimeout; list.CopyTo(valueArgs, 2); return(true); } } return(false); }
public void ImmutableObject_FetchDoNotMarksDirty() { // Initial insert to set up value ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); items["key1"] = "value1"; items["key2"] = 10; items.Dirty = false; Assert.Equal(2, items.Count); Assert.Equal(false, items.Dirty); Assert.Equal(0, items.GetModifiedKeys().Count); Assert.Equal(0, items.GetDeletedKeys().Count); // update value string key1 = (string)items["key1"]; int key2 = (int)items["key2"]; Assert.Equal(2, items.Count); Assert.Equal(0, items.GetModifiedKeys().Count); }
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.Equal(1, dataFromRedis.Count); // 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 GetEnumerator_AfterLazyDeserialization() { RedisUtility utility = new RedisUtility(Utility.GetDefaultConfigUtility()); ChangeTrackingSessionStateItemCollection items = Utility.GetChangeTrackingSessionStateItemCollection(); items.SetDataWithoutUpdatingModifiedKeys("k1", utility.GetBytesFromObject("v1")); items.SetDataWithoutUpdatingModifiedKeys("k2", utility.GetBytesFromObject("v2")); try { foreach (string key in items) { // read operation should not change value items.Keys var val = items[key]; } } catch (System.InvalidOperationException) { Assert.False(true, "Reading value from collection should not change it"); } }
public void GetItem_RecordFound() { Utility.SetConfigUtilityToDefault(); string id = "session-id"; bool locked; TimeSpan lockAge; object lockId = null; SessionStateActions actions; ISessionStateItemCollection sessionStateItemCollection = new ChangeTrackingSessionStateItemCollection(); sessionStateItemCollection["session-key"] = "session-value"; sessionStateItemCollection["SessionStateActions"] = SessionStateActions.None; SessionStateStoreData sssd = new SessionStateStoreData(sessionStateItemCollection, null, 15); ISessionStateItemCollection sessionData = new ChangeTrackingSessionStateItemCollection(); sessionData["session-key"] = "session-value"; sessionData["SessionStateActions"] = SessionStateActions.None; ISessionStateItemCollection mockSessionData = null; object mockLockId = 0; int mockSessionTimeout; int sessionTimeout = (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes; var mockCache = A.Fake <ICacheConnection>(); A.CallTo(() => mockCache.TryCheckWriteLockAndGetData(out mockLockId, out mockSessionData, out mockSessionTimeout)).Returns(true).AssignsOutAndRefParameters(0, sessionData, (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes); RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider(); sessionStateStore.cache = mockCache; SessionStateStoreData sessionStateStoreData = sessionStateStore.GetItem(null, id, out locked, out lockAge, out lockId, out actions); A.CallTo(() => mockCache.TryCheckWriteLockAndGetData(out mockLockId, out sessionData, out sessionTimeout)).MustHaveHappened(); Assert.Equal(true, Utility.CompareSessionStateStoreData(sessionStateStoreData, sssd)); Assert.Equal(false, locked); Assert.Equal(TimeSpan.Zero, lockAge); Assert.Equal(actions, SessionStateActions.None); }
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 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 InsertRemoveUpdate_Sequence() { // Initial insert to set up value ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); items["key1"] = "value1"; Assert.Equal("value1", items[0]); Assert.Equal(true, items.Dirty); items.Dirty = false; // remove key items.Remove("key1"); Assert.Equal(0, items.Count); Assert.Equal(1, items.GetDeletedKeys().Count); Assert.Equal(0, items.GetModifiedKeys().Count); // in same transaction insert same key than it should be update items["key1"] = "value1"; Assert.Equal(1, items.Count); Assert.Equal(0, items.GetDeletedKeys().Count); Assert.Equal(1, items.GetModifiedKeys().Count); }
public void Set_ExpireData() { using (RedisServer redisServer = new RedisServer()) { RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(); // Inserting data into redis server that expires after 1 second ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(); data["key"] = "value"; redisConn.Set(data, 1); // Wait for 2 seconds so that data will expire System.Threading.Thread.Sleep(1100); // Get actual connection and get data blob from redis IDatabase actualConnection = GetRealRedisConnection(redisConn); HashEntry[] sessionDataFromRedis = actualConnection.HashGetAll(redisConn.Keys.DataKey); // Check that data shoud not be there Assert.Equal(0, sessionDataFromRedis.Length); DisposeRedisConnectionWrapper(redisConn); } }
public void Set_ValidData_WithCustomSerializer() { // this also tests host:port config part ProviderConfiguration pc = Utility.GetDefaultConfigUtility(); pc.RedisSerializerType = typeof(TestSerializer).AssemblyQualifiedName; pc.ApplicationName = "APPTEST"; pc.Port = 6379; RedisUtility testSerializerRedisUtility = new RedisUtility(pc); using (RedisServer redisServer = new RedisServer()) { RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(pc); // Inserting data into redis server ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(testSerializerRedisUtility); data["key"] = "value"; data["key1"] = "value1"; redisConn.Set(data, 900); // Get actual connection and get data blob from redis IDatabase actualConnection = GetRealRedisConnection(redisConn); HashEntry[] sessionDataFromRedis = actualConnection.HashGetAll(redisConn.Keys.DataKey); // Check that data shoud be same as what inserted Assert.Equal(2, sessionDataFromRedis.Length); ChangeTrackingSessionStateItemCollection dataFromRedis = new ChangeTrackingSessionStateItemCollection(testSerializerRedisUtility); foreach (HashEntry entry in sessionDataFromRedis) { dataFromRedis[entry.Name] = testSerializerRedisUtility.GetObjectFromBytes(entry.Value).ToString(); } Assert.Equal("value", dataFromRedis["key"]); Assert.Equal("value1", dataFromRedis["key1"]); // remove data from redis actualConnection.KeyDelete(redisConn.Keys.DataKey); DisposeRedisConnectionWrapper(redisConn); } }
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 TryReleaseLockIfLockIdMatch_InvalidWriteLockRelease() { 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); 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 TryTakeReadLockAndGetData_WithOtherWriteLock() { 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_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.Single(dataFromRedis_1); 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.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 override void CreateUninitializedItem(HttpContext context, string id, int timeout) { try { if (LastException == null) { LogUtility.LogInfo("CreateUninitializedItem => Session Id: {0}, Session provider object: {1}.", id, this.GetHashCode()); ISessionStateItemCollection sessionData = new ChangeTrackingSessionStateItemCollection(); sessionData["SessionStateActions"] = SessionStateActions.InitializeItem; GetAccessToStore(id); // Converting timout from min to sec cache.Set(sessionData, (timeout * FROM_MIN_TO_SEC)); } } catch (Exception e) { LogUtility.LogError("CreateUninitializedItem => {0}", e.ToString()); LastException = e; if (configuration.ThrowOnError) { throw; } } }
public void Set_NullData() { // this also tests host:port config part ProviderConfiguration pc = Utility.GetDefaultConfigUtility(); pc.ApplicationName = "APPTEST"; pc.Port = 6379; using (RedisServer redisServer = new RedisServer()) { RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(pc); // Inserting data into redis server ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(); data["key"] = "value"; data["key1"] = null; redisConn.Set(data, 900); // Get actual connection and get data blob from redis IDatabase actualConnection = GetRealRedisConnection(redisConn); HashEntry[] sessionDataFromRedis = actualConnection.HashGetAll(redisConn.Keys.DataKey); // Check that data shoud be same as what inserted Assert.Equal(2, sessionDataFromRedis.Length); ChangeTrackingSessionStateItemCollection dataFromRedis = new ChangeTrackingSessionStateItemCollection(); foreach (HashEntry entry in sessionDataFromRedis) { dataFromRedis[entry.Name] = RedisUtility.GetObjectFromBytes(entry.Value); } Assert.Equal("value", dataFromRedis["key"]); Assert.Equal(null, dataFromRedis["key1"]); // remove data from redis actualConnection.KeyDelete(redisConn.Keys.DataKey); DisposeRedisConnectionWrapper(redisConn); } }
public void TryTakeWriteLockAndGetData_ExpireWriteLock() { 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 = 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 TryUpdateAndReleaseLockIfLockIdMatch_LargeLockTime_ExpireManuallyTest() { using (RedisServer redisServer = new RedisServer()) { RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(); // Inserting data into redis server ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(); 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_WriteLockWithoutAnyOtherLock() { using (RedisServer redisServer = new RedisServer()) { RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(); // Inserting data into redis server ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(); 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()); Assert.Equal(1, dataFromRedis.Count); // 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_WriteLockWithOtherWriteLockWithSameLockId() { 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; // 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 SetAndReleaseItemExclusive_OldItemInsertedItems() { Utility.SetConfigUtilityToDefault(); string id = "session-id"; ChangeTrackingSessionStateItemCollection sessionStateItemCollection = new ChangeTrackingSessionStateItemCollection(); sessionStateItemCollection["session-key"] = "session-value"; SessionStateStoreData sssd = new SessionStateStoreData(sessionStateItemCollection, null, 15); var mockCache = A.Fake<ICacheConnection>(); RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider(); sessionStateStore.cache = mockCache; sessionStateStore.SetAndReleaseItemExclusive(null, id, sssd, 7, false); A.CallTo(() => mockCache.TryUpdateAndReleaseLockIfLockIdMatch(A<object>.Ignored, A<ChangeTrackingSessionStateItemCollection>.That.Matches(o => o.Count == 1 && o.GetModifiedKeys().Count == 1 && o.GetDeletedKeys().Count == 0), 900)).MustHaveHappened(); }
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_WithoutAnyLock() { using (RedisServer redisServer = new RedisServer()) { RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(); // Inserting data into redis server ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(); data["key"] = "value"; redisConn.Set(data, 900); object lockId; ISessionStateItemCollection dataFromRedis; int sessionTimeout; Assert.True(redisConn.TryCheckWriteLockAndGetData(out lockId, out dataFromRedis, out sessionTimeout)); Assert.Equal(null, lockId); Assert.Equal(1, dataFromRedis.Count); Assert.Equal("value", dataFromRedis["key"]); // Get actual connection // remove data from redis IDatabase actualConnection = GetRealRedisConnection(redisConn); actualConnection.KeyDelete(redisConn.Keys.DataKey); DisposeRedisConnectionWrapper(redisConn); } }
public void MutableObject_FetchMarksDirty() { // Initial insert to set up value ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); items["key1"] = new StringBuilder("value1"); items.Dirty = false; Assert.Equal(1, items.Count); Assert.Equal(false, items.Dirty); Assert.Equal(0, items.GetModifiedKeys().Count); Assert.Equal(0, items.GetDeletedKeys().Count); // update value StringBuilder sb = (StringBuilder)items["key1"]; Assert.Equal(1, items.Count); Assert.Equal(1, items.GetModifiedKeys().Count); }
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); // 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 SetAndReleaseItemExclusive_NewItemValidItems() { Utility.SetConfigUtilityToDefault(); string id = "session-id"; ChangeTrackingSessionStateItemCollection sessionStateItemCollection = new ChangeTrackingSessionStateItemCollection(); sessionStateItemCollection["session-key"] = "session-value"; SessionStateStoreData sssd = new SessionStateStoreData(sessionStateItemCollection, null, 15); var mockCache = A.Fake<ICacheConnection>(); RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider(); sessionStateStore.cache = mockCache; sessionStateStore.SetAndReleaseItemExclusive(null, id, sssd, null, true); A.CallTo(() => mockCache.Set(A<ISessionStateItemCollection>.That.Matches( o => o.Count == 1 && o["session-key"] != null ), 900)).MustHaveHappened(); }
public void TryUpdateIfLockIdMatchPrepare_Valid_OneUpdateOneDelete() { string id = "session_id"; int sessionTimeout = 900; object lockId = DateTime.Now.Ticks; ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(); data["KeyDel"] = "valueDel"; data["Key"] = "value"; data.Remove("KeyDel"); var mockRedisClient = A.Fake<IRedisClientConnection>(); RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null); RedisConnectionWrapper.sharedConnection.connection = mockRedisClient; RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id); redisConn.TryUpdateAndReleaseLockIfLockIdMatch(lockId, data, sessionTimeout); A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3), A<object[]>.That.Matches( o => o.Length == 11 && o[2].Equals(1) && o[3].Equals(9) && o[4].Equals(9) && o[5].Equals(1) && o[6].Equals(10) && o[7].Equals(11) ))).MustHaveHappened(); }
public void GetNewItemsAsList_EmptySessionData() { ChangeTrackingSessionStateItemCollection sessionItems = new ChangeTrackingSessionStateItemCollection(); List<object> list = RedisUtility.GetNewItemsAsList(sessionItems); Assert.Equal(0, list.Count); }
public void TryUpdateIfLockIdMatch_WithValidUpdateAndDelete() { using (RedisServer redisServer = new RedisServer()) { RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(); // Inserting data into redis server ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(); 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"; dataFromRedis.Remove("key3"); 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(2, sessionDataFromRedis.Length); ChangeTrackingSessionStateItemCollection sessionDataFromRedisAsCollection = new ChangeTrackingSessionStateItemCollection(); foreach (HashEntry entry in sessionDataFromRedis) { sessionDataFromRedisAsCollection[entry.Name] = RedisUtility.GetObjectFromBytes(entry.Value).ToString(); } Assert.Equal("value1", sessionDataFromRedisAsCollection["key1"]); Assert.Equal("value2-updated", sessionDataFromRedisAsCollection["key2"]); // check lock removed and remove data from redis actualConnection.KeyDelete(redisConn.Keys.DataKey); Assert.False(actualConnection.KeyExists(redisConn.Keys.LockKey)); DisposeRedisConnectionWrapper(redisConn); } }
public void ImmutableObject_FetchDoNotMarksDirty() { // Initial insert to set up value ChangeTrackingSessionStateItemCollection items = new ChangeTrackingSessionStateItemCollection(); items["key1"] = "value1"; items["key2"] = 10; items.Dirty = false; Assert.Equal(2, items.Count); Assert.Equal(false, items.Dirty); Assert.Equal(0, items.GetModifiedKeys().Count); Assert.Equal(0, items.GetDeletedKeys().Count); // update value string key1 = (string) items["key1"]; int key2 = (int)items["key2"]; Assert.Equal(2, items.Count); Assert.Equal(0, items.GetModifiedKeys().Count); }
public void TryUpdateIfLockIdMatch_ExpiryTime_OnValidData() { using (RedisServer redisServer = new RedisServer()) { RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(); // Inserting data into redis server ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(); 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 TryRemoveIfLockIdMatch_ValidLockIdAndRemove() { 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); 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 AppendUpdatedOrNewItemsInList_EmptySessionItems() { ChangeTrackingSessionStateItemCollection sessionItems = new ChangeTrackingSessionStateItemCollection(); Assert.Equal(0, RedisUtility.AppendUpdatedOrNewItemsInList(sessionItems, null)); }
public void AppendRemoveItemsInList_EmptySessionItems() { ChangeTrackingSessionStateItemCollection sessionItems = Utility.GetChangeTrackingSessionStateItemCollection(); Assert.Equal(0, RedisUtility.AppendRemoveItemsInList(sessionItems, null)); }