View Javadoc

1   /*
2    * $Id: RoundRobinXmlSplitterTestCase.java 22387 2011-07-12 03:53:36Z dirk.olmes $
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.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          // setup async targets
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          // setup sync targets
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          // setup async splitter
76          asyncXmlSplitter = new XmlMessageSplitter();
77          asyncXmlSplitter.setValidateSchema(true);
78          asyncXmlSplitter.setExternalSchemaLocation("purchase-order.xsd");
79          asyncXmlSplitter.setMuleContext(muleContext);
80  
81          // The xml document declares a default namespace, thus
82          // we need to workaround it by specifying it both in
83          // the namespaces and in the splitExpression
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          // setup sync splitter
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 }