View Javadoc

1   /*
2    * $Id: ExpressionTransformerTestCase.java 22414 2011-07-14 13:24:46Z 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.transformers.simple;
12  
13  import org.mule.DefaultMuleEvent;
14  import org.mule.DefaultMuleMessage;
15  import org.mule.api.MuleEvent;
16  import org.mule.api.MuleMessage;
17  import org.mule.api.expression.RequiredValueException;
18  import org.mule.construct.Flow;
19  import org.mule.expression.transformers.BeanBuilderTransformer;
20  import org.mule.expression.transformers.ExpressionArgument;
21  import org.mule.expression.transformers.ExpressionTransformer;
22  import org.mule.tck.junit4.FunctionalTestCase;
23  import org.mule.tck.testmodels.fruit.Apple;
24  import org.mule.tck.testmodels.fruit.Banana;
25  import org.mule.tck.testmodels.fruit.FruitBasket;
26  import org.mule.tck.testmodels.fruit.FruitBowl;
27  
28  import java.util.HashMap;
29  import java.util.List;
30  import java.util.Map;
31  
32  import org.junit.Test;
33  
34  import static org.junit.Assert.assertEquals;
35  import static org.junit.Assert.assertFalse;
36  import static org.junit.Assert.assertNotNull;
37  import static org.junit.Assert.assertNull;
38  import static org.junit.Assert.assertTrue;
39  import static org.junit.Assert.fail;
40  
41  public class ExpressionTransformerTestCase extends FunctionalTestCase
42  {
43  
44      @Override
45      protected String getConfigResources()
46      {
47          return "org/mule/test/transformers/expression-transformers-test.xml";
48      }
49  
50      @Test
51      public void testTransformerConfig() throws Exception
52      {
53          ExpressionTransformer transformer = (ExpressionTransformer) muleContext.getRegistry().lookupTransformer("testTransformer");
54          assertNotNull(transformer);
55          assertNotNull(transformer.getArguments());
56          assertEquals(2, transformer.getArguments().size());
57          ExpressionArgument arg1 = transformer.getArguments().get(0);
58          assertEquals("payload", arg1.getEvaluator());
59          assertEquals("org.mule.tck.testmodels.fruit.FruitBasket", arg1.getExpression());
60          assertFalse(arg1.isOptional());
61  
62          ExpressionArgument arg2 = transformer.getArguments().get(1);
63          assertEquals("headers", arg2.getEvaluator());
64          assertEquals("foo,bar?", arg2.getExpression());
65          assertTrue(arg2.isOptional());
66      }
67  
68      @Test
69      public void testBeanBuilderTransformerConfig() throws Exception
70      {
71          BeanBuilderTransformer transformer = (BeanBuilderTransformer) muleContext.getRegistry().lookupTransformer("testTransformer3");
72          assertNotNull(transformer);
73          assertNotNull(transformer.getArguments());
74          assertEquals(3, transformer.getArguments().size());
75          ExpressionArgument arg1 = transformer.getArguments().get(0);
76          assertEquals("brand", arg1.getName());
77          assertEquals("mule", arg1.getEvaluator());
78          assertEquals("message.payload", arg1.getExpression());
79          assertFalse(arg1.isOptional());
80  
81          ExpressionArgument arg2 = transformer.getArguments().get(1);
82          assertEquals("segments", arg2.getName());
83          assertEquals("mule", arg2.getEvaluator());
84          assertEquals("message.header(SEGMENTS)", arg2.getExpression());
85          assertTrue(arg2.isOptional());
86      }
87  
88      @Test
89      public void testExecutionWithCorrectMessage() throws Exception
90      {
91          ExpressionTransformer transformer = (ExpressionTransformer) muleContext.getRegistry().lookupTransformer("testTransformer");
92          Map<String, Object> props = new HashMap<String, Object>();
93          props.put("foo", "moo");
94          props.put("bar", "mar");
95  
96          MuleMessage message = new DefaultMuleMessage(new FruitBowl(new Apple(), new Banana()), props, muleContext);
97  
98          Object result = transformer.transform(message);
99          assertNotNull(result);
100         assertTrue(result.getClass().isArray());
101         Object o1 = ((Object[]) result)[0];
102         assertTrue(o1 instanceof FruitBasket);
103 
104         Object o2 = ((Object[]) result)[1];
105         assertTrue(o2 instanceof Map<?, ?>);
106         Map<?, ?> map = (Map<?, ?>) o2;
107         assertEquals(2, map.size());
108         assertEquals("moo", map.get("foo"));
109         assertEquals("mar", map.get("bar"));
110     }
111 
112     @Test
113     public void testExecutionWithPartialMissingOptionalParams() throws Exception
114     {
115         ExpressionTransformer transformer = (ExpressionTransformer) muleContext.getRegistry().lookupTransformer("testTransformer");
116         Map<String, Object> props = new HashMap<String, Object>();
117         props.put("foo", "moo");
118 
119         MuleMessage message = new DefaultMuleMessage(new FruitBowl(new Apple(), new Banana()), props, muleContext);
120 
121         Object result = transformer.transform(message);
122         assertNotNull(result);
123         assertTrue(result.getClass().isArray());
124         Object o1 = ((Object[]) result)[0];
125         assertTrue(o1 instanceof FruitBasket);
126 
127         Object o2 = ((Object[]) result)[1];
128         assertTrue(o2 instanceof Map<?, ?>);
129         Map<?, ?> map = (Map<?, ?>) o2;
130         assertEquals(1, map.size());
131         assertEquals("moo", map.get("foo"));
132     }
133 
134     @Test
135     public void testExecutionWithAllMissingOptionalParams() throws Exception
136     {
137         ExpressionTransformer transformer = (ExpressionTransformer) muleContext.getRegistry().lookupTransformer("testTransformer");
138 
139         MuleMessage message = new DefaultMuleMessage(new FruitBowl(new Apple(), new Banana()), muleContext);
140 
141         Object result = transformer.transform(message);
142         assertNotNull(result);
143         assertTrue(result.getClass().isArray());
144         Object o1 = ((Object[]) result)[0];
145         assertTrue(o1 instanceof FruitBasket);
146 
147         assertNull(((Object[]) result)[1]);
148     }
149 
150     @Test
151     public void testTransformerConfigWithSingleArgument() throws Exception
152     {
153         ExpressionTransformer transformer = (ExpressionTransformer) muleContext.getRegistry().lookupTransformer("testTransformer2");
154         Map<String, Object> props = new HashMap<String, Object>();
155         props.put("foo", "moo");
156         props.put("bar", "mar");
157 
158         MuleMessage message = new DefaultMuleMessage(new FruitBowl(new Apple(), new Banana()), props, muleContext);
159 
160         Object result = transformer.transform(message);
161         assertNotNull(result);
162         assertFalse(result.getClass().isArray());
163         assertTrue(result instanceof List<?>);
164         List<?> list = (List<?>) result;
165         assertTrue(list.contains("moo"));
166         assertTrue(list.contains("mar"));
167     }
168 
169     @Test
170     public void testTransformerConfigWithSingleArgumentShortcutConfig() throws Exception
171     {
172         ExpressionTransformer transformer = (ExpressionTransformer) muleContext.getRegistry().lookupTransformer("testTransformer4");
173         Map<String, Object> props = new HashMap<String, Object>();
174         props.put("foo", "moo");
175         props.put("bar", "mar");
176 
177         MuleMessage message = new DefaultMuleMessage(new FruitBowl(new Apple(), new Banana()), props, muleContext);
178 
179         Object result = transformer.transform(message);
180         assertNotNull(result);
181         assertFalse(result.getClass().isArray());
182         assertTrue(result instanceof List<?>);
183         List<?> list = (List<?>) result;
184         assertTrue(list.contains("moo"));
185         assertTrue(list.contains("mar"));
186     }
187 
188     @Test
189     public void testTransformerConfigWithSingleArgumentShortcutConfigInFlow() throws Exception
190     {
191         Flow flow = (Flow) muleContext.getRegistry().lookupFlowConstruct("et");
192         Map<String, Object> props = new HashMap<String, Object>();
193         props.put("foo", "moo");
194         props.put("bar", "mar");
195 
196         MuleMessage message = new DefaultMuleMessage(new FruitBowl(new Apple(), new Banana()), props,
197             muleContext);
198 
199         MuleEvent resultEvent = flow.process(new DefaultMuleEvent(message, getTestInboundEndpoint(""),
200             getTestSession(getTestService(), muleContext)));
201         assertNotNull(resultEvent);
202         assertNotNull(resultEvent.getMessage().getPayload());
203         Object payload = resultEvent.getMessage().getPayload();
204         assertFalse(payload.getClass().isArray());
205         assertTrue(payload instanceof List<?>);
206         List<?> list = (List<?>) payload;
207         assertTrue(list.contains("moo"));
208         assertTrue(list.contains("mar"));
209     }
210 
211     @Test(expected = RequiredValueException.class)
212     public void testExecutionWithInCorrectMessage() throws Exception
213     {
214         ExpressionTransformer transformer = (ExpressionTransformer) muleContext.getRegistry().lookupTransformer("testTransformer2");
215         Map<String, Object> props = new HashMap<String, Object>();
216         props.put("foo", "moo");
217 
218         MuleMessage message = new DefaultMuleMessage(new FruitBowl(new Apple(), new Banana()), props, muleContext);
219 
220         transformer.transform(message);
221         fail("Not all headers present, the transform should have failed");
222     }
223 }