1
2
3
4
5
6
7
8
9
10
11 package org.mule.util.store;
12
13 import org.mule.api.config.MuleProperties;
14 import org.mule.api.registry.RegistrationException;
15 import org.mule.api.store.ListableObjectStore;
16 import org.mule.api.store.ObjectAlreadyExistsException;
17 import org.mule.api.store.ObjectDoesNotExistException;
18 import org.mule.api.store.ObjectStore;
19 import org.mule.api.store.ObjectStoreException;
20 import org.mule.api.store.ObjectStoreManager;
21 import org.mule.tck.AbstractMuleTestCase;
22
23 public class ManagedStoresTestCase extends AbstractMuleTestCase
24 {
25
26 public ManagedStoresTestCase()
27 {
28 setDisposeManagerPerSuite(true);
29 }
30
31 @Override
32 protected void doSetUp() throws Exception
33 {
34 super.doSetUp();
35 MuleObjectStoreManager manager = muleContext.getRegistry().lookupObject(
36 MuleProperties.OBJECT_STORE_MANAGER);
37 manager.clearStoreCache();
38 }
39
40 public void testInMemoryStore() throws ObjectStoreException, InterruptedException, RegistrationException
41 {
42 muleContext.getRegistry().registerObject(MuleProperties.OBJECT_STORE_DEFAULT_IN_MEMORY_NAME,
43 new SimpleMemoryObjectStore());
44 ObjectStoreManager manager = muleContext.getRegistry().lookupObject(
45 MuleProperties.OBJECT_STORE_MANAGER);
46 ListableObjectStore store = manager.getObjectStore("inMemoryPart1", false);
47 assertTrue(store instanceof PartitionedObjectStoreWrapper);
48 ObjectStore baseStore = ((PartitionedObjectStoreWrapper) store).getBaseStore();
49 assertTrue(baseStore instanceof SimpleMemoryObjectStore);
50 assertSame(baseStore,
51 muleContext.getRegistry().lookupObject(MuleProperties.OBJECT_STORE_DEFAULT_IN_MEMORY_NAME));
52 testObjectStore(store);
53 testObjectStoreExpiry(manager.getObjectStore("inMemoryExpPart1", false, -1, 500, 200));
54 testObjectStoreMaxEntries((ListableObjectStore) manager.getObjectStore("inMemoryMaxPart1", false, 10,
55 10000, 200));
56 }
57
58 public void testPersistentStore()
59 throws ObjectStoreException, InterruptedException, RegistrationException
60 {
61 QueuePersistenceObjectStore queueStore = new QueuePersistenceObjectStore(muleContext);
62 queueStore.open();
63 muleContext.getRegistry().registerObject(MuleProperties.OBJECT_STORE_DEFAULT_PERSISTENT_NAME,
64 queueStore);
65 ObjectStoreManager manager = muleContext.getRegistry().lookupObject(
66 MuleProperties.OBJECT_STORE_MANAGER);
67 ListableObjectStore store = manager.getObjectStore("persistencePart1", true);
68 assertTrue(store instanceof PartitionedObjectStoreWrapper);
69 ObjectStore baseStore = ((PartitionedObjectStoreWrapper) store).getBaseStore();
70 assertTrue(baseStore instanceof QueuePersistenceObjectStore);
71 assertSame(baseStore,
72 muleContext.getRegistry().lookupObject(MuleProperties.OBJECT_STORE_DEFAULT_PERSISTENT_NAME));
73 testObjectStore(store, false);
74 testObjectStoreExpiry(manager.getObjectStore("persistenceExpPart1", true, -1, 500, 200));
75 testObjectStoreMaxEntries((ListableObjectStore) manager.getObjectStore("persistenceMaxPart1", true,
76 10, 10000, 200));
77 }
78
79 public void testPartitionableInMemoryStore()
80 throws ObjectStoreException, RegistrationException, InterruptedException
81 {
82 muleContext.getRegistry().registerObject(MuleProperties.OBJECT_STORE_DEFAULT_IN_MEMORY_NAME,
83 new PartitionedInMemoryObjectStore());
84 ObjectStoreManager manager = muleContext.getRegistry().lookupObject(
85 MuleProperties.OBJECT_STORE_MANAGER);
86 ListableObjectStore store = manager.getObjectStore("inMemoryPart2", false);
87 assertTrue(store instanceof ObjectStorePartition);
88 ObjectStore baseStore = ((ObjectStorePartition) store).getBaseStore();
89 assertTrue(baseStore instanceof PartitionedInMemoryObjectStore);
90 assertSame(baseStore,
91 muleContext.getRegistry().lookupObject(MuleProperties.OBJECT_STORE_DEFAULT_IN_MEMORY_NAME));
92 testObjectStore(store);
93 testObjectStoreExpiry(manager.getObjectStore("inMemoryExpPart2", false, -1, 500, 200));
94 testObjectStoreMaxEntries((ListableObjectStore) manager.getObjectStore("inMemoryMaxPart2", false, 10,
95 10000, 200));
96 }
97
98 public void testPartitionablePersistenceStore()
99 throws ObjectStoreException, RegistrationException, InterruptedException
100 {
101 PartitionedPersistentObjectStore partitionedStore = new PartitionedPersistentObjectStore(muleContext);
102 partitionedStore.open();
103 muleContext.getRegistry().registerObject(MuleProperties.OBJECT_STORE_DEFAULT_PERSISTENT_NAME,
104 partitionedStore);
105 ObjectStoreManager manager = muleContext.getRegistry().lookupObject(
106 MuleProperties.OBJECT_STORE_MANAGER);
107 ListableObjectStore store = manager.getObjectStore("persistencePart2", true);
108 assertTrue(store instanceof ObjectStorePartition);
109 ObjectStore baseStore = ((ObjectStorePartition) store).getBaseStore();
110 assertTrue(baseStore instanceof PartitionedPersistentObjectStore);
111 assertSame(baseStore,
112 muleContext.getRegistry().lookupObject(MuleProperties.OBJECT_STORE_DEFAULT_PERSISTENT_NAME));
113 testObjectStore(store);
114 testObjectStoreExpiry(manager.getObjectStore("persistenceExpPart2", true, -1, 1000, 200));
115 testObjectStoreMaxEntries((ListableObjectStore) manager.getObjectStore("persistenceMaxPart2", true,
116 10, 10000, 200));
117 }
118
119 private void testObjectStore(ListableObjectStore store) throws ObjectStoreException
120 {
121 testObjectStore(store, true);
122 }
123
124 private void testObjectStore(ListableObjectStore store, boolean removeReturnsObject)
125 throws ObjectStoreException
126 {
127 ObjectStoreException e = null;
128 store.store("key1", "value1");
129 assertEquals("value1", store.retrieve("key1"));
130 assertTrue(store.contains("key1"));
131 try
132 {
133 store.store("key1", "value1");
134 }
135 catch (ObjectAlreadyExistsException e1)
136 {
137 e = e1;
138 }
139 assertNotNull(e);
140 e = null;
141 assertEquals(1, store.allKeys().size());
142 assertEquals("key1", store.allKeys().get(0));
143 if (removeReturnsObject)
144 {
145 assertEquals("value1", store.remove("key1"));
146 }
147 else
148 {
149 assertNull(store.remove("key1"));
150 }
151 assertFalse(store.contains("key1"));
152 try
153 {
154 store.retrieve("key1");
155 }
156 catch (ObjectDoesNotExistException e1)
157 {
158 e = e1;
159 }
160 assertNotNull(e);
161 e = null;
162 try
163 {
164 store.remove("key1");
165 }
166 catch (ObjectDoesNotExistException e1)
167 {
168 e = e1;
169 }
170 assertNotNull(e);
171 e = null;
172 }
173
174 private void testObjectStoreExpiry(ObjectStore objectStore)
175 throws ObjectStoreException, InterruptedException
176 {
177 objectStore.store("key1", "value1");
178 assertEquals("value1", objectStore.retrieve("key1"));
179 Thread.sleep(2000);
180 assertFalse("Object with key1 still exists.", objectStore.contains("key1"));
181
182 }
183
184 private void testObjectStoreMaxEntries(ListableObjectStore objectStore)
185 throws ObjectStoreException, InterruptedException
186 {
187 for (int i = 0; i < 100; i++)
188 {
189 objectStore.store("key" + i, "value" + i);
190 assertEquals("value" + i, objectStore.retrieve("key" + i));
191 }
192 Thread.sleep(2000);
193 assertEquals(10, objectStore.allKeys().size());
194 for (int i = 90; i < 100; i++)
195 {
196 assertTrue("Checking that key" + i + " exists", objectStore.contains("key" + i));
197 }
198
199 }
200
201 }