1
2
3
4
5
6
7
8
9
10
11 package org.mule.routing.outbound;
12
13 import org.mule.DefaultMuleMessage;
14 import org.mule.api.MuleEvent;
15 import org.mule.api.MuleMessage;
16 import org.mule.api.MuleMessageCollection;
17 import org.mule.api.MuleSession;
18 import org.mule.api.endpoint.OutboundEndpoint;
19 import org.mule.module.xml.routing.XmlMessageSplitter;
20 import org.mule.tck.MuleTestUtils;
21 import org.mule.tck.junit4.AbstractMuleContextTestCase;
22 import org.mule.util.IOUtils;
23
24 import com.mockobjects.constraint.Constraint;
25 import com.mockobjects.dynamic.Mock;
26
27 import java.util.HashMap;
28 import java.util.Map;
29
30 import org.dom4j.Document;
31 import org.dom4j.DocumentHelper;
32 import org.junit.Test;
33
34 import static org.junit.Assert.assertEquals;
35 import static org.junit.Assert.assertNotNull;
36 import static org.junit.Assert.assertTrue;
37 import static org.junit.Assert.fail;
38
39 public class RoundRobinXmlSplitterTestCase extends AbstractMuleContextTestCase
40 {
41 private OutboundEndpoint endpoint1;
42 private OutboundEndpoint endpoint2;
43 private OutboundEndpoint endpoint3;
44 private OutboundEndpoint endpoint4;
45 private OutboundEndpoint endpoint5;
46 private OutboundEndpoint endpoint6;
47 private Mock mockendpoint1;
48 private Mock mockendpoint2;
49 private Mock mockendpoint3;
50 private Mock mockendpoint4;
51 private Mock mockendpoint5;
52 private Mock mockendpoint6;
53 private XmlMessageSplitter asyncXmlSplitter;
54 private XmlMessageSplitter syncXmlSplitter;
55
56 @Override
57 protected void doSetUp() throws Exception
58 {
59
60 endpoint1 = getTestOutboundEndpoint("Test1Endpoint", "test://endpointUri.1");
61 endpoint2 = getTestOutboundEndpoint("Test2Endpoint", "test://endpointUri.2");
62 endpoint3 = getTestOutboundEndpoint("Test3Endpoint", "test://endpointUri.3");
63 mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
64 mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
65 mockendpoint3 = RouterTestUtils.getMockEndpoint(endpoint3);
66
67
68 endpoint4 = getTestOutboundEndpoint("Test4Endpoint", "test://endpointUri.4?exchangePattern=request-response");
69 endpoint5 = getTestOutboundEndpoint("Test5Endpoint", "test://endpointUri.5?exchangePattern=request-response");
70 endpoint6 = getTestOutboundEndpoint("Test6Endpoint", "test://endpointUri.6?exchangePattern=request-response");
71 mockendpoint4 = RouterTestUtils.getMockEndpoint(endpoint4);
72 mockendpoint5 = RouterTestUtils.getMockEndpoint(endpoint5);
73 mockendpoint6 = RouterTestUtils.getMockEndpoint(endpoint6);
74
75
76 asyncXmlSplitter = new XmlMessageSplitter();
77 asyncXmlSplitter.setValidateSchema(true);
78 asyncXmlSplitter.setExternalSchemaLocation("purchase-order.xsd");
79 asyncXmlSplitter.setMuleContext(muleContext);
80
81
82
83
84 Map namespaces = new HashMap();
85 namespaces.put("e", "http://www.example.com");
86 asyncXmlSplitter.setSplitExpression("/e:purchaseOrder/e:items/e:item");
87 asyncXmlSplitter.setNamespaces(namespaces);
88 asyncXmlSplitter.addRoute((OutboundEndpoint) mockendpoint1.proxy());
89 asyncXmlSplitter.addRoute((OutboundEndpoint) mockendpoint2.proxy());
90 asyncXmlSplitter.addRoute((OutboundEndpoint) mockendpoint3.proxy());
91
92
93 syncXmlSplitter = new XmlMessageSplitter();
94 syncXmlSplitter.setMuleContext(muleContext);
95 syncXmlSplitter.setValidateSchema(true);
96 syncXmlSplitter.setExternalSchemaLocation("purchase-order.xsd");
97 syncXmlSplitter.setSplitExpression("/e:purchaseOrder/e:items/e:item");
98
99 syncXmlSplitter.setNamespaces(namespaces);
100 syncXmlSplitter.addRoute((OutboundEndpoint) mockendpoint4.proxy());
101 syncXmlSplitter.addRoute((OutboundEndpoint) mockendpoint5.proxy());
102 syncXmlSplitter.addRoute((OutboundEndpoint) mockendpoint6.proxy());
103 }
104
105 @Test
106 public void testStringPayloadXmlMessageSplitter() throws Exception
107 {
108 String payload = IOUtils.getResourceAsString("purchase-order2.xml", getClass());
109 internalTestSuccessfulXmlSplitter(payload);
110 }
111
112 @Test
113 public void testDom4JDocumentPayloadXmlMessageSplitter() throws Exception
114 {
115 String payload = IOUtils.getResourceAsString("purchase-order2.xml", getClass());
116 Document doc = DocumentHelper.parseText(payload);
117 internalTestSuccessfulXmlSplitter(doc);
118 }
119
120 @Test
121 public void testByteArrayPayloadXmlMessageSplitter() throws Exception
122 {
123 String payload = IOUtils.getResourceAsString("purchase-order2.xml", getClass());
124 internalTestSuccessfulXmlSplitter(payload.getBytes());
125 }
126
127 private void internalTestSuccessfulXmlSplitter(Object payload) throws Exception
128 {
129 Mock session = MuleTestUtils.getMockSession();
130 session.matchAndReturn("getFlowConstruct", getTestService());
131 session.matchAndReturn("setFlowConstruct", RouterTestUtils.getArgListCheckerFlowConstruct(), null);
132 MuleMessage message = new DefaultMuleMessage(payload, muleContext);
133
134 assertTrue(asyncXmlSplitter.isMatch(message));
135 final RoundRobinXmlSplitterTestCase.ItemNodeConstraint itemNodeConstraint = new RoundRobinXmlSplitterTestCase.ItemNodeConstraint();
136 mockendpoint1.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
137 mockendpoint2.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
138 mockendpoint3.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
139 mockendpoint1.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
140 asyncXmlSplitter.route(new OutboundRoutingTestEvent(message, (MuleSession) session.proxy(), muleContext));
141 mockendpoint1.verify();
142 mockendpoint2.verify();
143 mockendpoint3.verify();
144
145 message = new DefaultMuleMessage(payload, muleContext);
146 MuleEvent event = new OutboundRoutingTestEvent(message, null, muleContext);
147 assertTrue(syncXmlSplitter.isMatch(message));
148 mockendpoint4.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
149 mockendpoint5.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
150 mockendpoint6.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
151 mockendpoint4.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
152 MuleEvent result = syncXmlSplitter.route(new OutboundRoutingTestEvent(message, (MuleSession) session.proxy(), muleContext));
153 MuleMessage resultMessage = result.getMessage();
154 assertNotNull(resultMessage);
155 assertNotNull(result);
156 assertTrue(resultMessage instanceof MuleMessageCollection);
157 assertEquals(4, ((MuleMessageCollection) resultMessage).size());
158 mockendpoint4.verify();
159 mockendpoint5.verify();
160 mockendpoint6.verify();
161 }
162
163 @Test
164 public void testXsdNotFoundThrowsException() throws Exception
165 {
166 final String invalidSchemaLocation = "non-existent.xsd";
167 Mock session = MuleTestUtils.getMockSession();
168 session.matchAndReturn("getFlowConstruct", getTestService());
169
170 XmlMessageSplitter splitter = new XmlMessageSplitter();
171 splitter.setValidateSchema(true);
172 splitter.setExternalSchemaLocation(invalidSchemaLocation);
173 splitter.setMuleContext(muleContext);
174 String payload = IOUtils.getResourceAsString("purchase-order.xml", getClass());
175
176 MuleMessage message = new DefaultMuleMessage(payload, muleContext);
177
178 assertTrue(splitter.isMatch(message));
179 try
180 {
181 splitter.route(new OutboundRoutingTestEvent(message, (MuleSession) session.proxy(), muleContext));
182 fail("Should have thrown an exception, because XSD is not found.");
183 }
184 catch (IllegalArgumentException iaex)
185 {
186 assertTrue("Wrong exception?", iaex.getMessage().indexOf(
187 "Couldn't find schema at " + invalidSchemaLocation) != -1);
188 }
189 session.verify();
190 }
191
192
193 @Test
194 public void testInvalidXmlPayloadThrowsException() throws Exception
195 {
196 Mock session = MuleTestUtils.getMockSession();
197 session.matchAndReturn("getFlowConstruct", getTestService());
198
199 XmlMessageSplitter splitter = new XmlMessageSplitter();
200 splitter.setMuleContext(muleContext);
201 MuleMessage message = new DefaultMuleMessage("This is not XML.", muleContext);
202
203 try
204 {
205 splitter.route(new OutboundRoutingTestEvent(message, (MuleSession) session.proxy(), muleContext));
206 fail("No exception thrown.");
207 }
208 catch (IllegalArgumentException iaex)
209 {
210 assertTrue("Wrong exception message.", iaex.getMessage().startsWith(
211 "Failed to initialise the payload: "));
212 }
213
214 }
215
216 private class ItemNodeConstraint implements Constraint
217 {
218 public boolean eval(Object o)
219 {
220 final MuleMessage message = (MuleMessage) o;
221 final Object payload = message.getPayload();
222 assertTrue("Wrong class type for node.", payload instanceof Document);
223
224 Document node = (Document) payload;
225
226 final String partNumber = node.getRootElement().attributeValue("partNum");
227
228 return "872-AA".equals(partNumber) || "926-AA".equals(partNumber) || "126-AA".equals(partNumber)
229 || "226-AA".equals(partNumber);
230 }
231 }
232 }