View Javadoc

1   /*
2    * $Id: MessagePropertiesTransformerTestCase.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.DefaultMuleMessage;
14  import org.mule.api.MuleEventContext;
15  import org.mule.api.MuleMessage;
16  import org.mule.api.transformer.TransformerException;
17  import org.mule.api.transport.PropertyScope;
18  import org.mule.tck.junit4.FunctionalTestCase;
19  import org.mule.transformer.simple.MessagePropertiesTransformer;
20  
21  import java.util.HashMap;
22  import java.util.Map;
23  
24  import org.junit.Test;
25  
26  import static org.junit.Assert.assertEquals;
27  import static org.junit.Assert.assertFalse;
28  import static org.junit.Assert.assertNotNull;
29  import static org.junit.Assert.assertSame;
30  import static org.junit.Assert.assertTrue;
31  
32  public class MessagePropertiesTransformerTestCase extends FunctionalTestCase
33  {
34  
35      @Override
36      protected String getConfigResources()
37      {
38          return "message-properties-transformer-config.xml";
39      }
40  
41      @Test
42      public void testOverwriteFlagEnabledByDefault() throws Exception
43      {
44          MessagePropertiesTransformer t = new MessagePropertiesTransformer();
45          Map<String, Object> add = new HashMap<String, Object>();
46          add.put("addedProperty", "overwrittenValue");
47          t.setAddProperties(add);
48          t.setMuleContext(muleContext);
49  
50          MuleMessage msg = new DefaultMuleMessage("message", muleContext);
51          msg.setOutboundProperty("addedProperty", "originalValue");
52          MuleEventContext ctx = getTestEventContext(msg);
53          // context clones message
54          msg = ctx.getMessage();
55          DefaultMuleMessage transformed = (DefaultMuleMessage) t.transform(msg, (String)null);
56          assertSame(msg, transformed);
57          assertEquals(msg.getUniqueId(), transformed.getUniqueId());
58          assertEquals(msg.getPayload(), transformed.getPayload());
59          compareProperties(msg, transformed);
60  
61          assertEquals("overwrittenValue", transformed.getOutboundProperty("addedProperty"));
62      }
63  
64      @Test
65      public void testOverwriteFalsePreservesOriginal() throws Exception
66      {
67          MessagePropertiesTransformer t = new MessagePropertiesTransformer();
68          Map<String, Object> add = new HashMap<String, Object>();
69          add.put("addedProperty", "overwrittenValue");
70          t.setAddProperties(add);
71          t.setOverwrite(false);
72          t.setMuleContext(muleContext);
73  
74          DefaultMuleMessage msg = new DefaultMuleMessage("message", muleContext);
75          msg.setProperty("addedProperty", "originalValue", PropertyScope.INVOCATION);
76          DefaultMuleMessage transformed = (DefaultMuleMessage) t.transform(msg, (String)null);
77          assertSame(msg, transformed);
78          assertEquals(msg.getUniqueId(), transformed.getUniqueId());
79          assertEquals(msg.getPayload(), transformed.getPayload());
80          compareProperties(msg, transformed);
81  
82          assertEquals("originalValue", transformed.getInvocationProperty("addedProperty"));
83      }
84  
85      @Test
86      public void testExpressionsInAddProperties() throws Exception
87      {
88          MessagePropertiesTransformer t = new MessagePropertiesTransformer();
89          Map<String, Object> add = new HashMap<String, Object>();
90          add.put("Foo", "#[header:public-house]");
91          t.setAddProperties(add);
92          t.setMuleContext(muleContext);
93  
94          DefaultMuleMessage msg = new DefaultMuleMessage("message", muleContext);
95          msg.setOutboundProperty("public-house", "Bar");
96          DefaultMuleMessage transformed = (DefaultMuleMessage) t.transform(msg, (String)null);
97          assertSame(msg, transformed);
98          assertEquals(msg.getUniqueId(), transformed.getUniqueId());
99          assertEquals(msg.getPayload(), transformed.getPayload());
100         compareProperties(msg, transformed);
101 
102         assertEquals("Bar", transformed.getOutboundProperty("Foo"));
103     }
104 
105     @Test
106     public void testRenameProperties() throws Exception
107     {
108         MessagePropertiesTransformer t = new MessagePropertiesTransformer();
109         Map<String, String> add = new HashMap<String, String>();
110         add.put("Foo", "Baz");
111         t.setRenameProperties(add);
112         t.setScope(PropertyScope.INVOCATION);
113         t.setMuleContext(muleContext);
114 
115         DefaultMuleMessage msg = new DefaultMuleMessage("message", muleContext);
116         msg.setInvocationProperty("Foo", "Bar");
117         DefaultMuleMessage transformed = (DefaultMuleMessage) t.transform(msg);
118         assertSame(msg, transformed);
119         assertEquals(msg.getUniqueId(), transformed.getUniqueId());
120         assertEquals(msg.getPayload(), transformed.getPayload());
121         compareProperties(msg, transformed);
122 
123         assertEquals("Bar", transformed.getInvocationProperty("Baz"));
124     }
125 
126     @Test
127     public void testDelete() throws Exception
128     {
129         MessagePropertiesTransformer t = new MessagePropertiesTransformer();
130         t.setDeleteProperties("badProperty");
131         t.setMuleContext(muleContext);
132 
133         DefaultMuleMessage msg = new DefaultMuleMessage("message", muleContext);
134         msg.setOutboundProperty("badProperty", "badValue");
135         assertEquals("badValue", msg.<Object>getOutboundProperty("badProperty"));
136         DefaultMuleMessage transformed = (DefaultMuleMessage) t.transform(msg, (String)null);
137         assertSame(msg, transformed);
138         assertEquals(msg.getUniqueId(), transformed.getUniqueId());
139         assertEquals(msg.getPayload(), transformed.getPayload());
140         compareProperties(msg, transformed);
141 
142         assertFalse(transformed.getInvocationPropertyNames().contains("badValue"));
143         assertFalse(transformed.getInboundPropertyNames().contains("badValue"));
144         assertFalse(transformed.getOutboundPropertyNames().contains("badValue"));
145         assertFalse(transformed.getSessionPropertyNames().contains("badValue"));
146     }
147 
148     @Test
149     public void testTransformerConfig() throws Exception
150     {
151         MessagePropertiesTransformer transformer = (MessagePropertiesTransformer) muleContext.getRegistry().lookupTransformer("testTransformer");
152         transformer.setMuleContext(muleContext);
153         assertNotNull(transformer);
154         assertNotNull(transformer.getAddProperties());
155         assertNotNull(transformer.getDeleteProperties());
156         assertEquals(2, transformer.getAddProperties().size());
157         assertEquals(2, transformer.getDeleteProperties().size());
158         assertEquals(1, transformer.getRenameProperties().size());
159         assertTrue(transformer.isOverwrite());
160         assertEquals("text/baz;charset=UTF-16BE", transformer.getAddProperties().get("Content-Type"));
161         assertEquals("value", transformer.getAddProperties().get("key"));
162         assertEquals("test-property1", transformer.getDeleteProperties().get(0));
163         assertEquals("test-property2", transformer.getDeleteProperties().get(1));
164         assertEquals("Faz", transformer.getRenameProperties().get("Foo"));
165         assertEquals(PropertyScope.OUTBOUND, transformer.getScope());
166     }
167 
168     @Test
169     public void testDeleteUsingPropertyName() throws Exception
170     {
171         final String expression = "badProperty";
172         final String[] validProperties = new String[] {"somethingnotsobad"};
173         final String[] invalidProperties = new String[] {"badProperty"};
174 
175         doTestMessageTransformationWithExpression(expression, validProperties, invalidProperties);
176     }
177 
178     @Test
179     public void testDeletePropertiesStartingWithExpression() throws Exception
180     {
181         final String expression = "^bad.*";
182         final String[] validProperties = new String[] {"somethingnotsobad"};
183         final String[] invalidProperties = new String[] {"badProperty", "badThing"};
184 
185         doTestMessageTransformationWithExpression(expression, validProperties, invalidProperties);
186     }
187 
188     @Test
189     public void testDeletePropertiesCaseInsensitiveRegex() throws Exception
190     {
191         final String expression = "(?i)^BAD.*";
192         final String[] validProperties = new String[] {"somethingnotsobad"};
193         final String[] invalidProperties = new String[] {"badProperty", "badThing"};
194 
195         doTestMessageTransformationWithExpression(expression, validProperties, invalidProperties);
196     }
197 
198     @Test
199     public void testDeletePropertiesEndingWithExpression() throws Exception
200     {
201         final String expression = ".*bad$";
202         final String[] validProperties = new String[] {"badProperty", "badThing"};
203         final String[] invalidProperties = new String[] {"somethingnotsobad"};
204 
205         doTestMessageTransformationWithExpression(expression, validProperties, invalidProperties);
206     }
207 
208     @Test
209     public void testDeletePropertiesContainingExpression() throws Exception
210     {
211         final String expression = ".*bad.*";
212         final String[] validProperties = new String[] {};
213         final String[] invalidProperties = new String[] {"badProperty", "badThing", "somethingnotsobad"};
214 
215         doTestMessageTransformationWithExpression(expression, validProperties, invalidProperties);
216     }
217 
218     @Test
219     public void testDeletePropertiesUsingWildcard() throws Exception
220     {
221         final String expression = "bad*";
222         final String[] validProperties = new String[] {"somethingnotsobad"};
223         final String[] invalidProperties = new String[] {"badProperty", "badThing"};
224 
225         doTestMessageTransformationWithExpression(expression, validProperties, invalidProperties);
226     }
227 
228     private void doTestMessageTransformationWithExpression(String expression, String[] validProperties, String[] invalidProperties)
229             throws TransformerException
230     {
231         MessagePropertiesTransformer t = createTransformerWithExpression(expression);
232 
233         DefaultMuleMessage msg = new DefaultMuleMessage("message", muleContext);
234         addPropertiesToMessage(validProperties, msg);
235         addPropertiesToMessage(invalidProperties, msg);
236 
237         DefaultMuleMessage transformed = (DefaultMuleMessage) t.transform(msg);
238         assertSame(msg, transformed);
239         assertEquals(msg.getUniqueId(), transformed.getUniqueId());
240         assertEquals(msg.getPayload(), transformed.getPayload());
241         assertMessageContainsExpectedProperties(validProperties, invalidProperties, transformed);
242     }
243 
244     private void assertMessageContainsExpectedProperties(String[] validProperties, String[] invalidProperties, DefaultMuleMessage transformed)
245     {
246         for (String property : validProperties)
247         {
248             assertTrue("Should contain property: " + property, transformed.getOutboundPropertyNames().contains(property));
249         }
250 
251         for (String property : invalidProperties)
252         {
253             assertFalse("Should not contain property: " + property, transformed.getOutboundPropertyNames().contains(property));
254         }
255     }
256 
257     private MessagePropertiesTransformer createTransformerWithExpression(String expression)
258     {
259         MessagePropertiesTransformer t = new MessagePropertiesTransformer();
260         t.setDeleteProperties(expression);
261         t.setMuleContext(muleContext);
262         return t;
263     }
264 
265     private void addPropertiesToMessage(String[] validProperties, DefaultMuleMessage msg)
266     {
267         for (String property : validProperties)
268         {
269             msg.setOutboundProperty(property, "defaultPropertyValue");
270         }
271     }
272 
273     private void compareProperties(MuleMessage msg, MuleMessage transformed)
274     {
275         assertEquals(msg.getInvocationPropertyNames(), transformed.getInvocationPropertyNames());
276         assertEquals(msg.getInboundPropertyNames(), transformed.getInboundPropertyNames());
277         assertEquals(msg.getOutboundPropertyNames(), transformed.getOutboundPropertyNames());
278         assertEquals(msg.getSessionPropertyNames(), transformed.getSessionPropertyNames());
279     }
280 
281 }