View Javadoc

1   /*
2    * $Id: TransientRegistryLifecycleTestCase.java 22377 2011-07-11 12:41:42Z dirk.olmes $
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  
20  import java.util.ArrayList;
21  import java.util.List;
22  
23  import javax.annotation.PostConstruct;
24  import javax.annotation.PreDestroy;
25  
26  import org.junit.Test;
27  
28  import static org.junit.Assert.assertEquals;
29  import static org.junit.Assert.fail;
30  
31  public class TransientRegistryLifecycleTestCase extends TransientRegistryTestCase
32  {
33      @Test
34      public void testObjectLifecycleWithTransientRegistryDirectly() throws Exception
35      {
36          TransientRegistry reg = new TransientRegistry(muleContext);
37          reg.initialise();
38          reg.fireLifecycle(Startable.PHASE_NAME);
39  
40          InterfaceBasedTracker tracker = new InterfaceBasedTracker();
41          reg.registerObject("test", tracker);
42  
43          reg.dispose();
44          assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
45      }
46  
47      @Test
48      public void testObjectBypassLifecycleWithTransientRegistryDirectly() throws Exception
49      {
50          TransientRegistry reg = new TransientRegistry(muleContext);
51          reg.initialise();
52          reg.fireLifecycle(Startable.PHASE_NAME);
53  
54          InterfaceBasedTracker tracker = new InterfaceBasedTracker();
55          reg.registerObject("test", tracker, MuleRegistry.LIFECYCLE_BYPASS_FLAG);
56          reg.dispose();
57          assertEquals("[setMuleContext, stop, dispose]", tracker.getTracker().toString());
58      }
59  
60      @Test
61      public void testObjectBypassInjectorsWithTransientRegistryDirectly() throws Exception
62      {
63          TransientRegistry reg = new TransientRegistry(muleContext);
64          reg.initialise();
65          reg.fireLifecycle(Startable.PHASE_NAME);
66  
67          InterfaceBasedTracker tracker = new InterfaceBasedTracker();
68          reg.registerObject("test", tracker, MuleRegistry.INJECT_PROCESSORS_BYPASS_FLAG);
69          reg.dispose();
70          assertEquals("[initialise, start, stop, dispose]", tracker.getTracker().toString());
71      }
72  
73      @Test
74      public void testObjectBypassLifecycleAndInjectorsWithTransientRegistryDirectly() throws Exception
75      {
76          TransientRegistry reg = new TransientRegistry(muleContext);
77          reg.initialise();
78          reg.fireLifecycle(Startable.PHASE_NAME);
79  
80          InterfaceBasedTracker tracker = new InterfaceBasedTracker();
81          reg.registerObject("test", tracker, MuleRegistry.LIFECYCLE_BYPASS_FLAG + MuleRegistry.INJECT_PROCESSORS_BYPASS_FLAG);
82          reg.dispose();
83          assertEquals("[stop, dispose]", tracker.getTracker().toString());
84      }
85  
86      @Test
87      public void testObjectLifecycleStatesWithTransientRegistryDirectly() throws Exception
88      {
89          TransientRegistry reg = new TransientRegistry(muleContext);
90          InterfaceBasedTracker tracker = new InterfaceBasedTracker();
91          reg.registerObject("test", tracker);
92          assertEquals("[setMuleContext]", tracker.getTracker().toString());
93          reg.initialise();
94          assertEquals("[setMuleContext, initialise]", tracker.getTracker().toString());
95  
96  
97          reg.fireLifecycle(Startable.PHASE_NAME);
98          assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
99  
100         try
101         {
102             reg.fireLifecycle(Startable.PHASE_NAME);
103             fail("Registry is already started");
104         }
105         catch (Exception e)
106         {
107             //expected
108         }
109 
110         reg.fireLifecycle(Stoppable.PHASE_NAME);
111         assertEquals("[setMuleContext, initialise, start, stop]", tracker.getTracker().toString());
112 
113         try
114         {
115             reg.fireLifecycle(Stoppable.PHASE_NAME);
116             fail("Registry is already stopped");
117         }
118         catch (Exception e)
119         {
120             //expected
121         }
122 
123         reg.dispose();
124         assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
125 
126         try
127         {
128             reg.dispose();
129             fail("Registry is already disposed");
130         }
131         catch (Exception e)
132         {
133             //expected
134         }
135     }
136 
137     @Test
138     public void testLifecycleState() throws Exception
139     {
140         TransientRegistry reg = new TransientRegistry(muleContext);
141         reg.fireLifecycle(Initialisable.PHASE_NAME);
142         reg.fireLifecycle(Startable.PHASE_NAME);
143 
144         InterfaceBasedTracker tracker = new InterfaceBasedTracker();
145         reg.registerObject("test", tracker);
146         assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
147 
148         reg.fireLifecycle(Disposable.PHASE_NAME);
149         assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
150     }
151 
152     @Test
153     public void testLifecycleStateOutOfSequenceStartFirstWithTransientRegistryDirectly() throws Exception
154     {
155         TransientRegistry reg = new TransientRegistry(muleContext);
156         try
157         {
158             //fire start directly
159             reg.fireLifecycle(Startable.PHASE_NAME);
160             fail("Cannot start without initialising first");
161         }
162         catch (IllegalStateException e)
163         {
164             //expected
165         }
166 
167         InterfaceBasedTracker tracker = new InterfaceBasedTracker();
168         reg.registerObject("test", tracker);
169 
170         reg.fireLifecycle(Initialisable.PHASE_NAME);
171         reg.fireLifecycle(Startable.PHASE_NAME);
172 
173         //Initialise called implicitly because you cannot start a component without initialising it first
174         assertEquals("[setMuleContext, initialise, start]", tracker.getTracker().toString());
175 
176         reg.fireLifecycle(Disposable.PHASE_NAME);
177         //Stop called implicitly because you cannot dispose component without stopping it first
178         assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
179     }
180 
181     @Test
182     public void testLifecycleStateOutOfSequenceStopFirstWithTransientRegistryDirectly() throws Exception
183     {
184         TransientRegistry reg = new TransientRegistry(muleContext);
185         try
186         {
187             //fire stop directly
188             reg.fireLifecycle(Stoppable.PHASE_NAME);
189             fail("Cannot stop without starting first");
190         }
191         catch (IllegalStateException e)
192         {
193             //expected
194         }
195 
196         InterfaceBasedTracker tracker = new InterfaceBasedTracker();
197         reg.registerObject("test", tracker);
198 
199         reg.fireLifecycle(Initialisable.PHASE_NAME);
200         reg.fireLifecycle(Startable.PHASE_NAME);
201         reg.fireLifecycle(Stoppable.PHASE_NAME);
202 
203         //Start is bypassed because the component was added when the registry was stopped, hence no need to start the component
204         //Stop isn't called either because start was not called
205         //Initialised is called because in order for a component to be stopped it needs to be initialised
206         assertEquals("[setMuleContext, initialise, start, stop]", tracker.getTracker().toString());
207 
208         reg.fireLifecycle(Disposable.PHASE_NAME);
209         assertEquals("[setMuleContext, initialise, start, stop, dispose]", tracker.getTracker().toString());
210     }
211 
212     public class InterfaceBasedTracker extends AbstractLifecycleTracker
213     {
214         // no custom methods
215     }
216 
217     public class JSR250ObjectLifecycleTracker implements MuleContextAware
218     {
219         private final List<String> tracker = new ArrayList<String>();
220 
221         public List<String> getTracker() {
222             return tracker;
223         }
224 
225         public void setMuleContext(MuleContext context)
226         {
227             tracker.add("setMuleContext");
228         }
229 
230         @PostConstruct
231         public void init()
232         {
233             tracker.add("initialise");
234         }
235 
236         @PreDestroy
237         public void dispose()
238         {
239             tracker.add("dispose");
240         }
241     }
242 }