View Javadoc
1   /*
2    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
3    * The software in this package is published under the terms of the CPAL v1.0
4    * license, a copy of which has been included with this distribution in the
5    * LICENSE.txt file.
6    */
7   package org.mule.transformer;
8   
9   import org.mule.DefaultMuleMessage;
10  import org.mule.api.MuleContext;
11  import org.mule.api.MuleEvent;
12  import org.mule.api.MuleException;
13  import org.mule.api.transformer.DataType;
14  import org.mule.api.transformer.Transformer;
15  import org.mule.api.transformer.TransformerException;
16  import org.mule.tck.junit4.AbstractMuleTestCase;
17  import org.mule.transformer.types.DataTypeFactory;
18  
19  import java.util.Collections;
20  
21  import org.junit.Test;
22  
23  import static org.junit.Assert.assertEquals;
24  import static org.junit.Assert.assertNotNull;
25  import static org.junit.Assert.fail;
26  import static org.mockito.Mockito.mock;
27  
28  public class TransformerChainingTestCase extends AbstractMuleTestCase
29  {
30  
31      private MuleContext muleContext = mock(MuleContext.class);
32  
33      @Test
34      public void testSingleChainedTransformer() throws Exception
35      {
36          AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
37          assertNotNull(validTransformer);
38          
39          DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
40          Transformer messageTransformer = new TransformerChain(validTransformer);
41          message.applyTransformers((MuleEvent)null, messageTransformer);
42  
43          Object transformedMessage = message.getPayload();
44          assertNotNull(transformedMessage);
45          assertEquals(new Integer(1), transformedMessage);
46      }
47  
48      @Test
49      public void testTwoChainedTransformers() throws Exception
50      {
51          AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
52          assertNotNull(validTransformer);
53          
54          DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
55          Transformer messageTransformer = new TransformerChain(validTransformer, validTransformer);
56          message.applyTransformers(null, Collections.singletonList(messageTransformer));
57  
58          Object transformedMessage = message.getPayload();
59          assertNotNull(transformedMessage);
60          assertEquals(new Integer(2), transformedMessage);
61      }
62  
63      @Test
64      public void testThreeChainedTransformers() throws Exception
65      {
66          AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
67          assertNotNull(validTransformer);
68          
69          DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
70          Transformer messageTransformer = new TransformerChain(validTransformer, validTransformer, validTransformer);
71          message.applyTransformers((MuleEvent)null, messageTransformer);
72  
73          Object transformedMessage = message.getPayload();
74          assertNotNull(transformedMessage);
75          assertEquals(new Integer(3), transformedMessage);
76      }
77  
78      @Test
79      public void testIgnoreBadInputDoesNotBreakChainWithTransformationOrderInvalidValid() throws Exception
80      {
81          AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer();
82          assertNotNull(invalidTransformer);
83          invalidTransformer.setIgnoreBadInput(true);
84          
85          AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
86          assertNotNull(validTransformer);
87          
88          DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
89          Transformer messageTransformer = new TransformerChain(invalidTransformer, validTransformer);
90          message.applyTransformers((MuleEvent)null, messageTransformer);
91  
92          Object transformedMessage = message.getPayload();
93          assertNotNull(transformedMessage);
94          assertEquals(new Integer(1), transformedMessage);
95      }
96  
97      @Test
98      public void testIgnoreBadInputBreaksChainWithTransformationOrderInvalidValid() throws Exception
99      {
100         AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer();
101         assertNotNull(invalidTransformer);
102         invalidTransformer.setIgnoreBadInput(false);
103         
104         AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
105         assertNotNull(validTransformer);
106         
107         DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
108         Transformer messageTransformer = new TransformerChain(invalidTransformer, validTransformer);
109         
110         try
111         {
112             message.applyTransformers((MuleEvent)null, messageTransformer);
113             fail("Transformer chain is expected to fail because of invalid transformer within chain.");
114         }
115         catch (MuleException tfe)
116         {
117             // ignore
118         }
119     }
120 
121     @Test
122     public void testIgnoreBadInputDoesNotBreakChainWithTransformationOrderValidInvalid() throws Exception
123     {
124         AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer();
125         assertNotNull(invalidTransformer);
126         invalidTransformer.setIgnoreBadInput(true);
127         
128         AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
129         assertNotNull(validTransformer);
130         
131         DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
132         Transformer messageTransformer = new TransformerChain(validTransformer, invalidTransformer);
133         message.applyTransformers((MuleEvent)null, messageTransformer);
134 
135         Object transformedMessage = message.getPayload();
136         assertNotNull(transformedMessage);
137         assertEquals(new Integer(1), transformedMessage);
138     }
139 
140     @Test
141     public void testIgnoreBadInputBreaksChainWithTransformationOrderValidInvalid() throws Exception
142     {
143         AbstractTransformer invalidTransformer = (AbstractTransformer) this.getInvalidTransformer();
144         assertNotNull(invalidTransformer);
145         invalidTransformer.setIgnoreBadInput(false);
146         
147         AbstractTransformer validTransformer = (AbstractTransformer) this.getIncreaseByOneTransformer();
148         assertNotNull(validTransformer);
149         
150         DefaultMuleMessage message = new DefaultMuleMessage(new Integer(0), muleContext);
151         Transformer messageTransformer = new TransformerChain(validTransformer, invalidTransformer);
152         
153         try
154         {
155             message.applyTransformers((MuleEvent)null, messageTransformer);
156             fail("Transformer chain is expected to fail because of invalid transformer within chain.");
157         }
158         catch (MuleException tfe)
159         {
160             assertNotNull(tfe);
161         }
162     }
163 
164     private Transformer getInvalidTransformer() throws Exception
165     {
166         AbstractTransformer transformer = new AbstractTransformer()
167         {
168             @Override
169             protected Object doTransform(final Object src, final String encoding) throws TransformerException
170             {
171                 throw new RuntimeException("This transformer must not perform any transformations.");
172             }
173         };
174 
175         // Use this class as a bogus source type to enforce a simple invalid transformer
176         transformer.registerSourceType(DataTypeFactory.create(this.getClass()));
177         
178         return transformer;
179     }
180     
181     private Transformer getIncreaseByOneTransformer() throws Exception
182     {
183         AbstractTransformer transformer = new AbstractTransformer()
184         {
185             @Override
186             protected Object doTransform(Object src, String encoding) throws TransformerException
187             {
188                 return new Integer(((Integer) src).intValue() + 1);
189             }
190         };
191         
192         DataType<Integer> integerDataType = DataTypeFactory.create(Integer.class);
193         transformer.registerSourceType(integerDataType);
194         transformer.setReturnDataType(integerDataType);
195         
196         return transformer;
197     }
198     
199 }