View Javadoc

1   /*
2    * $Id: DefaultLocalMuleClientTestCase.java 22542 2011-07-22 20:50:01Z 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  
11  package org.mule.client;
12  
13  import static org.junit.Assert.assertEquals;
14  import static org.junit.Assert.assertSame;
15  import static org.mockito.Matchers.any;
16  import static org.mockito.Mockito.mock;
17  import static org.mockito.Mockito.stub;
18  import static org.mockito.Mockito.verify;
19  
20  import org.mule.DefaultMuleMessage;
21  import org.mule.MessageExchangePattern;
22  import org.mule.api.MuleContext;
23  import org.mule.api.MuleEvent;
24  import org.mule.api.MuleException;
25  import org.mule.api.MuleMessage;
26  import org.mule.api.endpoint.InboundEndpoint;
27  import org.mule.api.endpoint.OutboundEndpoint;
28  import org.mule.tck.junit4.AbstractMuleContextTestCase;
29  
30  import java.util.HashMap;
31  import java.util.Map;
32  
33  import org.junit.Test;
34  import org.mockito.ArgumentCaptor;
35  import org.mockito.Matchers;
36  
37  public class DefaultLocalMuleClientTestCase extends AbstractMuleContextTestCase
38  {
39      protected final String PROP_KEY_1 = "key1";
40      protected final String TEST_URI = "test://test";
41      protected final long TEST_RESPONSE_TIMEOUT = 567;
42      protected final long TEST_FREQ = 123;
43      protected final MessageExchangePattern TEST_MEP = MessageExchangePattern.ONE_WAY;
44      protected TestableLocalMuleClient client;
45      protected InboundEndpoint inboundEndpoint;
46      protected OutboundEndpoint outboundEndpoint;
47      protected Object messagePaylaod = TEST_MESSAGE;
48      protected Map<String, Object> messageProperties = new HashMap<String, Object>();
49      protected MuleMessage message;
50      protected MuleEvent responseEvent;
51  
52      @Override
53      protected void doSetUp() throws Exception
54      {
55          super.doSetUp();
56          client = new TestableLocalMuleClient(muleContext);
57          messageProperties.put(PROP_KEY_1, "val1");
58          message = new DefaultMuleMessage(messagePaylaod, messageProperties, muleContext);
59          outboundEndpoint = mock(OutboundEndpoint.class);
60          inboundEndpoint = mock(InboundEndpoint.class);
61          responseEvent = getTestEvent("RESPONSE");
62      }
63  
64      @Test
65      public void testProcessOutboundEndpointObjectMapOfStringObject() throws MuleException
66      {
67          stub(outboundEndpoint.process(any(MuleEvent.class))).toReturn(responseEvent);
68          ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
69  
70          MuleMessage response = client.process(outboundEndpoint, messagePaylaod, messageProperties);
71  
72          verify(outboundEndpoint).process(argument.capture());
73  
74          assertSame(message.getPayload(), argument.getValue().getMessage().getPayload());
75          assertSame(message.getOutboundProperty(PROP_KEY_1), argument.getValue()
76                  .getMessage().getOutboundProperty(PROP_KEY_1));
77          assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
78          assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
79  
80          assertSame(responseEvent.getMessage(), response);
81      }
82  
83      @Test
84      public void testProcessOutboundEndpointMuleMessage() throws MuleException
85      {
86          stub(outboundEndpoint.process(any(MuleEvent.class))).toReturn(responseEvent);
87          ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
88  
89          MuleMessage response = client.process(outboundEndpoint, message);
90  
91          verify(outboundEndpoint).process(argument.capture());
92  
93          assertSame(message, argument.getValue().getMessage());
94          assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
95          assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
96          assertSame(responseEvent.getMessage(), response);
97      }
98  
99      @Test
100     public void testRequestInboundEndpointLong() throws Exception
101     {
102         stub(inboundEndpoint.request(Matchers.anyLong())).toReturn(responseEvent.getMessage());
103         MuleMessage result = client.request(inboundEndpoint, TEST_RESPONSE_TIMEOUT);
104         assertSame(responseEvent.getMessage(), result);
105     }
106 
107     @Test
108     public void testDispatchStringObjectMapOfStringObject() throws MuleException
109     {
110         ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
111 
112         client.dispatch(TEST_URI, messagePaylaod, messageProperties);
113 
114         verify(outboundEndpoint).process(argument.capture());
115 
116         assertSame(message.getPayload(), argument.getValue().getMessage().getPayload());
117         assertSame(message.getOutboundProperty(PROP_KEY_1), argument.getValue()
118                 .getMessage().getOutboundProperty(PROP_KEY_1));
119         assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
120         assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
121     }
122 
123     @Test
124     public void testSendStringObjectMapOfStringObject() throws MuleException
125     {
126         stub(outboundEndpoint.process(any(MuleEvent.class))).toReturn(responseEvent);
127         ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
128 
129         MuleMessage response = client.send(TEST_URI, messagePaylaod, messageProperties);
130 
131         verify(outboundEndpoint).process(argument.capture());
132 
133         assertSame(message.getPayload(), argument.getValue().getMessage().getPayload());
134         assertSame(message.getOutboundProperty(PROP_KEY_1), argument.getValue()
135                 .getMessage().getOutboundProperty(PROP_KEY_1));
136         assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
137         assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
138 
139         assertSame(responseEvent.getMessage(), response);
140     }
141 
142     @Test
143     public void testSendStringMuleMessage() throws MuleException
144     {
145         stub(outboundEndpoint.process(any(MuleEvent.class))).toReturn(responseEvent);
146         ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
147 
148         MuleMessage response = client.send(TEST_URI, message);
149 
150         verify(outboundEndpoint).process(argument.capture());
151 
152         assertSame(message, argument.getValue().getMessage());
153         assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
154         assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
155 
156         assertSame(responseEvent.getMessage(), response);
157     }
158 
159     @Test
160     public void testSendStringObjectMapOfStringObjectInt() throws MuleException
161     {
162         stub(outboundEndpoint.process(any(MuleEvent.class))).toReturn(responseEvent);
163         ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
164 
165         MuleMessage response = client.send(TEST_URI, messagePaylaod, messageProperties, TEST_RESPONSE_TIMEOUT);
166 
167         verify(outboundEndpoint).process(argument.capture());
168 
169         assertSame(message.getPayload(), argument.getValue().getMessage().getPayload());
170         assertSame(message.getOutboundProperty(PROP_KEY_1), argument.getValue()
171                 .getMessage().getOutboundProperty(PROP_KEY_1));
172         assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
173         assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
174 
175         assertSame(responseEvent.getMessage(), response);
176     }
177 
178     @Test
179     public void testSendStringMuleMessageInt() throws MuleException
180     {
181         stub(outboundEndpoint.process(any(MuleEvent.class))).toReturn(responseEvent);
182         ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
183 
184         MuleMessage response = client.send(TEST_URI, message, TEST_RESPONSE_TIMEOUT);
185 
186         verify(outboundEndpoint).process(argument.capture());
187 
188         assertSame(message, argument.getValue().getMessage());
189         assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
190         assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
191 
192         assertSame(responseEvent.getMessage(), response);
193     }
194 
195     @Test
196     public void testDispatchStringMuleMessage() throws MuleException
197     {
198         ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
199 
200         client.dispatch(TEST_URI, message);
201 
202         verify(outboundEndpoint).process(argument.capture());
203 
204         assertSame(message, argument.getValue().getMessage());
205         assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
206         assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
207     }
208 
209     @Test
210     public void testRequestStringLong() throws Exception
211     {
212         stub(inboundEndpoint.request(Matchers.anyLong())).toReturn(responseEvent.getMessage());
213         MuleMessage result = client.request(TEST_URI, TEST_RESPONSE_TIMEOUT);
214         assertSame(responseEvent.getMessage(), result);
215     }
216 
217     @Test
218     public void testProcessStringMessageExchangePatternObjectMapOfStringObject() throws MuleException
219     {
220         stub(outboundEndpoint.process(any(MuleEvent.class))).toReturn(responseEvent);
221         ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
222 
223         MuleMessage response = client.send(TEST_URI, messagePaylaod, messageProperties, TEST_RESPONSE_TIMEOUT);
224 
225         verify(outboundEndpoint).process(argument.capture());
226 
227         assertSame(message.getPayload(), argument.getValue().getMessage().getPayload());
228         assertSame(message.getOutboundProperty(PROP_KEY_1), argument.getValue()
229                 .getMessage().getOutboundProperty(PROP_KEY_1));
230         assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
231         assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
232 
233         assertSame(responseEvent.getMessage(), response);
234     }
235 
236     @Test
237     public void testProcessStringMessageExchangePatternMuleMessage() throws MuleException
238     {
239         stub(outboundEndpoint.process(any(MuleEvent.class))).toReturn(responseEvent);
240         ArgumentCaptor<MuleEvent> argument = ArgumentCaptor.forClass(MuleEvent.class);
241 
242         MuleMessage response = client.send(TEST_URI, message, TEST_RESPONSE_TIMEOUT);
243 
244         verify(outboundEndpoint).process(argument.capture());
245 
246         assertSame(message, argument.getValue().getMessage());
247         assertSame(outboundEndpoint.getExchangePattern(), argument.getValue().getExchangePattern());
248         assertSame(outboundEndpoint.getEndpointURI().getUri(), argument.getValue().getMessageSourceURI());
249 
250         assertSame(responseEvent.getMessage(), response);
251     }
252 
253     @Test
254     public void testInboundEndpointCreation() throws MuleException
255     {
256         InboundEndpoint endpoint = client.createInboundEndpoint(TEST_URI, TEST_MEP);
257         assertEquals(TEST_URI, endpoint.getEndpointURI().getUri().toString());
258         assertEquals(TEST_MEP, endpoint.getExchangePattern());
259     }
260 
261     @Test
262     public void testOutboundEndpointCreation() throws MuleException
263     {
264         OutboundEndpoint endpoint = client.createOutboundEndpoint(TEST_URI, TEST_MEP, new Long(
265             TEST_RESPONSE_TIMEOUT));
266         assertEquals(TEST_URI, endpoint.getEndpointURI().getUri().toString());
267         assertEquals(TEST_MEP, endpoint.getExchangePattern());
268         assertEquals(TEST_RESPONSE_TIMEOUT, endpoint.getResponseTimeout());
269     }
270 
271     class TestableLocalMuleClient extends DefaultLocalMuleClient
272     {
273 
274         public TestableLocalMuleClient(MuleContext muleContext)
275         {
276             super(muleContext);
277         }
278 
279         InboundEndpoint createInboundEndpoint(String uri, MessageExchangePattern mep) throws MuleException
280         {
281             return getInboundEndpoint(uri, mep);
282         }
283 
284         OutboundEndpoint createOutboundEndpoint(String uri, MessageExchangePattern mep, Long responseTimeout)
285             throws MuleException
286         {
287             return getOutboundEndpoint(uri, mep, responseTimeout);
288         }
289 
290         protected InboundEndpoint getInboundEndpoint(String uri, MessageExchangePattern mep)
291             throws MuleException
292         {
293             return inboundEndpoint;
294         }
295 
296         protected OutboundEndpoint getOutboundEndpoint(String uri,
297                                                        MessageExchangePattern mep,
298                                                        Long responseTimeout) throws MuleException
299         {
300             return outboundEndpoint;
301         }
302     }
303 }