示例#1
0
		/// <summary>
		/// Uses reflection to determine if the MongoDB Session State Provider is holding onto a sessionId
		/// in it's memory cache object.
		/// </summary>
		/// <param name="mongoSessionStateProvider">The provider to use</param>
		/// <param name="sessionId">The session id to query</param>
		/// <param name="dataFromCache">The data retrieved from the cache</param>
		/// <returns>True if the session exists in the provider's cache</returns>
		private bool CheckSessionExistsInCache(MongoDBSessionStateProvider mongoSessionStateProvider, string sessionId, out ISessionStateData dataFromCache)
		{
			var mongoSessionStateProviderBaseType = mongoSessionStateProvider.GetType().BaseType;

			bool objectExistsInCache = (bool)mongoSessionStateProviderBaseType
										.GetMethod("CacheContains", BindingFlags.NonPublic | BindingFlags.Instance)
										.Invoke(mongoSessionStateProvider, new object[] { sessionId });

			dataFromCache = (DefaultSessionStateData)mongoSessionStateProviderBaseType
									.GetMethod("CacheGet", BindingFlags.NonPublic | BindingFlags.Instance)
									.Invoke(mongoSessionStateProvider, new object[] { sessionId });

			return objectExistsInCache;
		}
示例#2
0
        /// <summary>
        /// Method that creates a new session, waits for it to automatically expire and then
        /// verifies that the session has been removed from the provider as well as the provider's
        /// memory cache.
        /// </summary>
        /// <param name="mongoSessionStateProvider">The MongoDB provider to use for the test.</param>
        private void VerifySessionExpiration(MongoDBSessionStateProvider mongoSessionStateProvider)
        {
            var mongoSessionStateProviderBaseType = mongoSessionStateProvider.GetType().BaseType;

            HttpRequest  httpRequest  = null;
            HttpResponse httpResponse = null;
            HttpContext  httpContext  = GetContext(out httpRequest, out httpResponse);

            var timeoutInMinutes = (_TimeoutInSeconds / 60);
            var storeData        = mongoSessionStateProvider.CreateNewStoreData(httpContext, timeoutInMinutes);

            storeData.Items["DummyEntry"] = "DummyValue";

            string sessionId = null;

            lock (_SessionIdManager)
            {
                sessionId = _SessionIdManager.CreateSessionID(httpContext);
            }

            object lockId = null;             // New items don't have a lockId

            mongoSessionStateProvider.SetAndReleaseItemExclusive(httpContext, sessionId, storeData, lockId, true);

            TestContext.WriteLine("Created Session {0}", sessionId);

            int counter = _TimeoutInSeconds + 60;

            TestContext.WriteLine("Waiting {0} seconds...", counter);
            while (counter > 0)
            {
                System.Threading.Thread.Sleep(1000);
                counter--;
            }

            bool     locked;
            TimeSpan lockAge;
            object   lockId2 = null;

            System.Web.SessionState.SessionStateActions actions;
            var storeDataAfterExpiry = mongoSessionStateProvider.GetItem(httpContext, sessionId, out locked, out lockAge, out lockId2, out actions);

            if (storeDataAfterExpiry == null || storeDataAfterExpiry.Items.Count == 0)
            {
                TestContext.WriteLine("Session expired from Session State Provider.  Verifying session provider cache...");

                ISessionStateData objectInCache = null;
                bool objectExistsInCache        = CheckSessionExistsInCache(mongoSessionStateProvider, sessionId, out objectInCache);

                if (objectInCache != null)
                {
                    Assert.Fail("Session data exists in cache when should have expired - Expires = {0}", objectInCache.Expires);
                }
                else if (objectInCache == null && objectExistsInCache)
                {
                    Assert.Fail("Session data has expired but the cache is retaining the object!");
                }
                else
                {
                    TestContext.WriteLine("Success - session data does not exist in cache.");
                }
            }
            else
            {
                Assert.Fail("Session expired but MongoDB Sessions State Provider still contains data!");
            }
        }
