public void GetItem_NullFromStore()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
bool locked;
TimeSpan lockAge;
object lockId = null;
SessionStateActions actions;
object mockLockId = 0;
ISessionStateItemCollection sessionData = null;
int sessionTimeout;
var mockCache = A.Fake<ICacheConnection>();
A.CallTo(() => mockCache.TryCheckWriteLockAndGetData(out mockLockId, out sessionData, out sessionTimeout)).Returns(true);
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();
A.CallTo(() => mockCache.TryReleaseLockIfLockIdMatch(mockLockId, A<int>.Ignored)).MustHaveHappened();
Assert.Equal(null, sessionStateStoreData);
Assert.Equal(false, locked);
Assert.Equal(TimeSpan.Zero, lockAge);
Assert.Equal(0, lockId);
}
public void CreateNewStoreData_WithEmptyStore()
{
Utility.SetConfigUtilityToDefault();
SessionStateStoreData sssd = new SessionStateStoreData(new ChangeTrackingSessionStateItemCollection(), null, 900);
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
Assert.Equal(true, Utility.CompareSessionStateStoreData(sessionStateStore.CreateNewStoreData(null, 900),sssd));
}
public void SessionReadCycle_Valid()
{
using (RedisServer redisServer = new RedisServer())
{
string sessionId = ResetRedisConnectionWrapperAndConfiguration();
// Inserting empty session with "SessionStateActions.InitializeItem" flag into redis server
RedisSessionStateProvider ssp = new RedisSessionStateProvider();
ssp.CreateUninitializedItem(null, sessionId, (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes);
// Get write lock and session from cache
bool locked;
TimeSpan lockAge;
object lockId;
SessionStateActions actions;
SessionStateStoreData storeData = ssp.GetItem(null, sessionId, out locked, out lockAge, out lockId, out actions);
// Get actual connection and varify lock and session timeout
IDatabase actualConnection = GetRealRedisConnection();
Assert.True(actualConnection.StringGet(ssp.cache.Keys.LockKey).IsNull);
Assert.Equal(((int)RedisSessionStateProvider.configuration.SessionTimeout.TotalSeconds).ToString(), actualConnection.HashGet(ssp.cache.Keys.InternalKey, "SessionTimeout").ToString());
// reset sessions timoue
ssp.ResetItemTimeout(null, sessionId);
// End request
ssp.EndRequest(null);
// remove data and lock from redis
DisposeRedisConnectionWrapper();
}
}
public void RemoveItem_Successful()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
var mockCache = A.Fake <ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
sessionStateStore.RemoveItem(null, id, "lockId", null);
A.CallTo(() => mockCache.TryRemoveAndReleaseLockIfLockIdMatch(A <object> .Ignored)).MustHaveHappened();
}
public async Task RemoveItemWithNullLockId()
{
using (RedisServer redisServer = new RedisServer())
{
string sessionId = ResetRedisConnectionWrapperAndConfiguration();
RedisSessionStateProvider ssp = new RedisSessionStateProvider();
await ssp.RemoveItemAsync(null, sessionId, null, null, CancellationToken.None);
DisposeRedisConnectionWrapper();
}
}
public void EndRequest_Successful()
{
Utility.SetConfigUtilityToDefault();
var mockCache = A.Fake<ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.sessionId = "session-id";
sessionStateStore.sessionLockId = "session-lock-id";
sessionStateStore.cache = mockCache;
sessionStateStore.EndRequest(null);
A.CallTo(() => mockCache.TryReleaseLockIfLockIdMatch(A<object>.Ignored, A<int>.Ignored)).MustHaveHappened();
}
public void ResetItemTimeout_Successful()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
var mockCache = A.Fake <ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
sessionStateStore.ResetItemTimeout(null, id);
A.CallTo(() => mockCache.UpdateExpiryTime(900)).MustHaveHappened();
}
public void EndRequest_Successful()
{
Utility.SetConfigUtilityToDefault();
var mockCache = A.Fake <ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.sessionId = "session-id";
sessionStateStore.sessionLockId = "session-lock-id";
sessionStateStore.cache = mockCache;
sessionStateStore.EndRequest(null);
A.CallTo(() => mockCache.TryReleaseLockIfLockIdMatch(A <object> .Ignored)).MustHaveHappened();
}
public async Task ReleaseItemExclusive_Successful()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
var mockCache = A.Fake <ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
await sessionStateStore.ReleaseItemExclusiveAsync(null, id, "lockId", CancellationToken.None);
A.CallTo(() => mockCache.TryReleaseLockIfLockIdMatch(A <object> .Ignored, A <int> .Ignored)).MustHaveHappened();
}
public void CreateUninitializedItem_Successful()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
var mockCache = A.Fake<ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
sessionStateStore.CreateUninitializedItem(null, id, 15);
A.CallTo(() => mockCache.Set(A<ISessionStateItemCollection>.That.Matches(
o => o.Count == 1 && SessionStateActions.InitializeItem.Equals(o["SessionStateActions"])
), 900)).MustHaveHappened();
}
public void SetAndReleaseItemExclusive_NewItemNullItems()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
SessionStateStoreData sssd = new SessionStateStoreData(null, 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 == 0), 900)).MustHaveHappened();
}
public void SetAndReleaseItemExclusive_OldItemNullItems()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
SessionStateStoreData sssd = new SessionStateStoreData(null, null, 900);
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 <ISessionStateItemCollection> .Ignored, 900)).MustNotHaveHappened();
}
public async Task ResetItemTimeout_Successful()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
var mockCache = A.Fake <ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
await sessionStateStore.ResetItemTimeoutAsync(null, id, CancellationToken.None);
A.CallTo(() => mockCache.UpdateExpiryTime(900)).MustHaveHappened();
}
public void CreateUninitializedItem_Successful()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
var mockCache = A.Fake <ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
sessionStateStore.CreateUninitializedItem(null, id, 15);
A.CallTo(() => mockCache.Set(A <ISessionStateItemCollection> .That.Matches(
o => o.Count == 1 && SessionStateActions.InitializeItem.Equals(o["SessionStateActions"])
), 900)).MustHaveHappened();
}
public void SessionTimoutChangeFromGlobalAspx()
{
using (RedisServer redisServer = new RedisServer())
{
string sessionId = ResetRedisConnectionWrapperAndConfiguration();
// Inserting empty session with "SessionStateActions.InitializeItem" flag into redis server
RedisSessionStateProvider ssp = new RedisSessionStateProvider();
ssp.CreateUninitializedItem(null, sessionId, (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes);
// Get write lock and session from cache
bool locked;
TimeSpan lockAge;
object lockId;
SessionStateActions actions;
SessionStateStoreData storeData = ssp.GetItemExclusive(null, sessionId, out locked, out lockAge, out lockId, out actions);
// Get actual connection and varify lock and session timeout
IDatabase actualConnection = GetRealRedisConnection();
Assert.Equal(lockId.ToString(), actualConnection.StringGet(ssp.cache.Keys.LockKey).ToString());
Assert.Equal(((int)RedisSessionStateProvider.configuration.SessionTimeout.TotalSeconds).ToString(), actualConnection.HashGet(ssp.cache.Keys.InternalKey, "SessionTimeout").ToString());
// setting data as done by any normal session operation
storeData.Items["key"] = "value";
storeData.Timeout = 5;
// session update
ssp.SetAndReleaseItemExclusive(null, sessionId, storeData, lockId, false);
Assert.Equal(1, actualConnection.HashGetAll(ssp.cache.Keys.DataKey).Length);
Assert.Equal("300", actualConnection.HashGet(ssp.cache.Keys.InternalKey, "SessionTimeout").ToString());
// reset sessions timoue
ssp.ResetItemTimeout(null, sessionId);
// End request
ssp.EndRequest(null);
// Verify that GetItemExclusive returns timeout from redis
bool locked_1;
TimeSpan lockAge_1;
object lockId_1;
SessionStateActions actions_1;
SessionStateStoreData storeData_1 = ssp.GetItemExclusive(null, sessionId, out locked_1, out lockAge_1, out lockId_1, out actions_1);
Assert.Equal(5, storeData_1.Timeout);
// remove data and lock from redis
DisposeRedisConnectionWrapper();
}
}
public async Task GetItemExclusive_RecordFound()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
bool locked;
TimeSpan lockAge;
object lockId = null;
SessionStateActions actions;
ISessionStateItemCollection sessionStateItemCollection = Utility.GetChangeTrackingSessionStateItemCollection();
sessionStateItemCollection["session-key"] = "session-value";
SessionStateStoreData sssd = new SessionStateStoreData(sessionStateItemCollection, null, 15);
ISessionStateItemCollection sessionData = Utility.GetChangeTrackingSessionStateItemCollection();
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;
GetItemResult data = await sessionStateStore.GetItemExclusiveAsync(null, id, CancellationToken.None);
sessionStateStoreData = data.Item;
locked = data.Locked;
lockAge = data.LockAge;
lockId = data.LockId;
actions = data.Actions;
A.CallTo(() => mockCache.TryTakeWriteLockAndGetData(A <DateTime> .Ignored, 90, out mockLockId, out sessionData, out sessionTimeout)).MustHaveHappened();
Assert.True(Utility.CompareSessionStateStoreData(sessionStateStoreData, sssd));
Assert.False(locked);
Assert.Equal(TimeSpan.Zero, lockAge);
Assert.Equal(SessionStateActions.None, actions);
}
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 SetAndReleaseItemExclusive_NewItemValidItems()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
ChangeTrackingSessionStateItemCollection sessionStateItemCollection = Utility.GetChangeTrackingSessionStateItemCollection();
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 async Task SessionTimoutChangeFromGlobalAspx()
{
using (RedisServer redisServer = new RedisServer())
{
string sessionId = ResetRedisConnectionWrapperAndConfiguration();
// Inserting empty session with "SessionStateActions.InitializeItem" flag into redis server
RedisSessionStateProvider ssp = new RedisSessionStateProvider();
await ssp.CreateUninitializedItemAsync(null, sessionId, (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes, CancellationToken.None);
// Get write lock and session from cache
GetItemResult data = await ssp.GetItemExclusiveAsync(null, sessionId, CancellationToken.None);
// Get actual connection and varify lock and session timeout
IDatabase actualConnection = GetRealRedisConnection();
Assert.Equal(data.LockId.ToString(), actualConnection.StringGet(ssp.cache.Keys.LockKey).ToString());
Assert.Equal(((int)RedisSessionStateProvider.configuration.SessionTimeout.TotalSeconds).ToString(), actualConnection.HashGet(ssp.cache.Keys.InternalKey, "SessionTimeout").ToString());
// setting data as done by any normal session operation
data.Item.Items["key"] = "value";
data.Item.Timeout = 5;
// session update
await ssp.SetAndReleaseItemExclusiveAsync(null, sessionId, data.Item, data.LockId, false, CancellationToken.None);
Assert.Single(actualConnection.HashGetAll(ssp.cache.Keys.DataKey));
Assert.Equal("300", actualConnection.HashGet(ssp.cache.Keys.InternalKey, "SessionTimeout").ToString());
// reset sessions timoue
await ssp.ResetItemTimeoutAsync(null, sessionId, CancellationToken.None);
// End request
await ssp.EndRequestAsync(null);
// Verify that GetItemExclusive returns timeout from redis
GetItemResult data_1 = await ssp.GetItemExclusiveAsync(null, sessionId, CancellationToken.None);
Assert.Equal(5, data.Item.Timeout);
// remove data and lock from redis
DisposeRedisConnectionWrapper();
}
}
public static Credentials ParseVCAP()
{
var redisSessionStateProvider = new RedisSessionStateProvider();
Credentials result = new Credentials();
const string dbServiceName = "mssql-dev";
const string redisServiceName = "p-redis";
string vcapServices = Environment.GetEnvironmentVariable("VCAP_SERVICES");
// if we are in the cloud and DB service was bound successfully...
if (vcapServices != null)
{
dynamic json = JsonConvert.DeserializeObject(vcapServices);
foreach (dynamic obj in json.Children())
{
switch (((string)obj.Name).ToLowerInvariant())
{
case dbServiceName:
{
dynamic credentials = (((JProperty)obj).Value[0] as dynamic).credentials;
result.DBHost = credentials != null ? credentials.host : null;
result.DBPort = credentials != null ? credentials.port : null;
result.DBUID = credentials != null ? credentials.username : null;
result.DBPassword = credentials != null ? credentials.password : null;
result.DBConnectionString = credentials != null ? credentials.connectionString : null;
}
break;
case redisServiceName:
{
dynamic credentials = (((JProperty)obj).Value[0] as dynamic).credentials;
result.RedisHost = credentials != null ? credentials.host : null;
result.RedisPort = credentials != null ? credentials.port : null;
result.RedisPassword = credentials != null ? credentials.password : null;
}
break;
default:
break;
}
}
}
return(result);
}
public async Task SetAndReleaseItemExclusive_OldItemRemovedItems()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
ChangeTrackingSessionStateItemCollection sessionStateItemCollection = Utility.GetChangeTrackingSessionStateItemCollection();
sessionStateItemCollection["session-key"] = "session-val";
sessionStateItemCollection.Remove("session-key");
SessionStateStoreData sssd = new SessionStateStoreData(sessionStateItemCollection, null, 15);
var mockCache = A.Fake <ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
await sessionStateStore.SetAndReleaseItemExclusiveAsync(null, id, sssd, 7, false, CancellationToken.None);
A.CallTo(() => mockCache.TryUpdateAndReleaseLock(A <object> .Ignored,
A <ChangeTrackingSessionStateItemCollection> .That.Matches(o => o.Count == 0 && o.GetModifiedKeys().Count == 0 && o.GetDeletedKeys().Count == 1), 900)).MustHaveHappened();
}
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 async Task GetItemExclusive_RecordLocked()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
bool locked;
TimeSpan lockAge;
object lockId = null;
SessionStateActions actions;
object mockLockId = 0;
ISessionStateItemCollection sessionData = null;
int sessionTimeout;
var mockCache = A.Fake <ICacheConnection>();
A.CallTo(() => mockCache.TryTakeWriteLockAndGetData(A <DateTime> .Ignored, 90, out mockLockId, out sessionData, out sessionTimeout)).Returns(false);
A.CallTo(() => mockCache.GetLockAge(A <object> .Ignored)).Returns(TimeSpan.Zero);
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
SessionStateStoreData sessionStateStoreData;
GetItemResult data = await sessionStateStore.GetItemExclusiveAsync(null, id, CancellationToken.None);
sessionStateStoreData = data.Item;
locked = data.Locked;
lockAge = data.LockAge;
lockId = data.LockId;
actions = data.Actions;
A.CallTo(() => mockCache.TryTakeWriteLockAndGetData(A <DateTime> .Ignored, 90, out mockLockId, out sessionData, out sessionTimeout)).MustHaveHappened();
A.CallTo(() => mockCache.GetLockAge(A <object> .Ignored)).MustHaveHappened();
Assert.Null(sessionStateStoreData);
Assert.True(locked);
}
public async Task GetItem_NullFromStore()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
bool locked;
TimeSpan lockAge;
object lockId = null;
SessionStateActions actions;
object mockLockId = 0;
ISessionStateItemCollection sessionData = null;
int sessionTimeout;
var mockCache = A.Fake <ICacheConnection>();
A.CallTo(() => mockCache.TryCheckWriteLockAndGetData(out mockLockId, out sessionData, out sessionTimeout)).Returns(true);
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
SessionStateStoreData sessionStateStoreData = null;
GetItemResult data = await sessionStateStore.GetItemAsync(null, id, CancellationToken.None);
sessionStateStoreData = data.Item;
locked = data.Locked;
lockAge = data.LockAge;
lockId = data.LockId;
actions = data.Actions;
A.CallTo(() => mockCache.TryCheckWriteLockAndGetData(out mockLockId, out sessionData, out sessionTimeout)).MustHaveHappened();
A.CallTo(() => mockCache.TryReleaseLockIfLockIdMatch(mockLockId, A <int> .Ignored)).MustHaveHappened();
Assert.Null(sessionStateStoreData);
Assert.False(locked);
Assert.Equal(TimeSpan.Zero, lockAge);
Assert.Equal(0, lockId);
}
public void Initialize_WithNullConfig()
{
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
Assert.Throws<ArgumentNullException>(() => sessionStateStore.Initialize(null, null));
}
public void ReleaseItemExclusive_Successful()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
var mockCache = A.Fake<ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
sessionStateStore.ReleaseItemExclusive(null, id, "lockId");
A.CallTo(() => mockCache.TryReleaseLockIfLockIdMatch(A<object>.Ignored, A<int>.Ignored)).MustHaveHappened();
}
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 SetAndReleaseItemExclusive_OldItemNullItems()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
SessionStateStoreData sssd = new SessionStateStoreData(null, null, 900);
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<ISessionStateItemCollection>.Ignored, 900)).MustNotHaveHappened();
}
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 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 Initialize_WithNullConfig()
{
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
Assert.Throws <ArgumentNullException>(() => sessionStateStore.Initialize(null, null));
}
public void GetItemExclusive_RecordLocked()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
bool locked;
TimeSpan lockAge;
object lockId = null;
SessionStateActions actions;
object mockLockId = 0;
ISessionStateItemCollection sessionData = null;
int sessionTimeout;
var mockCache = A.Fake<ICacheConnection>();
A.CallTo(() => mockCache.TryTakeWriteLockAndGetData(A<DateTime>.Ignored, 90, out mockLockId, out sessionData, out sessionTimeout)).Returns(false);
A.CallTo(() => mockCache.GetLockAge(A<object>.Ignored)).Returns(TimeSpan.Zero);
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();
A.CallTo(() => mockCache.GetLockAge(A<object>.Ignored)).MustHaveHappened();
Assert.Equal(null, sessionStateStoreData);
Assert.Equal(true, locked);
}
public void SessionTimoutChangeFromGlobalAspx()
{
using (RedisServer redisServer = new RedisServer())
{
string sessionId = ResetRedisConnectionWrapperAndConfiguration();
// Inserting empty session with "SessionStateActions.InitializeItem" flag into redis server
RedisSessionStateProvider ssp = new RedisSessionStateProvider();
ssp.CreateUninitializedItem(null, sessionId, (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes);
// Get write lock and session from cache
bool locked;
TimeSpan lockAge;
object lockId;
SessionStateActions actions;
SessionStateStoreData storeData = ssp.GetItemExclusive(null, sessionId, out locked, out lockAge, out lockId, out actions);
// Get actual connection and varify lock and session timeout
IDatabase actualConnection = GetRealRedisConnection();
Assert.Equal(lockId.ToString(), actualConnection.StringGet(ssp.cache.Keys.LockKey).ToString());
Assert.Equal(((int)RedisSessionStateProvider.configuration.SessionTimeout.TotalSeconds).ToString(), actualConnection.HashGet(ssp.cache.Keys.InternalKey, "SessionTimeout").ToString());
// setting data as done by any normal session operation
storeData.Items["key"] = "value";
storeData.Timeout = 5;
// session update
ssp.SetAndReleaseItemExclusive(null, sessionId, storeData, lockId, false);
Assert.Equal(1, actualConnection.HashGetAll(ssp.cache.Keys.DataKey).Length);
Assert.Equal("300", actualConnection.HashGet(ssp.cache.Keys.InternalKey, "SessionTimeout").ToString());
// reset sessions timoue
ssp.ResetItemTimeout(null, sessionId);
// End request
ssp.EndRequest(null);
// Verify that GetItemExclusive returns timeout from redis
bool locked_1;
TimeSpan lockAge_1;
object lockId_1;
SessionStateActions actions_1;
SessionStateStoreData storeData_1 = ssp.GetItemExclusive(null, sessionId, out locked_1, out lockAge_1, out lockId_1, out actions_1);
Assert.Equal(5, storeData_1.Timeout);
// remove data and lock from redis
DisposeRedisConnectionWrapper();
}
}
public void RemoveItemWithNullLockId()
{
using (RedisServer redisServer = new RedisServer())
{
string sessionId = ResetRedisConnectionWrapperAndConfiguration();
RedisSessionStateProvider ssp = new RedisSessionStateProvider();
ssp.RemoveItem(null, sessionId, null, null);
DisposeRedisConnectionWrapper();
}
}
public void ResetItemTimeout_Successful()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
var mockCache = A.Fake<ICacheConnection>();
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
sessionStateStore.ResetItemTimeout(null, id);
A.CallTo(() => mockCache.UpdateExpiryTime(900)).MustHaveHappened();
}
