public void ItemsGetRemovedFromCacheAfterExpiration()
        {
            Assert.IsNull(cache.GetData("key"));

            DataBackingStore backingStore = CreateDataBackingStore();

            Assert.AreEqual(0, backingStore.Load().Count);

            AbsoluteTime threeSecondExpiration = new AbsoluteTime(DateTime.Now + TimeSpan.FromSeconds(3.0));

            lock (callbackLock)
            {
                cache.Add("key", "value", CacheItemPriority.NotRemovable,
                          new RefreshAction(),
                          threeSecondExpiration);

                Assert.IsNotNull(cache.GetData("key"));

                Hashtable oneEntryHashTable = backingStore.Load();
                Assert.AreEqual(1, oneEntryHashTable.Count);

                Monitor.Wait(callbackLock, 15000);

                Assert.IsTrue(wasCalledBack);
            }

            object removedItem = cache.GetData("key");

            Assert.IsNull(removedItem);

            Hashtable emptyHashTable = backingStore.Load();

            Assert.AreEqual(0, emptyHashTable.Count);
        }
Beispiel #2
0
        public void LoadRetrievesFromCorrectDatabasePartition()
        {
            firstCache.Add(new CacheItem("key1", "value1", CacheItemPriority.Low, null));

            Hashtable firstDatabaseContents = firstCache.Load();

            Assert.AreEqual(1, firstDatabaseContents.Count);

            Hashtable secondDatabaseContents = secondCache.Load();

            Assert.AreEqual(0, secondDatabaseContents.Count);
        }
        public void CacheRemove()
        {
            cache.Add("Remove1", "98761");
            cache.Remove("Remove1");

            Assert.IsNull(cache.GetData("Remove1"));

            DataBackingStore backingStore = CreateDataBackingStore();

            Hashtable inDatabaseItems = backingStore.Load();

            Assert.AreEqual(0, inDatabaseItems.Count);
        }
        public void AddSameKey()
        {
            cache.Add("Add1", "12345");
            cache.Add("Add1", "23456");
            object o1 = cache.GetData("Add1");

            Assert.AreEqual("23456", o1);

            DataBackingStore backingStore    = CreateDataBackingStore();
            Hashtable        inDatabaseItems = backingStore.Load();

            Assert.AreEqual("23456", ((CacheItem)inDatabaseItems["Add1"]).Value);
        }
        public void DecryptedDataCanBeReadBackFromDatabase()
        {
            StorageEncryptionFactory factory = new StorageEncryptionFactory(Context);

            IStorageEncryptionProvider encryptionProvider     = factory.CreateSymmetricProvider(CacheManagerName);
            DataBackingStore           encryptingBackingStore = new DataBackingStore(db, "encryptionTests", encryptionProvider);

            encryptingBackingStore.Add(new CacheItem("key", "value", CacheItemPriority.Normal, new MockRefreshAction(), new AlwaysExpired()));
            Hashtable dataInCache = encryptingBackingStore.Load();

            CacheItem retrievedItem = (CacheItem)dataInCache["key"];

            Assert.AreEqual("key", retrievedItem.Key);
            Assert.AreEqual("value", retrievedItem.Value);
            Assert.AreEqual(CacheItemPriority.Normal, retrievedItem.ScavengingPriority);
            Assert.AreEqual(typeof(MockRefreshAction), retrievedItem.RefreshAction.GetType());
            Assert.AreEqual(typeof(AlwaysExpired), retrievedItem.Expirations[0].GetType());
        }
Beispiel #6
0
        public void DecryptedDataCanBeReadBackFromDatabase()
        {
            IStorageEncryptionProvider encryptionProvider = null;

            encryptionProvider = EnterpriseLibraryFactory.BuildUp <IStorageEncryptionProvider>("Fred");

            DataBackingStore encryptingBackingStore = new DataBackingStore(db, "encryptionTests", encryptionProvider);

            encryptingBackingStore.Add(new CacheItem("key", "value", CacheItemPriority.Normal, new MockRefreshAction(), new AlwaysExpired()));
            Hashtable dataInCache = encryptingBackingStore.Load();

            CacheItem retrievedItem = (CacheItem)dataInCache["key"];

            Assert.AreEqual("key", retrievedItem.Key);
            Assert.AreEqual("value", retrievedItem.Value);
            Assert.AreEqual(CacheItemPriority.Normal, retrievedItem.ScavengingPriority);
            Assert.AreEqual(typeof(MockRefreshAction), retrievedItem.RefreshAction.GetType());
            Assert.AreEqual(typeof(AlwaysExpired), retrievedItem.GetExpirations()[0].GetType());
        }
        public void AddMultipleItems()
        {
            cache.Add("AddM1", "12345");
            cache.Add("AddM2", "23456");
            cache.Add("AddM3", "34567");
            object o1 = cache.GetData("AddM1");
            object o2 = cache.GetData("AddM2");
            object o3 = cache.GetData("AddM3");

            Assert.AreEqual("12345", o1);
            Assert.AreEqual("23456", o2);
            Assert.AreEqual("34567", o3);

            DataBackingStore backingStore    = CreateDataBackingStore();
            Hashtable        inDatabaseItems = backingStore.Load();

            Assert.AreEqual("12345", ((CacheItem)inDatabaseItems["AddM1"]).Value);
            Assert.AreEqual("23456", ((CacheItem)inDatabaseItems["AddM2"]).Value);
            Assert.AreEqual("34567", ((CacheItem)inDatabaseItems["AddM3"]).Value);
        }