1
2
3
4
5
6
7
8
9
10 package org.mule.registry;
11
12 import org.mule.api.MuleContext;
13 import org.mule.api.context.MuleContextAware;
14 import org.mule.api.lifecycle.Disposable;
15 import org.mule.api.lifecycle.Initialisable;
16 import org.mule.api.lifecycle.Startable;
17 import org.mule.api.lifecycle.Stoppable;
18 import org.mule.api.registry.MuleRegistry;
19 import org.mule.api.registry.RegistrationException;
20 import org.mule.tck.AbstractMuleTestCase;
21
22 import java.util.ArrayList;
23 import java.util.List;
24
25 import javax.annotation.PostConstruct;
26 import javax.annotation.PreDestroy;
27
28 public class TransientRegistryTestCase extends AbstractMuleTestCase
29 {
30 public void testObjectLifecycle() throws Exception
31 {
32 muleContext.start();
33
34 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
35 muleContext.getRegistry().registerObject("test", tracker);
36
37 muleContext.dispose();
38 assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
39 }
40
41 public void testJSR250ObjectLifecycle() throws Exception
42 {
43 muleContext.start();
44
45 JSR250ObjectLifecycleTracker tracker = new JSR250ObjectLifecycleTracker();
46 muleContext.getRegistry().registerObject("test", tracker);
47
48 muleContext.dispose();
49 assertEquals("[setMuleContext, initialise, dispose]", tracker.getTracker().toString());
50 }
51
52 public void testObjectLifecycleWithTransientRegistryDirectly() throws Exception
53 {
54 TransientRegistry reg = new TransientRegistry(muleContext);
55 reg.initialise();
56 reg.fireLifecycle(Startable.PHASE_NAME);
57
58 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
59 reg.registerObject("test", tracker);
60
61 reg.dispose();
62 assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
63 }
64
65 public void testObjectBypassLifecycle() throws Exception
66 {
67 muleContext.start();
68
69 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
70 muleContext.getRegistry().registerObject("test", tracker, MuleRegistry.LIFECYCLE_BYPASS_FLAG);
71 muleContext.dispose();
72 assertEquals("[setMuleContext, stop, dispose]", tracker.getTracker().toString());
73 }
74
75 public void testObjectBypassLifecycleWithTransientRegistryDirectly() throws Exception
76 {
77 TransientRegistry reg = new TransientRegistry(muleContext);
78 reg.initialise();
79 reg.fireLifecycle(Startable.PHASE_NAME);
80
81 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
82 reg.registerObject("test", tracker, MuleRegistry.LIFECYCLE_BYPASS_FLAG);
83 reg.dispose();
84 assertEquals("[setMuleContext, stop, dispose]", tracker.getTracker().toString());
85 }
86
87 public void testObjectBypassInjectors() throws Exception
88 {
89 muleContext.start();
90 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
91 muleContext.getRegistry().registerObject("test", tracker, MuleRegistry.INJECT_PROCESSORS_BYPASS_FLAG);
92 muleContext.dispose();
93 assertEquals("[initialise, start, stop, dispose]", tracker.getTracker().toString());
94 }
95
96 public void testObjectBypassInjectorsWithTransientRegistryDirectly() throws Exception
97 {
98 TransientRegistry reg = new TransientRegistry(muleContext);
99 reg.initialise();
100 reg.fireLifecycle(Startable.PHASE_NAME);
101
102 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
103 reg.registerObject("test", tracker, MuleRegistry.INJECT_PROCESSORS_BYPASS_FLAG);
104 reg.dispose();
105 assertEquals("[initialise, start, stop, dispose]", tracker.getTracker().toString());
106 }
107
108 public void testObjectBypassLifecycleAndInjectors() throws Exception
109 {
110 muleContext.start();
111
112 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
113 muleContext.getRegistry().registerObject("test", tracker, MuleRegistry.LIFECYCLE_BYPASS_FLAG + MuleRegistry.INJECT_PROCESSORS_BYPASS_FLAG);
114 muleContext.dispose();
115 assertEquals("[stop, dispose]", tracker.getTracker().toString());
116 }
117
118 public void testObjectBypassLifecycleAndInjectorsWithTransientRegistryDirectly() throws Exception
119 {
120 TransientRegistry reg = new TransientRegistry(muleContext);
121 reg.initialise();
122 reg.fireLifecycle(Startable.PHASE_NAME);
123
124 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
125 reg.registerObject("test", tracker, MuleRegistry.LIFECYCLE_BYPASS_FLAG + MuleRegistry.INJECT_PROCESSORS_BYPASS_FLAG);
126 reg.dispose();
127 assertEquals("[stop, dispose]", tracker.getTracker().toString());
128
129 }
130
131 public void testObjectLifecycleStates() throws Exception
132 {
133 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
134 muleContext.getRegistry().registerObject("test", tracker);
135 assertEquals("[setMuleContext, initialise]", tracker.getTracker().toString());
136
137 try
138 {
139 muleContext.initialise();
140 fail("context already initialised");
141 }
142 catch (IllegalStateException e)
143 {
144
145 }
146
147 muleContext.start();
148 assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
149
150 try
151 {
152 muleContext.start();
153 fail("context already started");
154 }
155 catch (IllegalStateException e)
156 {
157
158 }
159
160 muleContext.stop();
161 assertEquals("[setMuleContext, initialise, start, stop]", tracker.getTracker().toString());
162
163 try
164 {
165 muleContext.stop();
166 fail("context already stopped");
167 }
168 catch (IllegalStateException e)
169 {
170
171 }
172
173 muleContext.dispose();
174 assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
175
176 try
177 {
178 muleContext.dispose();
179 fail("context already disposed");
180 }
181 catch (IllegalStateException e)
182 {
183
184 }
185
186 }
187
188 public void testObjectLifecycleRestart() throws Exception
189 {
190 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
191 muleContext.getRegistry().registerObject("test", tracker);
192
193 muleContext.start();
194 assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
195
196 muleContext.stop();
197 assertEquals("[setMuleContext, initialise, start, stop]", tracker.getTracker().toString());
198
199 muleContext.start();
200 assertEquals("[setMuleContext, initialise, start, stop, start]", tracker.getTracker().toString());
201
202 muleContext.dispose();
203 assertEquals("[setMuleContext, initialise, start, stop, start, stop, dispose]", tracker.getTracker().toString());
204 }
205
206 public void testObjectLifecycleRestartWithTransientRegistryDirectly() throws Exception
207 {
208 TransientRegistry reg = new TransientRegistry(muleContext);
209 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
210 reg.registerObject("test", tracker);
211
212 reg.fireLifecycle(Initialisable.PHASE_NAME);
213 reg.fireLifecycle(Startable.PHASE_NAME);
214 assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
215
216 reg.fireLifecycle(Stoppable.PHASE_NAME);
217 assertEquals("[setMuleContext, initialise, start, stop]", tracker.getTracker().toString());
218
219 reg.fireLifecycle(Startable.PHASE_NAME);
220 assertEquals("[setMuleContext, initialise, start, stop, start]", tracker.getTracker().toString());
221
222 reg.dispose();
223 assertEquals("[setMuleContext, initialise, start, stop, start, stop, dispose]", tracker.getTracker().toString());
224 }
225
226
227 public void testObjectLifecycleStatesWithTransientRegistryDirectly() throws Exception
228 {
229 TransientRegistry reg = new TransientRegistry(muleContext);
230 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
231 reg.registerObject("test", tracker);
232 assertEquals("[setMuleContext]", tracker.getTracker().toString());
233 reg.initialise();
234 assertEquals("[setMuleContext, initialise]", tracker.getTracker().toString());
235
236
237 reg.fireLifecycle(Startable.PHASE_NAME);
238 assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
239
240 try
241 {
242 reg.fireLifecycle(Startable.PHASE_NAME);
243 fail("Registry is already started");
244 }
245 catch (Exception e)
246 {
247
248 }
249
250 reg.fireLifecycle(Stoppable.PHASE_NAME);
251 assertEquals("[setMuleContext, initialise, start, stop]", tracker.getTracker().toString());
252
253 try
254 {
255 reg.fireLifecycle(Stoppable.PHASE_NAME);
256 fail("Registry is already stopped");
257 }
258 catch (Exception e)
259 {
260
261 }
262
263 reg.dispose();
264 assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
265
266 try
267 {
268 reg.dispose();
269 fail("Registry is already disposed");
270 }
271 catch (Exception e)
272 {
273
274 }
275 }
276
277
278 public void testLifecycleState() throws Exception
279 {
280 TransientRegistry reg = new TransientRegistry(muleContext);
281 reg.fireLifecycle(Initialisable.PHASE_NAME);
282 reg.fireLifecycle(Startable.PHASE_NAME);
283
284 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
285 reg.registerObject("test", tracker);
286 assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
287
288 reg.fireLifecycle(Disposable.PHASE_NAME);
289 assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
290 }
291
292 public void testLifecycleStateOutOfSequenceStartFirstWithTransientRegistryDirectly() throws Exception
293 {
294 TransientRegistry reg = new TransientRegistry(muleContext);
295 try
296 {
297
298 reg.fireLifecycle(Startable.PHASE_NAME);
299 fail("Cannot start without initialising first");
300 }
301 catch (IllegalStateException e)
302 {
303
304 }
305
306 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
307 reg.registerObject("test", tracker);
308
309 reg.fireLifecycle(Initialisable.PHASE_NAME);
310 reg.fireLifecycle(Startable.PHASE_NAME);
311
312
313 assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
314
315 reg.fireLifecycle(Disposable.PHASE_NAME);
316
317 assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
318 }
319
320 public void testLifecycleStateOutOfSequenceStopFirstWithTransientRegistryDirectly() throws Exception
321 {
322 TransientRegistry reg = new TransientRegistry(muleContext);
323 try
324 {
325
326 reg.fireLifecycle(Stoppable.PHASE_NAME);
327 fail("Cannot stop without starting first");
328 }
329 catch (IllegalStateException e)
330 {
331
332 }
333
334 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
335 reg.registerObject("test", tracker);
336
337 reg.fireLifecycle(Initialisable.PHASE_NAME);
338 reg.fireLifecycle(Startable.PHASE_NAME);
339 reg.fireLifecycle(Stoppable.PHASE_NAME);
340
341
342
343
344 assertEquals("[setMuleContext, initialise, start, stop]", tracker.getTracker().toString());
345
346 reg.fireLifecycle(Disposable.PHASE_NAME);
347 assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
348 }
349
350
351 public void testLifecycleStateOutOfSequenceDisposeFirstWithTransientRegistryDirectly() throws Exception
352 {
353 TransientRegistry reg = new TransientRegistry(muleContext);
354
355 reg.fireLifecycle(Disposable.PHASE_NAME);
356
357 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
358 try
359 {
360 reg.registerObject("test", tracker);
361 fail("Cannot register objects on a disposed registry");
362 }
363 catch (RegistrationException e)
364 {
365
366 }
367 }
368
369
370 public void testLifecycleStateOutOfSequenceStartFirst() throws Exception
371 {
372 muleContext.start();
373 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
374 muleContext.getRegistry().registerObject("test", tracker);
375
376 assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
377
378 muleContext.dispose();
379
380 assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
381 }
382
383 public void testLifecycleStateOutOfSequenceStopFirst() throws Exception
384 {
385 try
386 {
387 muleContext.stop();
388 fail("Cannot not stop the context if not started");
389 }
390 catch (IllegalStateException e)
391 {
392
393 }
394
395 muleContext.start();
396 muleContext.stop();
397 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
398 muleContext.getRegistry().registerObject("test", tracker);
399
400
401
402 assertEquals("[setMuleContext, initialise]", tracker.getTracker().toString());
403
404 muleContext.dispose();
405 assertEquals("[setMuleContext, initialise, dispose]", tracker.getTracker().toString());
406 }
407
408
409 public void testLifecycleStateOutOfSequenceDisposeFirst() throws Exception
410 {
411 muleContext.dispose();
412
413 InterfaceBasedTracker tracker = new InterfaceBasedTracker();
414 try
415 {
416 muleContext.getRegistry().registerObject("test", tracker);
417 fail("cannot register objects on a disposed registry");
418 }
419 catch (RegistrationException e)
420 {
421
422 }
423 }
424
425
426 public class InterfaceBasedTracker extends AbstractLifecycleTracker
427 {
428
429 }
430
431 public class JSR250ObjectLifecycleTracker implements MuleContextAware
432 {
433 private final List<String> tracker = new ArrayList<String>();
434
435 public List<String> getTracker() {
436 return tracker;
437 }
438
439 public void setMuleContext(MuleContext context)
440 {
441 tracker.add("setMuleContext");
442 }
443
444 @PostConstruct
445 public void init()
446 {
447 tracker.add("initialise");
448 }
449
450 @PreDestroy
451 public void dispose()
452 {
453 tracker.add("dispose");
454 }
455 }
456
457 }