1 |
| |
2 |
| |
3 |
| |
4 |
| |
5 |
| |
6 |
| |
7 |
| package org.jboss.cache.loader; |
8 |
| |
9 |
| import junit.framework.Assert; |
10 |
| import junit.framework.Test; |
11 |
| import junit.framework.TestSuite; |
12 |
| import org.jboss.cache.CacheListener; |
13 |
| import org.jboss.cache.CacheSPI; |
14 |
| import org.jboss.cache.config.CacheLoaderConfig; |
15 |
| import org.jboss.cache.factories.XmlConfigurationParser; |
16 |
| import org.jboss.cache.xml.XmlHelper; |
17 |
| import org.w3c.dom.Element; |
18 |
| |
19 |
| import java.util.List; |
20 |
| import java.util.Properties; |
21 |
| |
22 |
| |
23 |
| |
24 |
| |
25 |
| |
26 |
| |
27 |
| public class CacheLoaderManagerTest extends AbstractCacheLoaderTestBase |
28 |
| { |
29 |
10
| private CacheLoaderConfig createCacheLoaderCfg(boolean passivation)
|
30 |
| { |
31 |
10
| CacheLoaderConfig cfg = new CacheLoaderConfig();
|
32 |
10
| cfg.setPassivation(passivation);
|
33 |
10
| return cfg;
|
34 |
| } |
35 |
| |
36 |
19
| private CacheLoaderConfig.IndividualCacheLoaderConfig createIndividualCacheLoaderConfig(CacheLoaderConfig parent, boolean async, String classname) throws Exception
|
37 |
| { |
38 |
19
| CacheLoaderConfig.IndividualCacheLoaderConfig cfg = new CacheLoaderConfig.IndividualCacheLoaderConfig();
|
39 |
19
| cfg.setAsync(async);
|
40 |
19
| cfg.setClassName(classname);
|
41 |
19
| cfg.setFetchPersistentState(false);
|
42 |
19
| Properties p = new Properties();
|
43 |
19
| p.setProperty("location", getTempDir());
|
44 |
19
| p.setProperty("cache.jdbc.driver", "com.mysql.jdbc.Driver");
|
45 |
19
| p.setProperty("cache.jdbc.url", "jdbc:mysql://localhost/test");
|
46 |
19
| p.setProperty("cache.jdbc.user", "user");
|
47 |
19
| p.setProperty("cache.jdbc.password", "pwd");
|
48 |
19
| cfg.setProperties(p);
|
49 |
19
| return cfg;
|
50 |
| } |
51 |
| |
52 |
39
| private String getTempDir()
|
53 |
| { |
54 |
39
| return System.getProperty("java.io.tempdir", "/tmp");
|
55 |
| } |
56 |
| |
57 |
14
| private static Element strToElement(String s) throws Exception
|
58 |
| { |
59 |
14
| return XmlHelper.stringToElement(s);
|
60 |
| } |
61 |
| |
62 |
1
| public void testSingleCacheLoader() throws Exception
|
63 |
| { |
64 |
| |
65 |
1
| CacheLoaderManager mgr = new CacheLoaderManager();
|
66 |
1
| CacheLoaderConfig cfg = createCacheLoaderCfg(false);
|
67 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.FileCacheLoader"));
|
68 |
| |
69 |
1
| mgr.setConfig(cfg, null);
|
70 |
1
| CacheLoader cl = mgr.getCacheLoader();
|
71 |
| |
72 |
1
| Assert.assertEquals(FileCacheLoader.class, cl.getClass());
|
73 |
| |
74 |
| |
75 |
1
| cfg = createCacheLoaderCfg(false);
|
76 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader"));
|
77 |
| |
78 |
1
| mgr.setConfig(cfg, null);
|
79 |
1
| cl = mgr.getCacheLoader();
|
80 |
| |
81 |
1
| Assert.assertEquals(AsyncCacheLoader.class, cl.getClass());
|
82 |
| } |
83 |
| |
84 |
1
| public void testSingleCacheLoaderPassivation() throws Exception
|
85 |
| { |
86 |
| |
87 |
1
| CacheLoaderConfig cfg = createCacheLoaderCfg(true);
|
88 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.FileCacheLoader"));
|
89 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.bdbje.BdbjeCacheLoader"));
|
90 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.JDBCCacheLoader"));
|
91 |
| |
92 |
1
| CacheLoaderManager mgr = new CacheLoaderManager();
|
93 |
1
| mgr.setConfig(cfg, null);
|
94 |
1
| CacheLoader cl = mgr.getCacheLoader();
|
95 |
| |
96 |
1
| Assert.assertEquals(FileCacheLoader.class, cl.getClass());
|
97 |
| |
98 |
| |
99 |
1
| cfg = createCacheLoaderCfg(true);
|
100 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader"));
|
101 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.bdbje.BdbjeCacheLoader"));
|
102 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.JDBCCacheLoader"));
|
103 |
| |
104 |
1
| mgr.setConfig(cfg, null);
|
105 |
1
| cl = mgr.getCacheLoader();
|
106 |
| |
107 |
1
| Assert.assertEquals(AsyncCacheLoader.class, cl.getClass());
|
108 |
| } |
109 |
| |
110 |
1
| public void testSingleCacheLoaderFromXml() throws Exception
|
111 |
| { |
112 |
| |
113 |
1
| CacheLoaderConfig clc = getSingleCacheLoaderConfig("", "org.jboss.cache.loader.FileCacheLoader", "location=" + getTempDir(), false, false, false);
|
114 |
| |
115 |
1
| CacheLoaderManager mgr = new CacheLoaderManager();
|
116 |
1
| mgr.setConfig(clc, null);
|
117 |
1
| CacheLoader cl = mgr.getCacheLoader();
|
118 |
| |
119 |
1
| Assert.assertEquals(FileCacheLoader.class, cl.getClass());
|
120 |
| |
121 |
| |
122 |
1
| clc = getSingleCacheLoaderConfig("", "org.jboss.cache.loader.FileCacheLoader", "location=" + getTempDir(), true, false, false);
|
123 |
| |
124 |
1
| mgr.setConfig(clc, null);
|
125 |
1
| cl = mgr.getCacheLoader();
|
126 |
1
| Assert.assertEquals(AsyncCacheLoader.class, cl.getClass());
|
127 |
| } |
128 |
| |
129 |
1
| public void testSingleCacheLoaderPassivationFromXml() throws Exception
|
130 |
| { |
131 |
| |
132 |
1
| String conf = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
|
133 |
| "<config><passivation>true</passivation>" + |
134 |
| "<cacheloader>" + |
135 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
136 |
| " <async>false</async>" + |
137 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
138 |
| " <ignoreModifications>false</ignoreModifications>" + |
139 |
| " <properties>" + |
140 |
| " location=" + getTempDir() + |
141 |
| " </properties>" + |
142 |
| "</cacheloader>" + |
143 |
| "<cacheloader>" + |
144 |
| " <class>org.jboss.cache.loader.bdbje.BdbjeCacheLoader</class>" + |
145 |
| " <async>false</async>" + |
146 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
147 |
| " <ignoreModifications>false</ignoreModifications>" + |
148 |
| " <properties>" + |
149 |
| " location=" + getTempDir() + |
150 |
| " </properties>" + |
151 |
| "</cacheloader>" + |
152 |
| "<cacheloader>" + |
153 |
| " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" + |
154 |
| " <async>false</async>" + |
155 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
156 |
| " <ignoreModifications>false</ignoreModifications>" + |
157 |
| " <properties>" + |
158 |
| " location=" + getTempDir() + |
159 |
| " </properties>" + |
160 |
| "</cacheloader></config>"; |
161 |
1
| CacheLoaderConfig clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
162 |
1
| CacheLoaderManager mgr = new CacheLoaderManager();
|
163 |
1
| mgr.setConfig(clc, null);
|
164 |
1
| CacheLoader cl = mgr.getCacheLoader();
|
165 |
| |
166 |
1
| Assert.assertEquals(FileCacheLoader.class, cl.getClass());
|
167 |
| |
168 |
| |
169 |
1
| conf = "<config><passivation>true</passivation>" +
|
170 |
| "<cacheloader>" + |
171 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
172 |
| " <async>true</async>" + |
173 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
174 |
| " <ignoreModifications>false</ignoreModifications>" + |
175 |
| " <properties>" + |
176 |
| " location=" + getTempDir() + |
177 |
| " </properties>" + |
178 |
| "</cacheloader>" + |
179 |
| "<cacheloader>" + |
180 |
| " <class>org.jboss.cache.loader.bdbje.BdbjeCacheLoader</class>" + |
181 |
| " <async>true</async>" + |
182 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
183 |
| " <ignoreModifications>false</ignoreModifications>" + |
184 |
| " <properties>" + |
185 |
| " location=" + getTempDir() + |
186 |
| " </properties>" + |
187 |
| "</cacheloader>" + |
188 |
| "<cacheloader>" + |
189 |
| " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" + |
190 |
| " <async>true</async>" + |
191 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
192 |
| " <ignoreModifications>false</ignoreModifications>" + |
193 |
| " <properties>" + |
194 |
| " location=" + getTempDir() + |
195 |
| " </properties>" + |
196 |
| "</cacheloader></config>"; |
197 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
198 |
1
| mgr.setConfig(clc, null);
|
199 |
1
| cl = mgr.getCacheLoader();
|
200 |
| |
201 |
1
| Assert.assertEquals(AsyncCacheLoader.class, cl.getClass());
|
202 |
| } |
203 |
| |
204 |
1
| public void testChainingCacheLoader() throws Exception
|
205 |
| { |
206 |
| |
207 |
1
| CacheLoaderConfig cfg = createCacheLoaderCfg(false);
|
208 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.FileCacheLoader"));
|
209 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.JDBCCacheLoader"));
|
210 |
| |
211 |
1
| CacheLoaderManager mgr = new CacheLoaderManager();
|
212 |
1
| mgr.setConfig(cfg, null);
|
213 |
1
| CacheLoader cl = mgr.getCacheLoader();
|
214 |
| |
215 |
1
| Assert.assertEquals(ChainingCacheLoader.class, cl.getClass());
|
216 |
1
| Assert.assertEquals(2, ((ChainingCacheLoader) cl).getSize());
|
217 |
1
| List loaders = ((ChainingCacheLoader) cl).getCacheLoaders();
|
218 |
1
| Assert.assertEquals(FileCacheLoader.class, loaders.get(0).getClass());
|
219 |
1
| Assert.assertEquals(JDBCCacheLoader.class, loaders.get(1).getClass());
|
220 |
| |
221 |
| |
222 |
1
| cfg = createCacheLoaderCfg(false);
|
223 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, false, "org.jboss.cache.loader.FileCacheLoader"));
|
224 |
1
| cfg.addIndividualCacheLoaderConfig(createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.JDBCCacheLoader"));
|
225 |
| |
226 |
1
| mgr.setConfig(cfg, null);
|
227 |
1
| cl = mgr.getCacheLoader();
|
228 |
| |
229 |
1
| Assert.assertEquals(ChainingCacheLoader.class, cl.getClass());
|
230 |
1
| Assert.assertEquals(2, ((ChainingCacheLoader) cl).getSize());
|
231 |
1
| loaders = ((ChainingCacheLoader) cl).getCacheLoaders();
|
232 |
1
| Assert.assertEquals(FileCacheLoader.class, loaders.get(0).getClass());
|
233 |
1
| Assert.assertEquals(AsyncCacheLoader.class, loaders.get(1).getClass());
|
234 |
| } |
235 |
| |
236 |
1
| public void testChainingCacheLoaderFromXml() throws Exception
|
237 |
| { |
238 |
| |
239 |
1
| String conf = "<config><passivation>false</passivation>" +
|
240 |
| "<cacheloader>" + |
241 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
242 |
| " <async>false</async>" + |
243 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
244 |
| " <ignoreModifications>false</ignoreModifications>" + |
245 |
| " <properties>" + |
246 |
| " location=" + getTempDir() + |
247 |
| " </properties>" + |
248 |
| "</cacheloader>" + |
249 |
| "<cacheloader>" + |
250 |
| " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" + |
251 |
| " <async>false</async>" + |
252 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
253 |
| " <ignoreModifications>false</ignoreModifications>" + |
254 |
| " <properties>" + |
255 |
| "cache.jdbc.driver=com.mysql.jdbc.Driver\ncache.jdbc.url=jdbc:mysql://localhost/test\ncache.jdbc.user=user\ncache.jdbc.password=pwd" + |
256 |
| " </properties>" + |
257 |
| "</cacheloader></config>"; |
258 |
| |
259 |
1
| CacheLoaderConfig clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
260 |
1
| CacheLoaderManager mgr = new CacheLoaderManager();
|
261 |
1
| mgr.setConfig(clc, null);
|
262 |
1
| CacheLoader cl = mgr.getCacheLoader();
|
263 |
| |
264 |
| |
265 |
1
| Assert.assertEquals(ChainingCacheLoader.class, cl.getClass());
|
266 |
1
| Assert.assertEquals(2, ((ChainingCacheLoader) cl).getSize());
|
267 |
1
| List loaders = ((ChainingCacheLoader) cl).getCacheLoaders();
|
268 |
1
| Assert.assertEquals(FileCacheLoader.class, loaders.get(0).getClass());
|
269 |
1
| Assert.assertEquals(JDBCCacheLoader.class, loaders.get(1).getClass());
|
270 |
| |
271 |
| |
272 |
1
| conf = "<config>" +
|
273 |
| "<passivation>false</passivation>" + |
274 |
| "<cacheloader>" + |
275 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
276 |
| " <async>false</async>" + |
277 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
278 |
| " <ignoreModifications>false</ignoreModifications>" + |
279 |
| " <properties>" + |
280 |
| " location=" + getTempDir() + |
281 |
| " </properties>" + |
282 |
| "</cacheloader>" + |
283 |
| "<cacheloader>" + |
284 |
| " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" + |
285 |
| " <async>true</async>" + |
286 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
287 |
| " <ignoreModifications>false</ignoreModifications>" + |
288 |
| " <properties>" + |
289 |
| "cache.jdbc.driver=com.mysql.jdbc.Driver\ncache.jdbc.url=jdbc:mysql://localhost/test\ncache.jdbc.user=user\ncache.jdbc.password=pwd" + |
290 |
| " </properties>" + |
291 |
| "</cacheloader></config>"; |
292 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
293 |
1
| mgr.setConfig(clc, null);
|
294 |
1
| cl = mgr.getCacheLoader();
|
295 |
| |
296 |
1
| Assert.assertEquals(ChainingCacheLoader.class, cl.getClass());
|
297 |
1
| Assert.assertEquals(2, ((ChainingCacheLoader) cl).getSize());
|
298 |
1
| loaders = ((ChainingCacheLoader) cl).getCacheLoaders();
|
299 |
1
| Assert.assertEquals(FileCacheLoader.class, loaders.get(0).getClass());
|
300 |
1
| Assert.assertEquals(AsyncCacheLoader.class, loaders.get(1).getClass());
|
301 |
| } |
302 |
| |
303 |
1
| public void testMoreThanOneFetchPersistentState() throws Exception
|
304 |
| { |
305 |
1
| CacheLoaderManager mgr = new CacheLoaderManager();
|
306 |
1
| CacheLoaderConfig cfg = createCacheLoaderCfg(false);
|
307 |
1
| CacheLoaderConfig.IndividualCacheLoaderConfig i = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
|
308 |
1
| i.setFetchPersistentState(true);
|
309 |
1
| CacheLoaderConfig.IndividualCacheLoaderConfig i2 = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
|
310 |
1
| i2.setFetchPersistentState(true);
|
311 |
| |
312 |
1
| cfg.addIndividualCacheLoaderConfig(i);
|
313 |
1
| cfg.addIndividualCacheLoaderConfig(i2);
|
314 |
| |
315 |
1
| Assert.assertEquals(2, cfg.getIndividualCacheLoaderConfigs().size());
|
316 |
| |
317 |
1
| try
|
318 |
| { |
319 |
1
| mgr.setConfig(cfg, null);
|
320 |
0
| Assert.assertTrue("Should throw exception since we have > 1 cache loader with fetchPersistentState as true", false);
|
321 |
| } |
322 |
| catch (Exception e) |
323 |
| { |
324 |
1
| Assert.assertTrue(true);
|
325 |
| } |
326 |
| |
327 |
| |
328 |
1
| mgr = new CacheLoaderManager();
|
329 |
1
| cfg = createCacheLoaderCfg(false);
|
330 |
1
| i = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
|
331 |
1
| i.setFetchPersistentState(true);
|
332 |
| |
333 |
1
| cfg.addIndividualCacheLoaderConfig(i);
|
334 |
| |
335 |
1
| Assert.assertEquals(1, cfg.getIndividualCacheLoaderConfigs().size());
|
336 |
1
| mgr.setConfig(cfg, null);
|
337 |
| |
338 |
| |
339 |
1
| mgr = new CacheLoaderManager();
|
340 |
1
| cfg = createCacheLoaderCfg(false);
|
341 |
1
| i = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
|
342 |
1
| i.setFetchPersistentState(true);
|
343 |
1
| i2 = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
|
344 |
1
| i2.setFetchPersistentState(false);
|
345 |
| |
346 |
1
| cfg.addIndividualCacheLoaderConfig(i);
|
347 |
1
| cfg.addIndividualCacheLoaderConfig(i2);
|
348 |
| |
349 |
1
| Assert.assertEquals(2, cfg.getIndividualCacheLoaderConfigs().size());
|
350 |
1
| mgr.setConfig(cfg, null);
|
351 |
| |
352 |
| |
353 |
1
| mgr = new CacheLoaderManager();
|
354 |
1
| cfg = createCacheLoaderCfg(false);
|
355 |
1
| i = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
|
356 |
1
| i.setFetchPersistentState(false);
|
357 |
1
| i2 = createIndividualCacheLoaderConfig(cfg, true, "org.jboss.cache.loader.FileCacheLoader");
|
358 |
1
| i2.setFetchPersistentState(false);
|
359 |
| |
360 |
1
| cfg.addIndividualCacheLoaderConfig(i);
|
361 |
1
| cfg.addIndividualCacheLoaderConfig(i2);
|
362 |
| |
363 |
1
| Assert.assertEquals(2, cfg.getIndividualCacheLoaderConfigs().size());
|
364 |
1
| mgr.setConfig(cfg, null);
|
365 |
| } |
366 |
| |
367 |
1
| public void testConfigurationParsing() throws Exception
|
368 |
| { |
369 |
| |
370 |
1
| String conf = "<config>" +
|
371 |
| "<passivation>false</passivation>" + |
372 |
| "<preload>/, /blah, /blah2</preload>" + |
373 |
| "<cacheloader>" + |
374 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
375 |
| " <async>false</async>" + |
376 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
377 |
| " <ignoreModifications>true</ignoreModifications>" + |
378 |
| " <properties>" + |
379 |
| " location=" + getTempDir() + |
380 |
| " </properties>" + |
381 |
| "</cacheloader>" + |
382 |
| "<cacheloader>" + |
383 |
| " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" + |
384 |
| " <async>true</async>" + |
385 |
| " <fetchPersistentState>true</fetchPersistentState>" + |
386 |
| " <ignoreModifications>false</ignoreModifications>" + |
387 |
| " <properties>" + |
388 |
| "cache.jdbc.driver=com.mysql.jdbc.Driver\ncache.jdbc.url=jdbc:mysql://localhost/test\ncache.jdbc.user=user\ncache.jdbc.password=pwd" + |
389 |
| " </properties>" + |
390 |
| "</cacheloader></config>"; |
391 |
1
| CacheLoaderConfig clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
392 |
1
| CacheLoaderManager mgr = new CacheLoaderManager();
|
393 |
1
| mgr.setConfig(clc, null);
|
394 |
| |
395 |
1
| Assert.assertEquals(ChainingCacheLoader.class, mgr.getCacheLoader().getClass());
|
396 |
1
| Assert.assertTrue("Should be true", mgr.isFetchPersistentState());
|
397 |
1
| Assert.assertTrue("Passivation shuld be false", !mgr.isPassivation());
|
398 |
1
| CacheLoaderConfig c = mgr.getCacheLoaderConfig();
|
399 |
1
| Assert.assertTrue("Should be using a chaining cache loader", c.useChainingCacheLoader());
|
400 |
1
| Assert.assertEquals("/, /blah, /blah2", c.getPreload());
|
401 |
1
| Assert.assertEquals(2, c.getIndividualCacheLoaderConfigs().size());
|
402 |
| |
403 |
1
| CacheLoaderConfig.IndividualCacheLoaderConfig icfg = c.getIndividualCacheLoaderConfigs().get(0);
|
404 |
1
| Assert.assertEquals("org.jboss.cache.loader.FileCacheLoader", icfg.getClassName());
|
405 |
1
| Assert.assertTrue("Async shld be false", !icfg.isAsync());
|
406 |
1
| Assert.assertTrue("fetchPersistentState shld be false", !icfg.isFetchPersistentState());
|
407 |
1
| Assert.assertTrue("IgnoreMods should be true", icfg.isIgnoreModifications());
|
408 |
1
| Assert.assertEquals(1, icfg.getProperties().size());
|
409 |
| |
410 |
1
| icfg = c.getIndividualCacheLoaderConfigs().get(1);
|
411 |
1
| Assert.assertEquals("org.jboss.cache.loader.JDBCCacheLoader", icfg.getClassName());
|
412 |
1
| Assert.assertTrue("Async shld be true", icfg.isAsync());
|
413 |
1
| Assert.assertTrue("fetchPersistentState shld be true", icfg.isFetchPersistentState());
|
414 |
1
| Assert.assertTrue("IgnoreMods should be false", !icfg.isIgnoreModifications());
|
415 |
1
| Assert.assertEquals(4, icfg.getProperties().size());
|
416 |
| |
417 |
| |
418 |
1
| conf = "<config>" +
|
419 |
| "<passivation>false</passivation>" + |
420 |
| "<preload>/, /blah, /blah2</preload>" + |
421 |
| "<cacheloader>" + |
422 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
423 |
| " <async>false</async>" + |
424 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
425 |
| " <ignoreModifications>true</ignoreModifications>" + |
426 |
| " <properties>" + |
427 |
| " location=" + getTempDir() + |
428 |
| " </properties>" + |
429 |
| "</cacheloader>" + |
430 |
| "<cacheloader>" + |
431 |
| " <class>org.jboss.cache.loader.JDBCCacheLoader</class>" + |
432 |
| " <async>true</async>" + |
433 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
434 |
| " <ignoreModifications>false</ignoreModifications>" + |
435 |
| " <properties>" + |
436 |
| "cache.jdbc.driver=com.mysql.jdbc.Driver\ncache.jdbc.url=jdbc:mysql://localhost/test\ncache.jdbc.user=user\ncache.jdbc.password=pwd" + |
437 |
| " </properties>" + |
438 |
| "</cacheloader></config>"; |
439 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
440 |
| |
441 |
1
| mgr = new CacheLoaderManager();
|
442 |
1
| mgr.setConfig(clc, null);
|
443 |
| |
444 |
1
| Assert.assertTrue("Should be false", !mgr.isFetchPersistentState());
|
445 |
| |
446 |
| |
447 |
| } |
448 |
| |
449 |
1
| public void testSingletonConfiguration() throws Exception
|
450 |
| { |
451 |
1
| String conf = "<config>" +
|
452 |
| "<passivation>false</passivation>" + |
453 |
| "<preload>/, /blah, /blah2</preload>" + |
454 |
| "<cacheloader>" + |
455 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
456 |
| " <async>false</async>" + |
457 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
458 |
| " <ignoreModifications>true</ignoreModifications>" + |
459 |
| " <properties>" + |
460 |
| " location=" + getTempDir() + |
461 |
| " </properties>" + |
462 |
| "</cacheloader>" + |
463 |
| "</config>"; |
464 |
1
| CacheLoaderConfig clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
465 |
1
| CacheLoaderManager mgr = new CacheLoaderManager();
|
466 |
1
| mgr.setConfig(clc, null);
|
467 |
| |
468 |
1
| CacheLoaderConfig.IndividualCacheLoaderConfig iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
|
469 |
1
| assertFalse("Singleton has not been configured", iclc.isSingletonStore());
|
470 |
1
| assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
|
471 |
| |
472 |
1
| conf = "<config>" +
|
473 |
| "<passivation>false</passivation>" + |
474 |
| "<preload>/, /blah, /blah2</preload>" + |
475 |
| "<cacheloader>" + |
476 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
477 |
| " <async>false</async>" + |
478 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
479 |
| " <ignoreModifications>true</ignoreModifications>" + |
480 |
| " <properties>" + |
481 |
| " location=" + getTempDir() + |
482 |
| " </properties>" + |
483 |
| " <singletonStore>true</singletonStore>" + |
484 |
| "</cacheloader>" + |
485 |
| "</config>"; |
486 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
487 |
1
| mgr = new MockCacheLoaderManager();
|
488 |
1
| mgr.setConfig(clc, null);
|
489 |
| |
490 |
1
| iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
|
491 |
1
| assertTrue("Singleton has been configured", iclc.isSingletonStore());
|
492 |
1
| assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
|
493 |
| |
494 |
1
| conf = "<config>" +
|
495 |
| "<passivation>false</passivation>" + |
496 |
| "<preload>/, /blah, /blah2</preload>" + |
497 |
| "<cacheloader>" + |
498 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
499 |
| " <async>false</async>" + |
500 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
501 |
| " <ignoreModifications>true</ignoreModifications>" + |
502 |
| " <properties>" + |
503 |
| " location=" + getTempDir() + |
504 |
| " </properties>" + |
505 |
| " <singletonStore>false</singletonStore>" + |
506 |
| "</cacheloader>" + |
507 |
| "</config>"; |
508 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
509 |
1
| mgr = new CacheLoaderManager();
|
510 |
1
| mgr.setConfig(clc, null);
|
511 |
| |
512 |
1
| iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
|
513 |
1
| assertFalse("Singleton has not been configured", iclc.isSingletonStore());
|
514 |
1
| assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
|
515 |
| |
516 |
1
| conf = "<config>" +
|
517 |
| "<passivation>false</passivation>" + |
518 |
| "<preload>/, /blah, /blah2</preload>" + |
519 |
| "<cacheloader>" + |
520 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
521 |
| " <async>false</async>" + |
522 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
523 |
| " <ignoreModifications>true</ignoreModifications>" + |
524 |
| " <properties>" + |
525 |
| " location=" + getTempDir() + |
526 |
| " </properties>" + |
527 |
| " <singletonStore pushStateWhenCoordinator=\"false\">true</singletonStore>" + |
528 |
| "</cacheloader>" + |
529 |
| "</config>"; |
530 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
531 |
1
| mgr = new MockCacheLoaderManager();
|
532 |
1
| mgr.setConfig(clc, null);
|
533 |
| |
534 |
1
| iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
|
535 |
1
| assertTrue("Singleton has been configured", iclc.isSingletonStore());
|
536 |
1
| assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
|
537 |
| |
538 |
1
| conf = "<config>" +
|
539 |
| "<passivation>false</passivation>" + |
540 |
| "<preload>/, /blah, /blah2</preload>" + |
541 |
| "<cacheloader>" + |
542 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
543 |
| " <async>false</async>" + |
544 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
545 |
| " <ignoreModifications>true</ignoreModifications>" + |
546 |
| " <properties>" + |
547 |
| " location=" + getTempDir() + |
548 |
| " </properties>" + |
549 |
| " <singletonStore pushStateWhenCoordinator=\"false\">false</singletonStore>" + |
550 |
| "</cacheloader>" + |
551 |
| "</config>"; |
552 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
553 |
1
| mgr = new CacheLoaderManager();
|
554 |
1
| mgr.setConfig(clc, null);
|
555 |
| |
556 |
1
| iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
|
557 |
1
| assertFalse("Singleton has not been configured", iclc.isSingletonStore());
|
558 |
1
| assertFalse("Singleton.pushStateWhenCoordinator has not been configured", iclc.isPushStateWhenCoordinator());
|
559 |
| |
560 |
1
| conf = "<config>" +
|
561 |
| "<passivation>false</passivation>" + |
562 |
| "<preload>/, /blah, /blah2</preload>" + |
563 |
| "<cacheloader>" + |
564 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
565 |
| " <async>false</async>" + |
566 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
567 |
| " <ignoreModifications>true</ignoreModifications>" + |
568 |
| " <properties>" + |
569 |
| " location=" + getTempDir() + |
570 |
| " </properties>" + |
571 |
| " <singletonStore pushStateWhenCoordinator=\"true\">false</singletonStore>" + |
572 |
| "</cacheloader>" + |
573 |
| "</config>"; |
574 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
575 |
1
| mgr = new CacheLoaderManager();
|
576 |
1
| mgr.setConfig(clc, null);
|
577 |
| |
578 |
1
| iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
|
579 |
1
| assertFalse("Singleton has not been configured", iclc.isSingletonStore());
|
580 |
1
| assertFalse("Singleton.pushStateWhenCoordinator should be false has not been configured", iclc.isPushStateWhenCoordinator());
|
581 |
| |
582 |
1
| conf = "<config>" +
|
583 |
| "<passivation>false</passivation>" + |
584 |
| "<preload>/, /blah, /blah2</preload>" + |
585 |
| "<cacheloader>" + |
586 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
587 |
| " <async>false</async>" + |
588 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
589 |
| " <ignoreModifications>true</ignoreModifications>" + |
590 |
| " <properties>" + |
591 |
| " location=" + getTempDir() + |
592 |
| " </properties>" + |
593 |
| " <singletonStore pushStateWhenCoordinator=\"true\">true</singletonStore>" + |
594 |
| "</cacheloader>" + |
595 |
| "</config>"; |
596 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
597 |
1
| mgr = new MockCacheLoaderManager();
|
598 |
1
| mgr.setConfig(clc, null);
|
599 |
| |
600 |
1
| iclc = mgr.getCacheLoaderConfig().getFirstCacheLoaderConfig();
|
601 |
1
| assertTrue("Singleton has been configured", iclc.isSingletonStore());
|
602 |
1
| assertTrue("Singleton.pushStateWhenCoordinator has been configured", iclc.isPushStateWhenCoordinator());
|
603 |
| |
604 |
1
| conf = "<config>" +
|
605 |
| "<passivation>false</passivation>" + |
606 |
| "<shared>true</shared>" + |
607 |
| "<preload>/, /blah, /blah2</preload>" + |
608 |
| "<cacheloader>" + |
609 |
| " <class>org.jboss.cache.loader.FileCacheLoader</class>" + |
610 |
| " <async>false</async>" + |
611 |
| " <fetchPersistentState>false</fetchPersistentState>" + |
612 |
| " <ignoreModifications>true</ignoreModifications>" + |
613 |
| " <properties>" + |
614 |
| " location=" + getTempDir() + |
615 |
| " </properties>" + |
616 |
| " <singletonStore pushStateWhenCoordinator=\"true\">true</singletonStore>" + |
617 |
| "</cacheloader>" + |
618 |
| "</config>"; |
619 |
1
| clc = XmlConfigurationParser.parseCacheLoaderConfig(strToElement(conf));
|
620 |
1
| mgr = new CacheLoaderManager();
|
621 |
1
| try
|
622 |
| { |
623 |
1
| mgr.setConfig(clc, null);
|
624 |
0
| fail("A cache loader cannot be configured as singleton and shared, should have thrown an Exception");
|
625 |
| } |
626 |
| catch (Exception e) |
627 |
| { |
628 |
| } |
629 |
| } |
630 |
| |
631 |
| private class MockCacheLoaderManager extends CacheLoaderManager |
632 |
| { |
633 |
3
| protected void addCacheListener(CacheSPI cache, CacheListener listener)
|
634 |
| { |
635 |
| |
636 |
| } |
637 |
| } |
638 |
| |
639 |
1
| public static Test suite()
|
640 |
| { |
641 |
1
| return new TestSuite(CacheLoaderManagerTest.class);
|
642 |
| } |
643 |
| |
644 |
0
| public static void main(String[] args)
|
645 |
| { |
646 |
0
| junit.textui.TestRunner.run(suite());
|
647 |
| } |
648 |
| } |