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_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));
}
public void AppendUpdatedOrNewItemsInList_EmptySessionItems()
{
ChangeTrackingSessionStateItemCollection sessionItems = new ChangeTrackingSessionStateItemCollection();
Assert.Equal(0, RedisUtility.AppendUpdatedOrNewItemsInList(sessionItems, null));
}
