1
2
3
4
5
6
7
8
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 }