View Javadoc

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