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