1   /*
2    * $Id: CatchAllStrategiesTestCase.java 7976 2007-08-21 14:26:13Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.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;
12  
13  import org.mule.impl.MuleEvent;
14  import org.mule.impl.MuleMessage;
15  import org.mule.impl.endpoint.MuleEndpointURI;
16  import org.mule.routing.filters.PayloadTypeFilter;
17  import org.mule.routing.outbound.FilteringOutboundRouter;
18  import org.mule.routing.outbound.OutboundRouterCollection;
19  import org.mule.tck.AbstractMuleTestCase;
20  import org.mule.tck.MuleTestUtils;
21  import org.mule.transformers.AbstractTransformer;
22  import org.mule.umo.UMOEvent;
23  import org.mule.umo.UMOMessage;
24  import org.mule.umo.UMOSession;
25  import org.mule.umo.endpoint.UMOEndpoint;
26  import org.mule.umo.provider.UMOMessageDispatcher;
27  import org.mule.umo.transformer.TransformerException;
28  
29  import com.mockobjects.constraint.Constraint;
30  import com.mockobjects.dynamic.C;
31  import com.mockobjects.dynamic.Mock;
32  
33  import java.util.HashMap;
34  
35  public class CatchAllStrategiesTestCase extends AbstractMuleTestCase
36  {
37  
38      public void testLoggingOnlyStrategy() throws Exception
39      {
40          UMOEvent event = getTestEvent("UncaughtEvent");
41          LoggingCatchAllStrategy strategy = new LoggingCatchAllStrategy();
42          try
43          {
44              strategy.setEndpoint(getTestEndpoint("testProvider", UMOEndpoint.ENDPOINT_TYPE_SENDER));
45              fail("Illegal operation exception should have been thrown");
46          }
47          catch (Exception e)
48          {
49              // expected
50          }
51  
52          assertNull(strategy.getEndpoint());
53          strategy.catchMessage(event.getMessage(), null, false);
54      }
55  
56      public void testForwardingStrategy() throws Exception
57      {
58          ForwardingCatchAllStrategy strategy = new ForwardingCatchAllStrategy();
59          Mock endpoint = MuleTestUtils.getMockEndpoint();
60          Mock dispatcher = new Mock(UMOMessageDispatcher.class);
61          Mock connector = MuleTestUtils.getMockConnector();
62          UMOEvent event = getTestEvent("UncaughtEvent");
63          strategy.setEndpoint((UMOEndpoint)endpoint.proxy());
64  
65          endpoint.expectAndReturn("getProperties", new HashMap());
66          endpoint.expectAndReturn("getProperties", new HashMap());
67          endpoint.expectAndReturn("getEndpointURI", new MuleEndpointURI("test://dummy"));
68          endpoint.expectAndReturn("getEndpointURI", new MuleEndpointURI("test://dummy"));
69          endpoint.expect("dispatch", C.isA(MuleEvent.class));
70  
71          strategy.catchMessage(event.getMessage(), null, false);
72  
73          endpoint.verify();
74          dispatcher.verify();
75          connector.verify();
76  
77          assertNotNull(strategy.getEndpoint());
78      }
79  
80      private class TestEventTransformer extends AbstractTransformer
81      {
82          /*
83           * (non-Javadoc)
84           * 
85           * @see org.mule.transformers.AbstractTransformer#doTransform(java.lang.Object)
86           */
87          public Object doTransform(Object src, String encoding) throws TransformerException
88          {
89              return "Transformed Test Data";
90          }
91      }
92  
93      public void testForwardingStrategyWithTransform() throws Exception
94      {
95          ForwardingCatchAllStrategy strategy = new ForwardingCatchAllStrategy();
96          strategy.setSendTransformed(true);
97          Mock endpoint = MuleTestUtils.getMockEndpoint();
98          Mock dispatcher = new Mock(UMOMessageDispatcher.class);
99          Mock connector = MuleTestUtils.getMockConnector();
100         UMOEvent event = getTestEvent("UncaughtEvent");
101         strategy.setEndpoint((UMOEndpoint)endpoint.proxy());
102 
103         endpoint.expectAndReturn("getTransformer", new TestEventTransformer());
104         endpoint.expectAndReturn("getTransformer", new TestEventTransformer());
105         endpoint.expectAndReturn("getProperties", new HashMap());
106         endpoint.expectAndReturn("getProperties", new HashMap());
107 
108         endpoint.expectAndReturn("getEndpointURI", new MuleEndpointURI("test://dummy"));
109         endpoint.expectAndReturn("getEndpointURI", new MuleEndpointURI("test://dummy"));
110         endpoint.expect("send", new Constraint()
111         {
112             public boolean eval(Object arg0)
113             {
114                 if (arg0 instanceof UMOEvent)
115                 {
116                     return "Transformed Test Data".equals(((UMOEvent)arg0).getMessage().getPayload());
117                 }
118                 return false;
119             }
120         });
121 
122         strategy.catchMessage(event.getMessage(), null, true);
123 
124         endpoint.verify();
125         dispatcher.verify();
126         connector.verify();
127 
128         assertNotNull(strategy.getEndpoint());
129     }
130 
131     public void testFullRouter() throws Exception
132     {
133         final int[] count1 = new int[]{0};
134         final int[] count2 = new int[]{0};
135         final int[] catchAllCount = new int[]{0};
136 
137         OutboundRouterCollection messageRouter = new OutboundRouterCollection();
138 
139         FilteringOutboundRouter filterRouter1 = new FilteringOutboundRouter()
140         {
141             public UMOMessage route(UMOMessage message, UMOSession session, boolean synchronous)
142             {
143                 count1[0]++;
144                 return message;
145             }
146         };
147 
148         FilteringOutboundRouter filterRouter2 = new FilteringOutboundRouter()
149         {
150             public UMOMessage route(UMOMessage message, UMOSession session, boolean synchronous)
151             {
152                 count2[0]++;
153                 return message;
154             }
155         };
156 
157         filterRouter1.setFilter(new PayloadTypeFilter(Exception.class));
158         filterRouter2.setFilter(new PayloadTypeFilter(StringBuffer.class));
159         messageRouter.addRouter(filterRouter1);
160         messageRouter.addRouter(filterRouter2);
161 
162         LoggingCatchAllStrategy strategy = new LoggingCatchAllStrategy()
163         {
164             public UMOMessage catchMessage(UMOMessage message, UMOSession session, boolean synchronous)
165             {
166                 catchAllCount[0]++;
167                 return null;
168             }
169         };
170         messageRouter.setCatchAllStrategy(strategy);
171 
172         UMOSession session = getTestSession(getTestComponent(getTestDescriptor("test", "test")));
173 
174         messageRouter.route(new MuleMessage("hello"), session, true);
175         assertEquals(1, catchAllCount[0]);
176         assertEquals(0, count1[0]);
177         assertEquals(0, count2[0]);
178 
179         messageRouter.route(new MuleMessage(new StringBuffer()), session, true);
180         assertEquals(1, catchAllCount[0]);
181         assertEquals(0, count1[0]);
182         assertEquals(1, count2[0]);
183 
184         messageRouter.route(new MuleMessage(new Exception()), session, true);
185         assertEquals(1, catchAllCount[0]);
186         assertEquals(1, count1[0]);
187         assertEquals(1, count2[0]);
188     }
189 
190 }