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