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