View Javadoc

1   /*
2    * $Id: MuleEventTestCase.java 20385 2010-11-29 20:25:26Z dfeist $
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;
12  
13  import org.mule.api.MuleEvent;
14  import org.mule.api.endpoint.EndpointBuilder;
15  import org.mule.api.endpoint.ImmutableEndpoint;
16  import org.mule.api.routing.filter.Filter;
17  import org.mule.api.security.Credentials;
18  import org.mule.api.service.Service;
19  import org.mule.api.transformer.Transformer;
20  import org.mule.api.transformer.TransformerException;
21  import org.mule.endpoint.EndpointURIEndpointBuilder;
22  import org.mule.routing.MessageFilter;
23  import org.mule.routing.filters.PayloadTypeFilter;
24  import org.mule.tck.AbstractMuleTestCase;
25  import org.mule.transformer.AbstractTransformer;
26  import org.mule.transformer.simple.ByteArrayToObject;
27  import org.mule.transformer.simple.SerializableToByteArray;
28  
29  import java.io.Serializable;
30  import java.util.ArrayList;
31  import java.util.Arrays;
32  import java.util.List;
33  
34  
35  public class MuleEventTestCase extends AbstractMuleTestCase
36  {
37  
38  //    public void testEventInitialise() throws Exception
39  //    {
40  //        String data = "Test Data";
41  //
42  //        DefaultMuleEvent event = (DefaultMuleEvent)getTestEvent(data, getTestService("orange", Orange.class));
43  //        RequestContext.setEvent(event);
44  //        
45  //        assertEquals("MuleEvent data should equal " + data, data, event.getMessage().getPayload());
46  //        assertEquals("MuleEvent data should equal " + data, data, event.getMessageAsString());
47  //        assertEquals("MuleEvent data should equal " + data, data, event.transformMessage());
48  //        assertEquals("MuleEvent data should be a byte array 9 bytes in length", 9, event
49  //            .transformMessageToBytes().length);
50  //
51  //        assertEquals("MuleEvent data should be a byte array 9 bytes in length", 9,
52  //            event.getMessageAsBytes().length);
53  //        assertEquals("MuleEvent data should equal " + data, data, event.getSource());
54  //
55  //        assertEquals("MuleBeanPropertiesRule", event.getMessage().getProperty("MuleBeanPropertiesRule",
56  //            "MuleBeanPropertiesRule"));
57  //        event.getMessage().setProperty("Test", "Test1");
58  //
59  //        assertFalse(event.getMessage().getPropertyNames().isEmpty());
60  //        assertEquals("bla2", event.getMessage().getProperty("bla2", "bla2"));
61  //        assertEquals("Test1", event.getMessage().getProperty("Test"));
62  //        assertEquals("Test1", event.getMessage().getProperty("Test", "bla2"));
63  //        assertNotNull(event.getId());
64  //    }
65  //
66  //    public void testEventTransformer() throws Exception
67  //    {
68  //        String data = "Test Data";
69  //        ImmutableEndpoint endpoint = getTestOutboundEndpoint("Test",CollectionUtils.singletonList(new TestEventTransformer()));
70  //        MuleEvent event = getTestEvent(data, endpoint);
71  //        RequestContext.setEvent(event);
72  //        
73  //        assertEquals("MuleEvent data should equal " + data, data, event.getMessage().getPayload());
74  //        assertEquals("MuleEvent data should equal " + data, data, event.getMessageAsString());
75  //        assertEquals("MuleEvent data should equal 'Transformed Test Data'", "Transformed Test Data", event
76  //            .transformMessage());
77  //        assertEquals("MuleEvent data should be a byte array 28 bytes in length", 21, event
78  //            .transformMessageToBytes().length);
79  //    }
80  //
81  //    public void testEventRewrite() throws Exception
82  //    {
83  //        String data = "Test Data";
84  //        ImmutableEndpoint endpoint = getTestOutboundEndpoint("Test", CollectionUtils.singletonList(new TestEventTransformer()));
85  //        DefaultMuleEvent event = new DefaultMuleEvent(new DefaultMuleMessage(data), endpoint,
86  //            getTestSession(getTestService("apple", Apple.class), muleContext), true,
87  //            new ResponseOutputStream(System.out));
88  //
89  //        assertNotNull(event.getId());
90  //        assertNotNull(event.getSession());
91  //        assertNotNull(event.getEndpoint());
92  //        assertNotNull(event.getOutputStream());
93  //        assertNotNull(event.getMessage());
94  //        assertEquals(data, event.getMessageAsString());
95  //
96  //        MuleEvent event2 = new DefaultMuleEvent(new DefaultMuleMessage("New Data"), event);
97  //        assertNotNull(event2.getId());
98  //        assertEquals(event.getId(), event2.getId());
99  //        assertNotNull(event2.getSession());
100 //        assertNotNull(event2.getEndpoint());
101 //        assertNotNull(event2.getOutputStream());
102 //        assertNotNull(event2.getMessage());
103 //        assertEquals("New Data", event2.getMessageAsString());
104 //
105 //    }
106 //
107 //    public void testProperties() throws Exception
108 //    {
109 //        MuleEvent prevEvent;
110 //        Properties props;
111 //        MuleMessage msg;
112 //        ImmutableEndpoint endpoint;
113 //        MuleEvent event;
114 //
115 //        // nowhere
116 //        prevEvent = getTestEvent("payload");
117 //        props = new Properties();
118 //        msg = new DefaultMuleMessage("payload", props);
119 //        props = new Properties();
120 //        endpoint = getTestOutboundEndpoint("Test", null, null, null, props);
121 //        event = new DefaultMuleEvent(msg, endpoint, prevEvent.getService(), prevEvent);
122 //        assertNull(event.getMessage().getProperty("prop"));
123 //
124 //        // in previous event => previous event
125 //        prevEvent.getMessage().setProperty("prop", "value0");
126 //        event = new DefaultMuleEvent(msg, endpoint, prevEvent.getService(), prevEvent);
127 //        assertEquals("value0", event.getMessage().getProperty("prop"));
128 //
129 //        // TODO check if this fragment can be removed
130 //        // in previous event + endpoint => endpoint
131 //        // This doesn't apply now as the previous event properties will be the same
132 //        // as the current event props
133 //        // props = new Properties();
134 //        // props.put("prop", "value2");
135 //        // endpoint.setProperties(props);
136 //        // event = new DefaultMuleEvent(msg, endpoint, prevEvent.getComponent(), prevEvent);
137 //        // assertEquals("value2", event.getProperty("prop"));
138 //
139 //        // in previous event + message => message
140 //        props = new Properties();
141 //        props.put("prop", "value1");
142 //        msg = new DefaultMuleMessage("payload", props);
143 //        endpoint = getTestOutboundEndpoint("Test");
144 //        event = new DefaultMuleEvent(msg, endpoint, prevEvent.getService(), prevEvent);
145 //        assertEquals("value1", event.getMessage().getProperty("prop"));
146 //
147 //        // in previous event + endpoint + message => message
148 //        props = new Properties();
149 //        props.put("prop", "value1");
150 //        msg = new DefaultMuleMessage("payload", props);
151 //
152 //        Properties props2 = new Properties();
153 //        props2.put("prop", "value2");
154 //        endpoint = getTestOutboundEndpoint("Test", null, null, null, props2);
155 //        event = new DefaultMuleEvent(msg, endpoint, prevEvent.getService(), prevEvent);
156 //        assertEquals("value1", event.getMessage().getProperty("prop"));
157 //
158 //    }
159 //
160     /*
161      * See http://mule.mulesoft.org/jira/browse/MULE-384 for details.
162      */
163     public void testNoPasswordNoNullPointerException() throws Exception
164     {
165         // provide the username, but not the password, as is the case for SMTP
166         // cannot set SMTP endpoint type, because the module doesn't have this
167         // dependency
168         ImmutableEndpoint endpoint = getTestOutboundEndpoint("AuthTest", "test://john.doe@xyz.fr");
169         MuleEvent event = getTestEvent(new Object(), endpoint);
170         Credentials credentials = event.getCredentials();
171         assertNull("Credentials must not be created for endpoints without a password.", credentials);
172     }
173 
174     public void testEventSerialization() throws Exception
175     {
176         Transformer trans1 = new TestEventTransformer();
177         trans1.setName("OptimusPrime");
178 
179         Transformer trans2 = new TestEventTransformer();
180         trans2.setName("Bumblebee");
181 
182         List<Transformer> transformers = new ArrayList<Transformer>();
183         transformers.add(trans1);
184         transformers.add(trans2);
185 
186         ImmutableEndpoint endpoint = getTestOutboundEndpoint("Test", null, transformers, 
187             new PayloadTypeFilter(Object.class), null);
188 
189         MuleEvent event = RequestContext.setEvent(getTestEvent("payload", endpoint));
190         Serializable serialized = (Serializable) new SerializableToByteArray().transform(event);
191         assertNotNull(serialized);
192         ByteArrayToObject trans = new ByteArrayToObject();
193         trans.setMuleContext(muleContext);
194         MuleEvent deserialized = (MuleEvent) trans.transform(serialized);
195         
196         // Assert that deserialized event is not null and has muleContext
197         assertNotNull(deserialized);
198         assertNotNull(deserialized.getMuleContext());
199 
200         // Assert that deserialized event has session with same id
201         assertNotNull(deserialized.getSession());
202         assertEquals(event.getSession().getId(), deserialized.getSession().getId());
203 
204         // Assert that deserialized event has service and that the service is the same instance
205         assertNotNull(deserialized.getSession().getFlowConstruct());
206         assertEquals(event.getSession().getFlowConstruct(), deserialized.getSession().getFlowConstruct());
207         assertSame(event.getSession().getFlowConstruct(), deserialized.getSession().getFlowConstruct());
208 
209         // Assert that deserialized event has endpoint and that the endpoint is the same instance
210         assertNotNull(deserialized.getEndpoint());    
211         assertEquals(endpoint, deserialized.getEndpoint());
212 
213         List deserializedTransformers = deserialized.getEndpoint().getTransformers();
214         assertEquals(2, deserializedTransformers.size());
215         assertEquals(trans1.getName(), ((Transformer) deserializedTransformers.get(0)).getName());
216         assertEquals(trans2.getName(), ((Transformer) deserializedTransformers.get(1)).getName());
217         assertEquals(PayloadTypeFilter.class, deserialized.getEndpoint().getFilter().getClass());
218     }
219     
220     public void testEventSerializationRestart() throws Exception
221     {
222         // Create and register artifacts
223         MuleEvent event = createEventToSerialize();
224         muleContext.start();
225         List transformers = event.getEndpoint().getTransformers();
226         ImmutableEndpoint endpoint = event.getEndpoint();
227 
228         //Serialize
229         Serializable serialized = (Serializable) new SerializableToByteArray().transform(event);
230         assertNotNull(serialized);
231 
232         // Simulate mule cold restart
233         muleContext.dispose();
234         muleContext = createMuleContext();
235         muleContext.start();
236         ByteArrayToObject trans = new ByteArrayToObject();
237         trans.setMuleContext(muleContext);
238 
239         // Recreate and register artifacts (this would happen if using any kind of static config e.g. XML)
240         createAndRegisterTransformersEndpointBuilderService();
241 
242         //Deserialize
243         MuleEvent deserialized = (MuleEvent) trans.transform(serialized);
244 
245         // Assert that deserialized event is not null and has muleContext
246         assertNotNull(deserialized);
247         assertNotNull(deserialized.getMuleContext());
248 
249         // Assert that deserialized event has session with same id
250         assertNotNull(deserialized.getSession());
251         assertEquals(event.getSession().getId(), deserialized.getSession().getId());
252 
253         // Assert that deserialized event has service and that the service is the
254         // same instance
255         assertNotNull(deserialized.getSession().getFlowConstruct());
256 
257         Service service = (Service) event.getSession().getFlowConstruct();
258         Service deserializedService = (Service) deserialized.getSession().getFlowConstruct();
259         
260         // Unable to test services for equality because of need for equals() everywhere.  See MULE-3720
261         // assertEquals(event.getSession().getService(), deserialized.getSession().getService());
262         assertEquals(service.getName(), deserializedService.getName());
263         assertEquals(service.getInitialState(), deserializedService.getInitialState());
264         assertEquals(service.getExceptionListener().getClass(), deserializedService.getExceptionListener().getClass());
265         assertEquals(service.getComponent().getClass(), deserializedService.getComponent().getClass());
266         
267         // Assert that deserialized event has endpoint and that the endpoint is the
268         // same instance
269         assertNotNull(deserialized.getEndpoint());
270         // Unable to test endpoint for equality because of need for equals() everywhere.  See MULE-3720
271         // assertEquals(endpoint, deserialized.getEndpoint());
272         // Test some individual attributes instead
273         assertEquals(endpoint.getEncoding(), deserialized.getEndpoint().getEncoding());
274         assertEquals(endpoint.getEndpointBuilderName(), deserialized.getEndpoint().getEndpointBuilderName());
275         assertEquals(endpoint.getEndpointURI(), deserialized.getEndpoint().getEndpointURI());
276         assertEquals(endpoint.getProtocol(), deserialized.getEndpoint().getProtocol());
277         assertEquals(endpoint.getResponseTimeout(), deserialized.getEndpoint().getResponseTimeout());
278         assertEquals(endpoint.getConnector().getClass(), deserialized.getEndpoint().getConnector().getClass());
279         
280         List deserializedTransformers = deserialized.getEndpoint().getTransformers();
281         assertEquals(2, deserializedTransformers.size());
282         assertEquals(((Transformer) transformers.get(0)).getName(),
283             ((Transformer) deserializedTransformers.get(0)).getName());
284         assertEquals(((Transformer) transformers.get(1)).getName(),
285             ((Transformer) deserializedTransformers.get(1)).getName());
286         assertEquals(PayloadTypeFilter.class, deserialized.getEndpoint().getFilter().getClass());
287     }
288     
289     public void testMuleCredentialsSerialization() throws Exception
290     {
291         String username = "mule";
292         String password = "rulez";
293         String url = "test://" + username + ":" + password + "@localhost";
294         ImmutableEndpoint endpoint = getTestOutboundEndpoint("Test", url);
295         ByteArrayToObject trans = new ByteArrayToObject();
296         trans.setMuleContext(muleContext);
297 
298         MuleEvent event = RequestContext.setEvent(getTestEvent("payload", endpoint));
299         Serializable serialized = (Serializable) new SerializableToByteArray().transform(event);
300         assertNotNull(serialized);
301 
302         MuleEvent deserialized = (MuleEvent) trans.transform(serialized);
303         assertNotNull(deserialized);
304         
305         Credentials credentials = deserialized.getCredentials();
306         assertNotNull(credentials);
307         assertEquals(username, credentials.getUsername());
308         assertTrue(Arrays.equals(password.toCharArray(), credentials.getPassword()));
309     }
310     
311     private MuleEvent createEventToSerialize() throws Exception
312     {
313         createAndRegisterTransformersEndpointBuilderService();
314         ImmutableEndpoint endpoint = muleContext.getEndpointFactory().getInboundEndpoint(
315             muleContext.getRegistry().lookupEndpointBuilder("epBuilderTest"));
316         Service service = muleContext.getRegistry().lookupService("appleService");
317         return RequestContext.setEvent(getTestEvent("payload", service, endpoint));
318     }
319 
320     private void createAndRegisterTransformersEndpointBuilderService() throws Exception
321     {
322         Transformer trans1 = new TestEventTransformer();
323         trans1.setName("OptimusPrime");
324         muleContext.getRegistry().registerTransformer(trans1);
325 
326         Transformer trans2 = new TestEventTransformer();
327         trans2.setName("Bumblebee");
328         muleContext.getRegistry().registerTransformer(trans2);
329 
330         List<Transformer> transformers = new ArrayList<Transformer>();
331         transformers.add(trans1);
332         transformers.add(trans2);
333 
334         Filter filter = new PayloadTypeFilter(Object.class);
335         EndpointBuilder endpointBuilder = new EndpointURIEndpointBuilder("test://serializationTest",
336             muleContext);
337         endpointBuilder.setTransformers(transformers);
338         endpointBuilder.setName("epBuilderTest");
339         endpointBuilder.addMessageProcessor(new MessageFilter(filter));
340         muleContext.getRegistry().registerEndpointBuilder("epBuilderTest", endpointBuilder);
341 
342         getTestService();
343     }
344 
345     private static class TestEventTransformer extends AbstractTransformer
346     {
347         public Object doTransform(Object src, String encoding) throws TransformerException
348         {
349             return "Transformed Test Data";
350         }
351     }
352 
353 }