View Javadoc

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