View Javadoc

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