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