View Javadoc

1   /*
2    * $Id: MuleSessionHandlerTestCase.java 19400 2010-09-07 20:20:09Z mike.schilling $
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.MuleMessage;
14  import org.mule.api.MuleSession;
15  import org.mule.api.config.MuleProperties;
16  import org.mule.api.security.Authentication;
17  import org.mule.api.security.Credentials;
18  import org.mule.api.security.SecurityContext;
19  import org.mule.api.transport.SessionHandler;
20  import org.mule.security.DefaultMuleAuthentication;
21  import org.mule.security.DefaultSecurityContextFactory;
22  import org.mule.security.MuleCredentials;
23  import org.mule.session.DefaultMuleSession;
24  import org.mule.session.LegacySessionHandler;
25  import org.mule.session.SerializeAndEncodeSessionHandler;
26  import org.mule.tck.AbstractMuleTestCase;
27  
28  import java.util.ArrayList;
29  import java.util.Date;
30  import java.util.List;
31  
32  import org.apache.commons.lang.SerializationException;
33  
34  public class MuleSessionHandlerTestCase extends AbstractMuleTestCase
35  {
36      /** @see EE-1705/MULE-4567 */
37      public void testSessionProperties() throws Exception 
38      {
39          DefaultMuleMessage message = new DefaultMuleMessage("Test Message", muleContext);
40          SessionHandler handler = new SerializeAndEncodeSessionHandler();
41          MuleSession session = new DefaultMuleSession(muleContext);
42          
43          String string = "bar";
44          session.setProperty("fooString", string);
45  
46          Date date = new Date(0);
47          session.setProperty("fooDate", date);
48          
49          List<String> list = createList();
50          session.setProperty("fooList", list);
51          
52          handler.storeSessionInfoToMessage(session, message);
53          // store save session to outbound, move it to the inbound
54          // for retrieve to deserialize
55          Object s = message.removeProperty(MuleProperties.MULE_SESSION_PROPERTY);
56          message.setInboundProperty(MuleProperties.MULE_SESSION_PROPERTY, s);
57          session = handler.retrieveSessionInfoFromMessage(message);
58          
59          Object obj = session.getProperty("fooString");
60          assertTrue(obj instanceof String);
61          assertEquals(string, obj);
62          
63          obj = session.getProperty("fooDate");
64          assertTrue("Object should be a Date but is " + obj.getClass().getName(), obj instanceof Date);
65          assertEquals(date, obj);
66  
67          obj = session.getProperty("fooList");
68          assertTrue("Object should be a List but is " + obj.getClass().getName(), obj instanceof List);
69          assertEquals(list, obj);
70      }
71  
72      /** @see EE-1774 */
73      public void testNonSerializableSessionProperties() throws Exception 
74      {
75          DefaultMuleMessage message = new DefaultMuleMessage("Test Message", muleContext);
76          MuleSession session = new DefaultMuleSession(muleContext);
77          SessionHandler handler = new SerializeAndEncodeSessionHandler();
78          
79          NotSerializableClass clazz = new NotSerializableClass();
80          session.setProperty("foo", clazz);
81          handler.storeSessionInfoToMessage(session, message);
82          // store save session to outbound, move it to the inbound
83          // for retrieve to deserialize
84          Object s = message.removeProperty(MuleProperties.MULE_SESSION_PROPERTY);
85          message.setInboundProperty(MuleProperties.MULE_SESSION_PROPERTY, s);
86          session = handler.retrieveSessionInfoFromMessage(message);
87          // Property was removed because it could not be serialized
88          assertNull(session.getProperty("foo"));
89      }    
90  
91      /** @see EE-1820 */
92      public void testBackwardsCompatibility() throws Exception 
93      {
94          MuleMessage message = new DefaultMuleMessage("Test Message", muleContext);
95          SessionHandler legacyHandler = new LegacySessionHandler();
96          MuleSession session = new DefaultMuleSession(muleContext);
97          
98          String string = "bar";
99          session.setProperty("fooString", string);
100 
101         Date date = new Date(0);
102         session.setProperty("fooDate", date);
103         
104         List<String> list = createList();
105         session.setProperty("fooList", list);
106         
107         legacyHandler.storeSessionInfoToMessage(session, message);
108         try
109         {
110             // Try to deserialize legacy format with new session handler
111             session = new SerializeAndEncodeSessionHandler().retrieveSessionInfoFromMessage(message);
112         }
113         catch (SerializationException e)
114         {
115             // expected
116         }
117         session = legacyHandler.retrieveSessionInfoFromMessage(message);
118     }    
119     
120     /** @see EE-1820 */
121     public void testSessionPropertiesLegacyFormat() throws Exception 
122     {
123         DefaultMuleMessage message = new DefaultMuleMessage("Test Message", muleContext);
124         SessionHandler handler = new LegacySessionHandler();
125         MuleSession session = new DefaultMuleSession(muleContext);
126         
127         String string = "bar";
128         session.setProperty("fooString", string);
129 
130         Date date = new Date(0);
131         session.setProperty("fooDate", date);
132         
133         List<String> list = createList();
134         session.setProperty("fooList", list);
135 
136         handler.storeSessionInfoToMessage(session, message);
137         // store save session to outbound, move it to the inbound
138         // for retrieve to deserialize
139         Object s = message.removeProperty(MuleProperties.MULE_SESSION_PROPERTY);
140         message.setInboundProperty(MuleProperties.MULE_SESSION_PROPERTY, s);
141         session = handler.retrieveSessionInfoFromMessage(message);
142         
143         Object obj = session.getProperty("fooString");
144         assertTrue(obj instanceof String);
145         assertEquals(string, obj);
146         
147         obj = session.getProperty("fooDate");
148         // MULE-4567 / EE-1705 
149         assertTrue(obj instanceof String);
150 
151         obj = session.getProperty("fooList");
152         // MULE-4567 / EE-1705 
153         assertTrue(obj instanceof String);
154     }    
155 
156     /** @see MULE-4720 */
157     public void testSecurityContext() throws Exception 
158     {
159         DefaultMuleMessage message = new DefaultMuleMessage("Test Message", muleContext);
160         SessionHandler handler = new SerializeAndEncodeSessionHandler();
161         MuleSession session = new DefaultMuleSession(muleContext);
162         
163         Credentials credentials = new MuleCredentials("joe", "secret".toCharArray());
164         SecurityContext sc = new DefaultSecurityContextFactory().create(new DefaultMuleAuthentication(credentials));
165         session.setSecurityContext(sc);
166 
167         handler.storeSessionInfoToMessage(session, message);
168         // store save session to outbound, move it to the inbound
169         // for retrieve to deserialize
170         Object s = message.removeProperty(MuleProperties.MULE_SESSION_PROPERTY);
171         message.setInboundProperty(MuleProperties.MULE_SESSION_PROPERTY, s);
172         session = handler.retrieveSessionInfoFromMessage(message);
173 
174         sc = session.getSecurityContext();
175         assertEquals("joe", sc.getAuthentication().getPrincipal());
176     }    
177     
178     /** @see EE-1774 */
179     public void testNotSerializableSecurityContext() throws Exception 
180     {
181         MuleMessage message = new DefaultMuleMessage("Test Message", muleContext);
182         SessionHandler handler = new SerializeAndEncodeSessionHandler();
183         MuleSession session = new DefaultMuleSession(muleContext);
184         
185         session.setSecurityContext(new NotSerializableSecurityContext());
186         
187         try
188         {
189             handler.storeSessionInfoToMessage(session, message);
190             fail("Should throw a SerializationException");
191         }
192         catch (SerializationException e)
193         {
194             // expected
195         }
196     }    
197 
198     private List<String> createList()
199     {
200         List<String> list = new ArrayList<String>();
201         list.add("bar1");
202         list.add("bar2");
203         return list;
204     }    
205 
206     private class NotSerializableClass
207     {
208         public NotSerializableClass()
209         {
210             super();
211         }
212     }
213     
214     private class NotSerializableSecurityContext implements SecurityContext
215     {
216         public NotSerializableSecurityContext()
217         {
218             super();
219         }
220         
221         public void setAuthentication(Authentication authentication)
222         { 
223             // nothing to do
224         }
225 
226         public Authentication getAuthentication() 
227         { 
228             return null;
229         }
230     }
231     
232 }