|
1
22 package org.jboss.test.system.controller.lifecycle.seperated.test;
23
24 import java.util.List  ;
25
26 import javax.management.ObjectName ;
27
28 import org.jboss.mx.util.ObjectNameFactory;
29 import org.jboss.test.AbstractTestDelegate;
30 import org.jboss.test.system.controller.AbstractControllerTest;
31 import org.jboss.test.system.controller.support.Simple;
32
33
39 public abstract class NewOnDemandDependencyTest extends AbstractControllerTest
40 {
41 private static ObjectName NAME_ONE = ObjectNameFactory.create("test:name=1");
42 private static ObjectName NAME_TWO = ObjectNameFactory.create("test:name=2");
43
44 protected String resourceName1;
45 protected String resourceName2;
46
47 public NewOnDemandDependencyTest(String name)
48 {
49 super(name);
50 }
51
52 public static AbstractTestDelegate getDelegate(Class clazz) throws Exception
53 {
54 return getNewControllerDelegate(clazz);
55 }
56
57 public void testDeployCorrectOrder() throws Exception
58 {
59 Simple test1 = null;
60 Simple test2 = null;
61
62 boolean error = false;
63
64 List <ObjectName > mbeans1 = deploy(resourceName1);
65 try
66 {
67 assertServiceInstalled(NAME_ONE);
68 assertNotRegistered(NAME_ONE);
69 assertNoService(NAME_TWO);
70
71 List <ObjectName > mbeans2 = deploy(resourceName2);
72 try
73 {
74 assertServiceRunning(NAME_ONE);
75 assertServiceRunning(NAME_TWO);
76
77 test1 = getMBean(Simple.class, NAME_ONE, "Instance");
78 assertEquals(1, test1.createOrder);
79 assertEquals(3, test1.startOrder);
80 assertEquals(0, test1.stopOrder);
81 assertEquals(0, test1.destroyOrder);
82 test2 = getMBean(Simple.class, NAME_TWO, "Instance");
83 assertEquals("()", test2.constructorUsed);
84 assertEquals(2, test2.createOrder);
85 assertEquals(4, test2.startOrder);
86 assertEquals(0, test2.stopOrder);
87 assertEquals(0, test2.destroyOrder);
88 }
89 catch (Exception e)
90 {
91 error = true;
92 throw e;
93 }
94 catch (Error e)
95 {
96 error = true;
97 throw e;
98 }
99 finally
100 {
101 undeploy(mbeans2);
102
103 if (error == false)
104 {
105 assertServiceRunning(NAME_ONE);
106 assertEquals(1, test1.createOrder);
107 assertEquals(3, test1.startOrder);
108 assertEquals(0, test1.stopOrder);
109 assertEquals(0, test1.destroyOrder);
110 assertNoService(NAME_TWO);
111 assertNotRegistered(NAME_TWO);
112 assertEquals(2, test2.createOrder);
113 assertEquals(4, test2.startOrder);
114 assertEquals(5, test2.stopOrder);
115 assertEquals(6, test2.destroyOrder);
116 }
117 }
118 }
119 catch (Exception e)
120 {
121 error = true;
122 throw e;
123 }
124 catch (Error e)
125 {
126 error = true;
127 throw e;
128 }
129 finally
130 {
131 undeploy(mbeans1);
132
133 if (error == false)
134 {
135 assertNoService(NAME_ONE);
136 assertNotRegistered(NAME_ONE);
137 assertEquals(1, test1.createOrder);
138 assertEquals(3, test1.startOrder);
139 assertEquals(7, test1.stopOrder);
140 assertEquals(8, test1.destroyOrder);
141 assertNoService(NAME_TWO);
142 assertNotRegistered(NAME_TWO);
143 if (test2 != null)
144 {
145 assertEquals(2, test2.createOrder);
146 assertEquals(4, test2.startOrder);
147 assertEquals(5, test2.stopOrder);
148 assertEquals(6, test2.destroyOrder);
149 }
150 }
151 }
152 }
153
154 public void testDeployWrongOrder() throws Exception
155 {
156 Simple test1 = null;
157 Simple test2 = null;
158
159 boolean error = false;
160
161 List <ObjectName > mbeans2 = deploy(resourceName2);
162 try
163 {
164 assertServiceConfigured(NAME_TWO);
165
166 test2 = getMBean(Simple.class, NAME_TWO, "Instance");
167 assertEquals("()", test2.constructorUsed);
168 assertEquals(0, test2.createOrder);
169 assertEquals(0, test2.startOrder);
170 assertEquals(0, test2.stopOrder);
171 assertEquals(0, test2.destroyOrder);
172
173 List <ObjectName > mbeans1 = deploy(resourceName1);
174 try
175 {
176 assertServiceRunning(NAME_TWO);
177 assertServiceRunning(NAME_ONE);
178
179 assertEquals(2, test2.createOrder);
180 assertEquals(4, test2.startOrder);
181 assertEquals(0, test2.stopOrder);
182 assertEquals(0, test2.destroyOrder);
183 test1 = getMBean(Simple.class, NAME_ONE, "Instance");
184 assertEquals("()", test1.constructorUsed);
185 assertEquals(1, test1.createOrder);
186 assertEquals(3, test1.startOrder);
187 assertEquals(0, test1.stopOrder);
188 assertEquals(0, test1.destroyOrder);
189 }
190 catch (Exception e)
191 {
192 error = true;
193 throw e;
194 }
195 catch (Error e)
196 {
197 error = true;
198 throw e;
199 }
200 finally
201 {
202 undeploy(mbeans1);
203
204 if (error == false)
205 {
206 assertServiceDestroyed(NAME_TWO);
207 assertEquals(2, test2.createOrder);
208 assertEquals(4, test2.startOrder);
209 assertEquals(5, test2.stopOrder);
210 assertEquals(7, test2.destroyOrder);
211 assertNotRegistered(NAME_ONE);
212 assertEquals(1, test1.createOrder);
213 assertEquals(3, test1.startOrder);
214 assertEquals(6, test1.stopOrder);
215 assertEquals(8, test1.destroyOrder);
216 }
217 }
218 }
219 catch (Exception e)
220 {
221 error = true;
222 throw e;
223 }
224 catch (Error e)
225 {
226 error = true;
227 throw e;
228 }
229 finally
230 {
231 undeploy(mbeans2);
232
233 if (error == false)
234 {
235 assertNoService(NAME_TWO);
236 assertNotRegistered(NAME_TWO);
237 assertEquals(2, test2.createOrder);
238 assertEquals(4, test2.startOrder);
239 assertEquals(5, test2.stopOrder);
240 assertEquals(7, test2.destroyOrder);
241 assertNoService(NAME_ONE);
242 assertNotRegistered(NAME_ONE);
243 if (test1 != null)
244 {
245 assertEquals(1, test1.createOrder);
246 assertEquals(3, test1.startOrder);
247 assertEquals(6, test1.stopOrder);
248 assertEquals(8, test1.destroyOrder);
249 }
250 }
251 }
252 }
253
254 public void testRedeployOne() throws Exception
255 {
256 Simple test1 = null;
257 Simple test2 = null;
258
259 boolean error = false;
260
261 List <ObjectName > mbeans1 = deploy(resourceName1);
262 try
263 {
264 List <ObjectName > mbeans2 = deploy(resourceName2);
265 try
266 {
267 assertServiceRunning(NAME_ONE);
268 assertServiceRunning(NAME_TWO);
269
270 test1 = getMBean(Simple.class, NAME_ONE, "Instance");
271 assertEquals("()", test1.constructorUsed);
272 assertEquals(1, test1.createOrder);
273 assertEquals(3, test1.startOrder);
274 assertEquals(0, test1.stopOrder);
275 assertEquals(0, test1.destroyOrder);
276 test2 = getMBean(Simple.class, NAME_TWO, "Instance");
277 assertEquals("()", test2.constructorUsed);
278 assertEquals(2, test2.createOrder);
279 assertEquals(4, test2.startOrder);
280 assertEquals(0, test2.stopOrder);
281 assertEquals(0, test2.destroyOrder);
282
283 undeploy(mbeans1);
284
285 assertNotRegistered(NAME_ONE);
286 assertServiceDestroyed(NAME_TWO);
287
288 assertEquals(1, test1.createOrder);
289 assertEquals(3, test1.startOrder);
290 assertEquals(6, test1.stopOrder);
291 assertEquals(8, test1.destroyOrder);
292 assertEquals(2, test2.createOrder);
293 assertEquals(4, test2.startOrder);
294 assertEquals(5, test2.stopOrder);
295 assertEquals(7, test2.destroyOrder);
296
297 mbeans1 = deploy(resourceName1);
298
299 assertServiceRunning(NAME_ONE);
300 assertServiceRunning(NAME_TWO);
301
302 test1 = getMBean(Simple.class, NAME_ONE, "Instance");
303 assertEquals("()", test1.constructorUsed);
304 assertEquals(9, test1.createOrder);
305 assertEquals(11, test1.startOrder);
306 assertEquals(0, test1.stopOrder);
307 assertEquals(0, test1.destroyOrder);
308 assertEquals(10, test2.createOrder);
309 assertEquals(12, test2.startOrder);
310 assertEquals(5, test2.stopOrder);
311 assertEquals(7, test2.destroyOrder);
312 }
313 catch (Exception e)
314 {
315 error = true;
316 throw e;
317 }
318 catch (Error e)
319 {
320 error = true;
321 throw e;
322 }
323 finally
324 {
325 undeploy(mbeans2);
326
327 if (error == false)
328 {
329 assertServiceRunning(NAME_ONE);
330 assertEquals(9, test1.createOrder);
331 assertEquals(11, test1.startOrder);
332 assertEquals(0, test1.stopOrder);
333 assertEquals(0, test1.destroyOrder);
334 assertNoService(NAME_TWO);
335 assertNotRegistered(NAME_TWO);
336 assertEquals(10, test2.createOrder);
337 assertEquals(12, test2.startOrder);
338 assertEquals(13, test2.stopOrder);
339 assertEquals(14, test2.destroyOrder);
340 }
341 }
342 }
343 catch (Exception e)
344 {
345 error = true;
346 throw e;
347 }
348 catch (Error e)
349 {
350 error = true;
351 throw e;
352 }
353 finally
354 {
355 undeploy(mbeans1);
356
357 if (error == false)
358 {
359 assertNoService(NAME_ONE);
360 assertNotRegistered(NAME_ONE);
361 assertEquals(9, test1.createOrder);
362 assertEquals(11, test1.startOrder);
363 assertEquals(15, test1.stopOrder);
364 assertEquals(16, test1.destroyOrder);
365 assertNoService(NAME_TWO);
366 assertNotRegistered(NAME_TWO);
367 if (test2 != null)
368 {
369 assertEquals(10, test2.createOrder);
370 assertEquals(12, test2.startOrder);
371 assertEquals(13, test2.stopOrder);
372 assertEquals(14, test2.destroyOrder);
373 }
374 }
375 }
376 }
377
378 public void testRedeployTwo() throws Exception
379 {
380 Simple test1 = null;
381 Simple test2 = null;
382
383 boolean error = false;
384
385 List <ObjectName > mbeans1 = deploy(resourceName1);
386 try
387 {
388 List <ObjectName > mbeans2 = deploy(resourceName2);
389 try
390 {
391 assertServiceRunning(NAME_ONE);
392 assertServiceRunning(NAME_TWO);
393
394 test1 = getMBean(Simple.class, NAME_ONE, "Instance");
395 assertEquals("()", test1.constructorUsed);
396 assertEquals(1, test1.createOrder);
397 assertEquals(3, test1.startOrder);
398 assertEquals(0, test1.stopOrder);
399 assertEquals(0, test1.destroyOrder);
400 test2 = getMBean(Simple.class, NAME_TWO, "Instance");
401 assertEquals("()", test2.constructorUsed);
402 assertEquals(2, test2.createOrder);
403 assertEquals(4, test2.startOrder);
404 assertEquals(0, test2.stopOrder);
405 assertEquals(0, test2.destroyOrder);
406
407 undeploy(mbeans2);
408
409 assertServiceRunning(NAME_ONE);
410 assertNoService(NAME_TWO);
411
412 assertEquals(1, test1.createOrder);
413 assertEquals(3, test1.startOrder);
414 assertEquals(0, test1.stopOrder);
415 assertEquals(0, test1.destroyOrder);
416 assertEquals(2, test2.createOrder);
417 assertEquals(4, test2.startOrder);
418 assertEquals(5, test2.stopOrder);
419 assertEquals(6, test2.destroyOrder);
420
421 mbeans2 = deploy(resourceName2);
422
423 assertServiceRunning(NAME_ONE);
424 assertServiceRunning(NAME_TWO);
425
426 assertEquals(1, test1.createOrder);
427 assertEquals(3, test1.startOrder);
428 assertEquals(0, test1.stopOrder);
429 assertEquals(0, test1.destroyOrder);
430 test2 = getMBean(Simple.class, NAME_TWO, "Instance");
431 assertEquals("()", test1.constructorUsed);
432 assertEquals(7, test2.createOrder);
433 assertEquals(8, test2.startOrder);
434 assertEquals(0, test2.stopOrder);
435 assertEquals(0, test2.destroyOrder);
436 }
437 catch (Exception e)
438 {
439 error = true;
440 throw e;
441 }
442 catch (Error e)
443 {
444 error = true;
445 throw e;
446 }
447 finally
448 {
449 undeploy(mbeans2);
450
451 if (error == false)
452 {
453 assertServiceRunning(NAME_ONE);
454 assertEquals(1, test1.createOrder);
455 assertEquals(3, test1.startOrder);
456 assertEquals(0, test1.stopOrder);
457 assertEquals(0, test1.destroyOrder);
458 assertNoService(NAME_TWO);
459 assertNotRegistered(NAME_TWO);
460 assertEquals(7, test2.createOrder);
461 assertEquals(8, test2.startOrder);
462 assertEquals(9, test2.stopOrder);
463 assertEquals(10, test2.destroyOrder);
464 }
465 }
466 }
467 catch (Exception e)
468 {
469 error = true;
470 throw e;
471 }
472 catch (Error e)
473 {
474 error = true;
475 throw e;
476 }
477 finally
478 {
479 undeploy(mbeans1);
480
481 if (error == false)
482 {
483 assertNoService(NAME_ONE);
484 assertNotRegistered(NAME_ONE);
485 assertEquals(1, test1.createOrder);
486 assertEquals(3, test1.startOrder);
487 assertEquals(11, test1.stopOrder);
488 assertEquals(12, test1.destroyOrder);
489 assertNoService(NAME_TWO);
490 assertNotRegistered(NAME_TWO);
491 if (test2 != null)
492 {
493 assertEquals(7, test2.createOrder);
494 assertEquals(8, test2.startOrder);
495 assertEquals(9, test2.stopOrder);
496 assertEquals(10, test2.destroyOrder);
497 }
498 }
499 }
500 }
501 }
502 |
Popular Tags |
Java API By Example, From Geeks To Geeks.