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