public void TestEvents()
{
// start the ProxyService on just one cluster node
IInvocationService invocationService = RestartProxy(null);
// put data items into inner cache to generate events
INamedCache testCache = GetCache("proxy-stop-test");
testCache.Clear();
for (int i = 0; i < SOME_DATA; i++)
{
testCache.Add("TestKey" + i, i);
}
// create listener for CQC
TestCQCListener listener = new TestCQCListener(SOME_DATA);
// instantiate the CQC, will start the test running.
theCQC = new ContinuousQueryCache(testCache, AlwaysFilter.Instance, listener);
// instantiate a service listener to receive memberLeft event
fMemberLeft = false;
testCache.CacheService.MemberLeft += new MemberEventHandler(OnMemberLeft);
// allow test time to complete.
DateTime endTime = DateTime.Now.AddSeconds(30);
while (listener.GetActualTotal() < SOME_DATA && (DateTime.Now < endTime))
{
Thread.Sleep(250);
}
// check listener received the correct number of events.
Assert.AreEqual(SOME_DATA, listener.GetActualTotal());
listener.ResetActualTotal();
// restart proxy
RestartProxy(invocationService);
endTime = DateTime.Now.AddSeconds(30);
while (!fMemberLeft && (DateTime.Now < endTime))
{
Thread.Sleep(250);
}
// ping the CQC to make it realize the cache needs restart.
theCQC.Contains("junkstuff");
// allow test time to complete.
endTime = DateTime.Now.AddSeconds(30);
while (listener.GetActualTotal() < SOME_DATA && (DateTime.Now < endTime))
{
Thread.Sleep(250);
}
Assert.AreEqual(SOME_DATA, listener.GetActualTotal());
}
public void TestViewBuilderCacheValues()
{
INamedCache cache = new ViewBuilder(GetCache("v-cachingValues")).Values().Build();
Assert.IsInstanceOf(typeof(ContinuousQueryCache), cache);
ContinuousQueryCache queryCache = (ContinuousQueryCache)cache;
Assert.That(queryCache.CacheValues, Is.True);
}
public void ShouldUseConfiguredListener()
{
ContinuousQueryCache cache = ValidateIsCqc(GetCache("view-with-listener"));
Assert.That(cache.Filter, Is.EqualTo(AlwaysFilter.Instance));
Assert.That(cache.Transformer, Is.Null);
Assert.That(cache.CacheListener, Is.EqualTo(new TestCacheListener()));
Assert.That(cache.ReconnectInterval, Is.EqualTo(0L));
Assert.That(cache.IsReadOnly, Is.False);
}
public void ShouldUseCustomTransformerWithInitParams()
{
ContinuousQueryCache cache = ValidateIsCqc(GetCache("view-transformer-with-params"));
Assert.That(cache.Filter, Is.EqualTo(AlwaysFilter.Instance));
Assert.That(cache.Transformer, Is.EqualTo(new KeyExtractor("foo")));
Assert.That(cache.CacheListener, Is.Null);
Assert.That(cache.ReconnectInterval, Is.EqualTo(0L));
Assert.That(cache.IsReadOnly, Is.True);
}
public void ShouldUseCustomTransformer()
{
ContinuousQueryCache cache = ValidateIsCqc(GetCache("view-transformer"));
Assert.That(cache.Filter, Is.EqualTo(AlwaysFilter.Instance));
Assert.That(cache.Transformer, Is.EqualTo(IdentityExtractor.Instance));
Assert.That(cache.CacheListener, Is.Null);
Assert.That(cache.ReconnectInterval, Is.EqualTo(0L));
Assert.That(cache.IsReadOnly, Is.True);
}
public void ShouldUseCustomFilterWithInitParams()
{
ContinuousQueryCache cache = ValidateIsCqc(GetCache("view-filter-with-params"));
Assert.That(cache.Filter, Is.EqualTo(new GreaterFilter("foo", 10)));
Assert.That(cache.Transformer, Is.Null);
Assert.That(cache.CacheListener, Is.Null);
Assert.That(cache.ReconnectInterval, Is.EqualTo(0L));
Assert.That(cache.IsReadOnly, Is.False);
}
public void ShouldUseCustomFilter()
{
ContinuousQueryCache cache = ValidateIsCqc(GetCache("view-filter"));
Assert.That(cache.Filter, Is.EqualTo(NeverFilter.Instance));
Assert.That(cache.Transformer, Is.Null);
Assert.That(cache.CacheListener, Is.Null);
Assert.That(cache.ReconnectInterval, Is.EqualTo(0L));
Assert.That(cache.IsReadOnly, Is.False);
}
public void TestViewBuilderWithTransformer()
{
IValueExtractor transformer = new IdentityExtractor();
INamedCache cache = new ViewBuilder(GetCache("v-transformer")).Map(transformer).Build();
Assert.IsInstanceOf(typeof(ContinuousQueryCache), cache);
ContinuousQueryCache queryCache = (ContinuousQueryCache)cache;
Assert.That(queryCache.Transformer, Is.EqualTo(transformer));
}
public void TestViewBuilderWithListener()
{
ICacheListener listener = new TestCacheListener();
INamedCache cache = new ViewBuilder(GetCache("v-listener")).Listener(listener).Build();
Assert.IsInstanceOf(typeof(ContinuousQueryCache), cache);
ContinuousQueryCache queryCache = (ContinuousQueryCache)cache;
Assert.That(queryCache.CacheListener, Is.EqualTo(listener));
}
public void TestViewBuilderWithFilter()
{
IFilter filter = new EqualsFilter("foo", "bar");
INamedCache cache = new ViewBuilder(GetCache("v-filter")).Filter(filter).Build();
Assert.IsInstanceOf(typeof(ContinuousQueryCache), cache);
ContinuousQueryCache queryCache = (ContinuousQueryCache)cache;
Assert.That(queryCache.Filter, Is.EqualTo(filter));
}
public void TestViewBuilderKeysOnly()
{
IValueExtractor transformer = new IdentityExtractor();
INamedCache cache = new ViewBuilder(GetCache("v-keysOnly")).Keys().Build();
Assert.IsInstanceOf(typeof(ContinuousQueryCache), cache);
ContinuousQueryCache queryCache = (ContinuousQueryCache)cache;
Assert.That(queryCache.CacheValues, Is.False);
}
public void TestViewBuilderDefaults()
{
INamedCache cache = new ViewBuilder(GetCache("v-defaults")).Build();
Assert.IsInstanceOf(typeof(ContinuousQueryCache), cache);
ContinuousQueryCache queryCache = (ContinuousQueryCache)cache;
Assert.That(queryCache.Filter, Is.EqualTo(AlwaysFilter.Instance));
Assert.That(queryCache.IsReadOnly, Is.False);
Assert.That(queryCache.CacheListener, Is.Null);
Assert.That(queryCache.Transformer, Is.Null);
Assert.That(queryCache.ReconnectInterval, Is.EqualTo(0L));
Assert.That(queryCache.CacheNameSupplier, Is.Null);
Assert.That(queryCache.CacheValues, Is.False);
}
public void TestListeners()
{
INamedCache namedCache = CacheFactory.GetCache(CacheName);
Hashtable ht = new Hashtable();
ht.Add(GetKeyObject("Key1"), 435);
ht.Add(GetKeyObject("Key2"), 253);
ht.Add(GetKeyObject("Key3"), 3);
ht.Add(GetKeyObject("Key4"), 200);
ht.Add(GetKeyObject("Key5"), 333);
namedCache.InsertAll(ht);
IFilter greaterThan300 = new GreaterFilter(IdentityExtractor.Instance, 300);
IFilter listenerFilter = new CacheEventFilter(new GreaterFilter(IdentityExtractor.Instance, 350));
ContinuousQueryCache queryCache = new ContinuousQueryCache(namedCache, greaterThan300);
Listener listener = new SyncListener();
// listener
queryCache.AddCacheListener(listener);
listener.CacheEvent = null;
queryCache.Insert(GetKeyObject("Key7"), 400);
Assert.IsNotNull(listener.CacheEvent);
Assert.AreEqual(CacheEventType.Inserted, listener.CacheEvent.EventType);
listener.CacheEvent = null;
queryCache.Insert(GetKeyObject("Key7"), 350);
Assert.IsNotNull(listener.CacheEvent);
Assert.AreEqual(CacheEventType.Updated, listener.CacheEvent.EventType);
listener.CacheEvent = null;
queryCache.Remove(GetKeyObject("Key5"));
Assert.IsNotNull(listener.CacheEvent);
Assert.AreEqual(CacheEventType.Deleted, listener.CacheEvent.EventType);
queryCache.RemoveCacheListener(listener);
// listener, key, lite
namedCache.Clear();
namedCache.InsertAll(ht);
queryCache.AddCacheListener(listener, GetKeyObject("Key5"), false);
listener.CacheEvent = null;
queryCache.Insert(GetKeyObject("Key6"), 400);
Assert.IsNull(listener.CacheEvent);
queryCache.Insert(GetKeyObject("Key5"), 400);
Assert.IsNotNull(listener.CacheEvent);
Assert.AreEqual(CacheEventType.Updated, listener.CacheEvent.EventType);
listener.CacheEvent = null;
queryCache.Remove(GetKeyObject("Key1"));
Assert.IsNull(listener.CacheEvent);
queryCache.Remove(GetKeyObject("Key5"));
Assert.IsNotNull(listener.CacheEvent);
Assert.AreEqual(CacheEventType.Deleted, listener.CacheEvent.EventType);
queryCache.RemoveCacheListener(listener, GetKeyObject("Key5"));
// listener, filter, lite
namedCache.Clear();
namedCache.InsertAll(ht);
queryCache.AddCacheListener(listener, listenerFilter, false);
listener.CacheEvent = null;
queryCache.Insert(GetKeyObject("Key6"), 320);
Assert.IsNull(listener.CacheEvent);
queryCache.Insert(GetKeyObject("Key5"), 350);
Assert.IsNull(listener.CacheEvent);
queryCache.Insert(GetKeyObject("Key6"), 400);
Assert.IsNotNull(listener.CacheEvent);
Assert.AreEqual(CacheEventType.Updated, listener.CacheEvent.EventType);
listener.CacheEvent = null;
queryCache.Insert(GetKeyObject("Key7"), 340);
Assert.IsNull(listener.CacheEvent);
queryCache.Remove(GetKeyObject("Key7"));
Assert.IsNull(listener.CacheEvent);
queryCache.Remove(GetKeyObject("Key6"));
Assert.IsNotNull(listener.CacheEvent);
Assert.AreEqual(CacheEventType.Deleted, listener.CacheEvent.EventType);
queryCache.RemoveCacheListener(listener, listenerFilter);
// non-sync listener, filter, heavy
// COH-2529: Filter-based cache events are reevaluated on the client unncessarily
listener = new Listener();
listenerFilter = new CacheEventFilter(new EqualsFilter("getZip", "02144"));
namedCache.Clear();
namedCache.AddCacheListener(listener, listenerFilter, false);
listener.CacheEvent = null;
namedCache[GetKeyObject("Jason")] = new Address("3 TBR #8", "Somerville", "MA", "02144");
listener.waitForEvent(5000);
Assert.IsNotNull(listener.CacheEvent);
Assert.IsNotNull(listener.CacheEvent.NewValue);
Assert.AreEqual(CacheEventType.Inserted, listener.CacheEvent.EventType);
listener.CacheEvent = null;
listener.waitForEvent(5000);
namedCache[GetKeyObject("Oracle")] = new Address("8 NEEP", "Burlington", "MA", "01803");
Assert.IsNull(listener.CacheEvent);
namedCache.RemoveCacheListener(listener, listenerFilter);
CacheFactory.Shutdown();
}
