View Javadoc

1   /*
2    * $Id: TransformerChainingTestCase.java 19250 2010-08-30 16:53:14Z 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.transformer;
12  
13  import org.mule.DefaultMuleMessage;
14  import org.mule.api.MuleEvent;
15  import org.mule.api.MuleException;
16  import org.mule.api.transformer.DataType;
17  import org.mule.api.transformer.Transformer;
18  import org.mule.api.transformer.TransformerException;
19  import org.mule.tck.AbstractMuleTestCase;
20  import org.mule.transformer.types.DataTypeFactory;
21  
22  import java.util.Collections;
23  
24  public class TransformerChainingTestCase extends AbstractMuleTestCase
25  {
26      public void testSingleChainedTransformer() throws Exception
27      {
28          AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
29          assertNotNull(validTransformer);
30          
31          DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
32          Transformer messageTransformer = new TransformerChain(validTransformer);
33          message.applyTransformers((MuleEvent)null, messageTransformer);
34  
35          Object transformedMessage = message.getPayload();
36          assertNotNull(transformedMessage);
37          assertEquals(new Integer(1), transformedMessage);
38      }
39  
40      public void testTwoChainedTransformers() throws Exception
41      {
42          AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
43          assertNotNull(validTransformer);
44          
45          DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
46          Transformer messageTransformer = new TransformerChain(validTransformer, validTransformer);
47          message.applyTransformers(null, Collections.singletonList(messageTransformer));
48  
49          Object transformedMessage = message.getPayload();
50          assertNotNull(transformedMessage);
51          assertEquals(new Integer(2), transformedMessage);
52      }
53  
54      public void testThreeChainedTransformers() throws Exception
55      {
56          AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
57          assertNotNull(validTransformer);
58          
59          DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
60          Transformer messageTransformer = new TransformerChain(validTransformer, validTransformer, validTransformer);
61          message.applyTransformers((MuleEvent)null, messageTransformer);
62  
63          Object transformedMessage = message.getPayload();
64          assertNotNull(transformedMessage);
65          assertEquals(new Integer(3), transformedMessage);
66      }
67  
68      public void testIgnoreBadInputDoesNotBreakChainWithTransformationOrderInvalidValid() throws Exception
69      {
70          AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer();
71          assertNotNull(invalidTransformer);
72          invalidTransformer.setIgnoreBadInput(true);
73          
74          AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
75          assertNotNull(validTransformer);
76          
77          DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
78          Transformer messageTransformer = new TransformerChain(invalidTransformer, validTransformer);
79          message.applyTransformers((MuleEvent)null, messageTransformer);
80  
81          Object transformedMessage = message.getPayload();
82          assertNotNull(transformedMessage);
83          assertEquals(new Integer(1), transformedMessage);
84      }
85  
86      public void testIgnoreBadInputBreaksChainWithTransformationOrderInvalidValid() throws Exception
87      {
88          AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer();
89          assertNotNull(invalidTransformer);
90          invalidTransformer.setIgnoreBadInput(false);
91          
92          AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
93          assertNotNull(validTransformer);
94          
95          DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
96          Transformer messageTransformer = new TransformerChain(invalidTransformer, validTransformer);
97          
98          try
99          {
100             message.applyTransformers((MuleEvent)null, messageTransformer);
101             fail("Transformer chain is expected to fail because of invalid transformer within chain.");
102         }
103         catch (MuleException tfe)
104         {
105             // ignore
106         }
107     }
108 
109     public void testIgnoreBadInputDoesNotBreakChainWithTransformationOrderValidInvalid() throws Exception
110     {
111         AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer();
112         assertNotNull(invalidTransformer);
113         invalidTransformer.setIgnoreBadInput(true);
114         
115         AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
116         assertNotNull(validTransformer);
117         
118         DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
119         Transformer messageTransformer = new TransformerChain(validTransformer, invalidTransformer);
120         message.applyTransformers((MuleEvent)null, messageTransformer);
121 
122         Object transformedMessage = message.getPayload();
123         assertNotNull(transformedMessage);
124         assertEquals(new Integer(1), transformedMessage);
125     }
126 
127     public void testIgnoreBadInputBreaksChainWithTransformationOrderValidInvalid() throws Exception
128     {
129         AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer();
130         assertNotNull(invalidTransformer);
131         invalidTransformer.setIgnoreBadInput(false);
132         
133         AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
134         assertNotNull(validTransformer);
135         
136         DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
137         Transformer messageTransformer = new TransformerChain(validTransformer, invalidTransformer);
138         
139         try
140         {
141             message.applyTransformers((MuleEvent)null, messageTransformer);
142             fail("Transformer chain is expected to fail because of invalid transformer within chain.");
143         }
144         catch (MuleException tfe)
145         {
146             assertNotNull(tfe);
147         }
148     }
149 
150     private Transformer getInvalidTransformer() throws Exception
151     {
152         AbstractTransformer transformer = new AbstractTransformer()
153         {
154             @Override
155             protected Object doTransform(final Object src, final String encoding) throws TransformerException
156             {
157                 throw new RuntimeException("This transformer must not perform any transformations.");
158             }
159         };
160 
161         // Use this class as a bogus source type to enforce a simple invalid transformer
162         transformer.registerSourceType(DataTypeFactory.create(this.getClass()));
163         
164         return transformer;
165     }
166     
167     private Transformer getIncreaseByOneTransformer() throws Exception
168     {
169         AbstractTransformer transformer = new AbstractTransformer()
170         {
171             @Override
172             protected Object doTransform(Object src, String encoding) throws TransformerException
173             {
174                 return new Integer(((Integer) src).intValue() + 1);
175             }
176         };
177         
178         DataType<Integer> integerDataType = DataTypeFactory.create(Integer.class);
179         transformer.registerSourceType(integerDataType);
180         transformer.setReturnDataType(integerDataType);
181         
182         return transformer;
183     }
184     
185 }