[jboss-cvs] JBossCache/tests/functional/org/jboss/cache/notifications ...
Manik Surtani
manik at jboss.org
Thu Jun 14 13:56:07 EDT 2007
User: msurtani
Date: 07/06/14 13:56:07
Modified: tests/functional/org/jboss/cache/notifications
RemoteCacheListenerTest.java CacheListenerTest.java
Log:
JBCACHE-1107 and added more unit tests to cover notification and transactions
Revision Changes Path
1.16 +196 -7 JBossCache/tests/functional/org/jboss/cache/notifications/RemoteCacheListenerTest.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: RemoteCacheListenerTest.java
===================================================================
RCS file: /cvsroot/jboss/JBossCache/tests/functional/org/jboss/cache/notifications/RemoteCacheListenerTest.java,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -b -r1.15 -r1.16
--- RemoteCacheListenerTest.java 14 Jun 2007 15:19:24 -0000 1.15
+++ RemoteCacheListenerTest.java 14 Jun 2007 17:56:07 -0000 1.16
@@ -50,6 +50,7 @@
protected boolean optLocking = false;
private Cache cache1, cache2;
+ private TransactionManager tm1, tm2;
private EventLog eventLog1 = new EventLog(), eventLog2 = new EventLog();
private Fqn fqn = Fqn.fromString("/test");
private static final long eventSleepTime = 250; // 250ms should be more than enough
@@ -79,6 +80,9 @@
cache1.addCacheListener(eventLog1);
cache2.addCacheListener(eventLog2);
+
+ tm1 = cache1.getConfiguration().getRuntimeConfig().getTransactionManager();
+ tm2 = cache2.getConfiguration().getRuntimeConfig().getTransactionManager();
}
protected void tearDown() throws Exception
@@ -222,6 +226,7 @@
// test that the node has in fact been removed.
assertNull("Should be null", cache1.getRoot().getChild(fqn));
+ assertNull("Should be null", cache2.getRoot().getChild(fqn));
}
@@ -334,36 +339,220 @@
public void testTxCreationCommit() throws Exception
{
- fail("implement me");
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog2.events);
+ tm1.begin();
+ cache1.put(fqn, "key", "value");
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog1.events.size());
+ assertEquals("Events log should be empty until commit time", 0, eventLog2.events.size());
+ tm1.commit();
+ Map data = new HashMap();
+ data.put("key", "value");
+
+ //expectedRemote
+ List<CacheListenerEvent> expectedLocal = new ArrayList<CacheListenerEvent>();
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_CREATED, fqn, true, true, null));
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_CREATED, fqn, false, true, null));
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, true, Collections.emptyMap()));
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, true, data));
+
+ //expectedRemote
+ List<CacheListenerEvent> expectedRemote = new ArrayList<CacheListenerEvent>();
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_CREATED, fqn, true, false, null));
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_CREATED, fqn, false, false, null));
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, false, Collections.emptyMap()));
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, false, data));
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals(expectedLocal, eventLog1.events);
+ assertEquals(expectedRemote, eventLog2.events);
+ assertEquals("value", cache1.get(fqn, "key"));
}
public void testTxCreationRollback() throws Exception
{
- fail("implement me");
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog2.events);
+ tm1.begin();
+ cache1.put(fqn, "key", "value");
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog1.events.size());
+ assertEquals("Events log should be empty until commit time", 0, eventLog2.events.size());
+ tm1.rollback();
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty since tx rolled back", 0, eventLog1.events.size());
+ assertEquals("Events log should be empty since tx rolled back", 0, eventLog2.events.size());
+
+ assertNull(cache1.get(fqn, "key"));
+ assertNull(cache2.get(fqn, "key"));
}
public void testTxOnlyModification() throws Exception
{
- fail("implement me");
+ assertNull(cache1.get(fqn, "key"));
+ assertNull(cache2.get(fqn, "key"));
+
+ cache1.put(fqn, "key", "value");
+ Map oldData = new HashMap();
+ oldData.put("key", "value");
+
+ assertEquals("value", cache1.get(fqn, "key"));
+ assertEquals("value", cache2.get(fqn, "key"));
+
+ // clear event log
+ TestingUtil.sleepThread(eventSleepTime);
+ eventLog1.events.clear();
+ eventLog2.events.clear();
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog1.events);
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog2.events);
+
+ // modify existing node
+ tm1.begin();
+ cache1.put(fqn, "key", "value2");
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog1.events.size());
+ assertEquals("Events log should be empty until commit time", 0, eventLog2.events.size());
+ tm1.commit();
+ Map newData = new HashMap();
+ newData.put("key", "value2");
+
+ //expectedLocal
+ List<CacheListenerEvent> expectedLocal = new ArrayList<CacheListenerEvent>();
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, true, oldData));
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, true, newData));
+
+ //expectedRemote
+ List<CacheListenerEvent> expectedRemote = new ArrayList<CacheListenerEvent>();
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, false, oldData));
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, false, newData));
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals(expectedLocal, eventLog1.events);
+ assertEquals(expectedRemote, eventLog2.events);
}
public void testTxOnlyRemoval() throws Exception
{
- fail("implement me");
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog2.events);
+ cache1.put(fqn, "key", "value");
+ Map oldData = new HashMap();
+ oldData.put("key", "value");
+
+ assertEquals("value", cache1.get(fqn, "key"));
+ assertEquals("value", cache2.get(fqn, "key"));
+
+ // clear event log
+ TestingUtil.sleepThread(eventSleepTime);
+ eventLog1.events.clear();
+ eventLog2.events.clear();
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog1.events);
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog2.events);
+
+ // modify existing node
+ tm1.begin();
+ cache1.removeNode(fqn);
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog1.events.size());
+ assertEquals("Events log should be empty until commit time", 0, eventLog2.events.size());
+ tm1.commit();
+
+ //expectedLocal
+ List<CacheListenerEvent> expectedLocal = new ArrayList<CacheListenerEvent>();
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_REMOVED, fqn, true, true, oldData));
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_REMOVED, fqn, false, true, null));
+
+ //expectedRemote
+ List<CacheListenerEvent> expectedRemote = new ArrayList<CacheListenerEvent>();
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_REMOVED, fqn, true, false, oldData));
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_REMOVED, fqn, false, false, null));
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals(expectedLocal, eventLog1.events);
+ assertEquals(expectedRemote, eventLog2.events);
+
+ // test that the node has in fact been removed.
+ assertNull("Should be null", cache1.getRoot().getChild(fqn));
+ assertNull("Should be null", cache2.getRoot().getChild(fqn));
}
public void testTxRemoveData() throws Exception
{
- fail("implement me");
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog2.events);
+ cache1.put(fqn, "key", "value");
+ cache1.put(fqn, "key2", "value2");
+ Map oldData = new HashMap();
+ oldData.put("key", "value");
+ oldData.put("key2", "value2");
+
+ // clear event log
+ TestingUtil.sleepThread(eventSleepTime);
+ eventLog1.events.clear();
+ eventLog2.events.clear();
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog1.events);
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog2.events);
+
+ // modify existing node
+ tm1.begin();
+ cache1.remove(fqn, "key2");
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog1.events.size());
+ assertEquals("Events log should be empty until commit time", 0, eventLog2.events.size());
+ tm1.commit();
+
+ Map removed = new HashMap();
+ removed.put("key2", "value2");
+
+ //expectedLocal
+ List<CacheListenerEvent> expectedLocal = new ArrayList<CacheListenerEvent>();
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, true, oldData));
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, true, removed));
+
+ //expectedRemote
+ List<CacheListenerEvent> expectedRemote = new ArrayList<CacheListenerEvent>();
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, false, oldData));
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, false, removed));
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals(expectedLocal, eventLog1.events);
+ assertEquals(expectedRemote, eventLog2.events);
}
- public void testTxMove()
+ public void testTxMove() throws Exception
{
- fail("implement me");
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog2.events);
+ Fqn newParent = Fqn.fromString("/a");
+ cache1.put(fqn, "key", "value");
+ cache1.put(newParent, "key", "value");
+
+ Node n1 = cache1.getRoot().getChild(fqn);
+ Node n2 = cache1.getRoot().getChild(newParent);
+
+ TestingUtil.sleepThread(eventSleepTime);
+ eventLog1.events.clear();
+ eventLog2.events.clear();// clear events
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog1.events);
+ assertEquals("Event log should be empty", Collections.emptyList(), eventLog2.events);
+
+ tm1.begin();
+ cache1.move(n1.getFqn(), n2.getFqn());
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog1.events.size());
+ assertEquals("Events log should be empty until commit time", 0, eventLog2.events.size());
+ tm1.commit();
+
+ Fqn newFqn = new Fqn(newParent, fqn.getLastElement());
+
+ //expectedLocal
+ List<CacheListenerEvent> expectedLocal = new ArrayList<CacheListenerEvent>();
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MOVED, fqn, newFqn, true, true));
+ expectedLocal.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MOVED, fqn, newFqn, false, true));
+
+ //expectedRemote
+ List<CacheListenerEvent> expectedRemote = new ArrayList<CacheListenerEvent>();
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MOVED, fqn, newFqn, true, false));
+ expectedRemote.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MOVED, fqn, newFqn, false, false));
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals(expectedLocal, eventLog1.events);
+ assertEquals(expectedRemote, eventLog2.events);
}
// ============= supporting classes and enums =======================
1.19 +53 -13 JBossCache/tests/functional/org/jboss/cache/notifications/CacheListenerTest.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: CacheListenerTest.java
===================================================================
RCS file: /cvsroot/jboss/JBossCache/tests/functional/org/jboss/cache/notifications/CacheListenerTest.java,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -b -r1.18 -r1.19
--- CacheListenerTest.java 14 Jun 2007 15:19:24 -0000 1.18
+++ CacheListenerTest.java 14 Jun 2007 17:56:07 -0000 1.19
@@ -231,6 +231,7 @@
assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
tm.begin();
cache.put(fqn, "key", "value");
+ TestingUtil.sleepThread(eventSleepTime);
assertEquals("Events log should be empty until commit time", 0, eventLog.events.size());
tm.commit();
@@ -243,7 +244,7 @@
expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_CREATED, fqn, false, true, null));
expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, true, Collections.emptyMap()));
expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, true, data));
-
+ TestingUtil.sleepThread(eventSleepTime);
assertEquals(expected, eventLog.events);
assertEquals("value", cache.get(fqn, "key"));
}
@@ -253,26 +254,32 @@
assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
tm.begin();
cache.put(fqn, "key", "value");
+ TestingUtil.sleepThread(eventSleepTime);
assertEquals("Events log should be empty until commit time", 0, eventLog.events.size());
tm.rollback();
- assertEquals("Events log should be empty until commit time", 0, eventLog.events.size());
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty since tx rolled back", 0, eventLog.events.size());
}
public void testTxOnlyModification() throws Exception
{
- fail("implement me");
assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
cache.put(fqn, "key", "value");
Map oldData = new HashMap();
oldData.put("key", "value");
// clear CacheListenerEvent log
+ TestingUtil.sleepThread(eventSleepTime);
eventLog.events.clear();
assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
// modify existing node
+ tm.begin();
cache.put(fqn, "key", "value2");
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog.events.size());
+ tm.commit();
Map newData = new HashMap();
newData.put("key", "value2");
@@ -280,14 +287,13 @@
List<CacheListenerEvent> expected = new ArrayList<CacheListenerEvent>();
expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, true, oldData));
expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, true, newData));
-
+ TestingUtil.sleepThread(eventSleepTime);
assertEquals(expected, eventLog.events);
}
public void testTxOnlyRemoval() throws Exception
{
- fail("implement me");
assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
cache.put(fqn, "key", "value");
Map oldData = new HashMap();
@@ -296,17 +302,22 @@
assertEquals("value", cache.get(fqn, "key"));
// clear CacheListenerEvent log
+ TestingUtil.sleepThread(eventSleepTime);
eventLog.events.clear();
assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
// modify existing node
+ tm.begin();
cache.removeNode(fqn);
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog.events.size());
+ tm.commit();
//expected
List<CacheListenerEvent> expected = new ArrayList<CacheListenerEvent>();
expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_REMOVED, fqn, true, true, oldData));
expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_REMOVED, fqn, false, true, null));
-
+ TestingUtil.sleepThread(eventSleepTime);
assertEquals(expected, eventLog.events);
// test that the node has in fact been removed.
@@ -316,7 +327,6 @@
public void testTxRemoveData() throws Exception
{
- fail("implement me");
assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
cache.put(fqn, "key", "value");
cache.put(fqn, "key2", "value2");
@@ -325,25 +335,55 @@
oldData.put("key2", "value2");
// clear CacheListenerEvent log
+ TestingUtil.sleepThread(eventSleepTime);
eventLog.events.clear();
assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
// modify existing node
+ tm.begin();
cache.remove(fqn, "key2");
- Map newData = new HashMap();
- newData.put("key", "value");
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog.events.size());
+ tm.commit();
+
+ Map removedData = new HashMap();
+ removedData.put("key2", "value2");
//expected
List<CacheListenerEvent> expected = new ArrayList<CacheListenerEvent>();
- expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, true, oldData));
- expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, true, newData));
+ expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, true, true, oldData));
+ expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MODIFIED, fqn, false, true, removedData));
+ TestingUtil.sleepThread(eventSleepTime);
assertEquals(expected, eventLog.events);
}
- public void testTxMove()
+ public void testTxMove() throws Exception
{
- fail("implement me");
+ assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
+ Fqn newParent = Fqn.fromString("/a");
+ cache.put(fqn, "key", "value");
+ cache.put(newParent, "key", "value");
+
+ Node n1 = cache.getRoot().getChild(fqn);
+ Node n2 = cache.getRoot().getChild(newParent);
+ TestingUtil.sleepThread(eventSleepTime);
+ eventLog.events.clear();// clear events
+ assertEquals("CacheListenerEvent log should be empty", Collections.emptyList(), eventLog.events);
+
+ tm.begin();
+ cache.move(n1.getFqn(), n2.getFqn());
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals("Events log should be empty until commit time", 0, eventLog.events.size());
+ tm.commit();
+
+ //expected
+ Fqn newFqn = new Fqn(newParent, fqn.getLastElement());
+ List<CacheListenerEvent> expected = new ArrayList<CacheListenerEvent>();
+ expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MOVED, fqn, newFqn, true, true));
+ expected.add(new CacheListenerEvent(CacheListenerEvent.ListenerMethod.NODE_MOVED, fqn, newFqn, false, true));
+ TestingUtil.sleepThread(eventSleepTime);
+ assertEquals(expected, eventLog.events);
}
// ============= supporting classes and enums =======================
More information about the jboss-cvs-commits
mailing list