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