示例#3
0
        /// <summary>
        /// Uses reflection to determine if the MongoDB Session State Provider is holding onto a sessionId
        /// in it's memory cache object.
        /// </summary>
        /// <param name="mongoSessionStateProvider">The provider to use</param>
        /// <param name="sessionId">The session id to query</param>
        /// <param name="dataFromCache">The data retrieved from the cache</param>
        /// <returns>True if the session exists in the provider's cache</returns>
        private bool CheckSessionExistsInCache(MongoDBSessionStateProvider mongoSessionStateProvider, string sessionId, out ISessionStateData dataFromCache)
        {
            var mongoSessionStateProviderBaseType = mongoSessionStateProvider.GetType().BaseType;

            bool objectExistsInCache = (bool)mongoSessionStateProviderBaseType
                                       .GetMethod("CacheContains", BindingFlags.NonPublic | BindingFlags.Instance)
                                       .Invoke(mongoSessionStateProvider, new object[] { sessionId });

            dataFromCache = (DefaultSessionStateData)mongoSessionStateProviderBaseType
                            .GetMethod("CacheGet", BindingFlags.NonPublic | BindingFlags.Instance)
                            .Invoke(mongoSessionStateProvider, new object[] { sessionId });

            return(objectExistsInCache);
        }
示例#4
0
        /// <summary>
        /// Method that creates a new session using the provider supplied.  This method
        /// also verifies that the session was created, then modifies the session, then
        /// deletes the session and verifies deletion from the store and the memory cache
        /// in the provider.
        /// </summary>
        /// <param name="provider">The MongoDB provider to use for the test.</param>
        private void VerifySessionPersistence(MongoDBSessionStateProvider provider)
        {
            string itemName  = "DummyItem";
            string itemValue = "Value";

            HttpRequest  request  = null;
            HttpResponse response = null;
            HttpContext  context  = GetContext(out request, out response);

            TestContext.WriteLine("Creating Store Data");
            var dataStore = provider.CreateNewStoreData(context, (_TimeoutInSeconds / 60));

            dataStore.Items[itemName] = itemValue;

            var sessionId = _SessionIdManager.CreateSessionID(context);

            TestContext.WriteLine("Writing Store Data");
            provider.SetAndReleaseItemExclusive(context, sessionId, dataStore, null, true);

            System.Threading.Thread.Sleep(2000);

            bool     locked;
            TimeSpan lockAge;
            object   lockId;

            System.Web.SessionState.SessionStateActions actions;

            TestContext.WriteLine("Retrieving new Store Data");
            var retrievedDataStore = provider.GetItemExclusive(context, sessionId, out locked, out lockAge, out lockId, out actions);

            if (retrievedDataStore == null || retrievedDataStore.Items.Count == 0)
            {
                Assert.Fail("Retrieved data store does not contain session data");
            }

            TestContext.WriteLine("Testing Store Data");
            var dummyValue = retrievedDataStore.Items[itemName];

            Assert.AreEqual(itemValue, dummyValue);

            itemValue = "NewValue";
            retrievedDataStore.Items[itemName] = itemValue;

            TestContext.WriteLine("Updating Store Data");
            provider.SetAndReleaseItemExclusive(context, sessionId, retrievedDataStore, lockId, false);

            System.Threading.Thread.Sleep(2000);

            var retrievedDataStore2 = provider.GetItemExclusive(context, sessionId, out locked, out lockAge, out lockId, out actions);

            if (retrievedDataStore2 == null || retrievedDataStore2.Items.Count == 0)
            {
                Assert.Fail("Retrieved data store does not contain session data");
            }

            TestContext.WriteLine("Testing Store Data");
            Assert.AreEqual(itemValue, retrievedDataStore2.Items[itemName]);

            TestContext.WriteLine("Releasing Store Data");
            provider.ReleaseItemExclusive(context, sessionId, lockId);

            System.Threading.Thread.Sleep(2000);

            retrievedDataStore2 = provider.GetItemExclusive(context, sessionId, out locked, out lockAge, out lockId, out actions);
            TestContext.WriteLine("Deleting Store Data");
            provider.RemoveItem(context, sessionId, lockId, retrievedDataStore2);

            System.Threading.Thread.Sleep(2000);

            TestContext.WriteLine("Ensuring store was deleted");
            var retrievedDataStore3 = provider.GetItem(context, sessionId, out locked, out lockAge, out lockId, out actions);

            Assert.IsNull(retrievedDataStore3);

            System.Threading.Thread.Sleep(2000);

            TestContext.WriteLine("Ensuring cache is empty");
            ISessionStateData sessionStateDataFromCache = null;
            bool sessionExistsInCache = CheckSessionExistsInCache(provider, sessionId, out sessionStateDataFromCache);

            if (sessionExistsInCache)
            {
                Assert.Fail("Session should have been removed but still exists in cache");
            }

            TestContext.WriteLine("Success");
        }