View Javadoc

1   /*
2    * $Id: TransientRegistryTestCase.java 20321 2010-11-24 15:21:24Z dfeist $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
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             //expected
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             //expected
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             //expected
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             //expected
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             //expected
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             //expected
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             //expected
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             //fire start directly
298             reg.fireLifecycle(Startable.PHASE_NAME);
299             fail("Cannot start without initialising first");
300         }
301         catch (IllegalStateException e)
302         {
303             //expected
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         //Initialise called implicitly because you cannot start a component without initialising it first
313         assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
314 
315         reg.fireLifecycle(Disposable.PHASE_NAME);
316         //Stop called implicitly because you cannot dispose component without stopping it first
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             //fire stop directly
326             reg.fireLifecycle(Stoppable.PHASE_NAME);
327             fail("Cannot stop without starting first");
328         }
329         catch (IllegalStateException e)
330         {
331             //expected
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         //Start is bypassed because the component was added when the registry was stopped, hence no need to start the component
342         //Stop isn't called either because start was not called
343         //Initialised is called because in order for a component to be stopped it needs to be initialised
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             //Expected
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         //Initialise called implicitly because you cannot start a component without initialising it first
376         assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
377 
378         muleContext.dispose();
379         //Stop called implicitly because you cannot dispose component without stopping it first
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             //expected
393         }
394 
395         muleContext.start();
396         muleContext.stop();
397         InterfaceBasedTracker tracker = new InterfaceBasedTracker();
398         muleContext.getRegistry().registerObject("test", tracker);
399         //Start is bypassed because the component was added when the registry was stopped, hence no need to start the component
400         //Stop isn't called either because start was not called
401         //Initialised is called because that pahse has completed in the registry
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             //Expected
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 }