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.transport.http;
8   
9   import org.mule.tck.junit4.AbstractMuleTestCase;
10  
11  import java.util.Date;
12  import java.util.HashMap;
13  import java.util.LinkedHashMap;
14  import java.util.Map;
15  
16  import org.apache.commons.httpclient.Cookie;
17  import org.apache.commons.httpclient.cookie.MalformedCookieException;
18  import org.junit.Test;
19  
20  import static org.junit.Assert.assertEquals;
21  import static org.junit.Assert.assertNotNull;
22  import static org.junit.Assert.assertNull;
23  import static org.junit.Assert.assertSame;
24  import static org.junit.Assert.assertTrue;
25  import static org.junit.Assert.fail;
26  
27  public class CookieHelperTestCase extends AbstractMuleTestCase
28  {
29      private static final String COOKIE_1_NAME = "cookie1";
30      private static final String COOKIE_1_ORIGINAL_VALUE = "value1";
31      private static final String COOKIE_2_NAME = "cookie2";
32      private static final String COOKIE_2_VALUE = "value2";
33      private static final String COOKIE_1_NEW_VALUE = "newValue1 That Overrides Previous One";
34  
35      @Test
36      @SuppressWarnings("unchecked")
37      public void testPutAndMergeCookieObjectMapOfStringString_CookiesInMap_NewCookiesInMap()
38      {
39          Map<String, String> cookiesObject = new HashMap<String, String>();
40          cookiesObject.put(COOKIE_1_NAME, COOKIE_1_ORIGINAL_VALUE);
41  
42          assertEquals(1, cookiesObject.size());
43  
44          Map<String, String> newCookiesMap = new HashMap<String, String>();
45          newCookiesMap.put(COOKIE_1_NAME, COOKIE_1_NEW_VALUE);
46          newCookiesMap.put(COOKIE_2_NAME, COOKIE_2_VALUE);
47          cookiesObject = (Map<String, String>) CookieHelper.putAndMergeCookie(cookiesObject, newCookiesMap);
48  
49          assertEquals(2, cookiesObject.size());
50          assertEquals(COOKIE_1_NEW_VALUE, cookiesObject.get(COOKIE_1_NAME));
51          assertEquals(COOKIE_2_VALUE, cookiesObject.get(COOKIE_2_NAME));
52  
53          Map<String, String> unModifiedCookiesObject = (Map<String, String>) CookieHelper.putAndMergeCookie(
54              cookiesObject, (Map<String, String>) null);
55          assertSame(cookiesObject, unModifiedCookiesObject);
56          assertEquals(2, cookiesObject.size());
57      }
58  
59      @Test
60      public void testPutAndMergeCookieObjectMapOfStringString_CookiesInArray_NewCookiesInMap()
61      {
62          Cookie[] cookiesObject = new Cookie[]{new Cookie(null, COOKIE_1_NAME, COOKIE_1_ORIGINAL_VALUE)};
63  
64          Map<String, String> newCookiesMap = new HashMap<String, String>();
65          newCookiesMap.put(COOKIE_1_NAME, COOKIE_1_NEW_VALUE);
66          newCookiesMap.put(COOKIE_2_NAME, COOKIE_2_VALUE);
67  
68          cookiesObject = (Cookie[]) CookieHelper.putAndMergeCookie(cookiesObject, newCookiesMap);
69  
70          assertEquals(2, cookiesObject.length);
71  
72          assertEquals(COOKIE_1_NAME, cookiesObject[0].getName());
73          assertEquals(COOKIE_1_NEW_VALUE, cookiesObject[0].getValue());
74  
75          assertEquals(COOKIE_2_NAME, cookiesObject[1].getName());
76          assertEquals(COOKIE_2_VALUE, cookiesObject[1].getValue());
77  
78          Cookie[] unModifiedCookiesObject = (Cookie[]) CookieHelper.putAndMergeCookie(cookiesObject,
79              (Map<String, String>) null);
80          assertSame(cookiesObject, unModifiedCookiesObject);
81          assertEquals(2, cookiesObject.length);
82      }
83  
84      @Test
85      @SuppressWarnings("unchecked")
86      public void testPutAndMergeCookieObjectCookieArray_CookiesInMap_NewCookiesInArray()
87      {
88          Map<String, String> cookiesObject = new HashMap<String, String>();
89          cookiesObject.put(COOKIE_1_NAME, COOKIE_1_ORIGINAL_VALUE);
90  
91          assertEquals(1, cookiesObject.size());
92  
93          Cookie[] newCookiesArray = new Cookie[]{new Cookie(null, COOKIE_1_NAME, COOKIE_1_NEW_VALUE),
94              new Cookie(null, COOKIE_2_NAME, COOKIE_2_VALUE)};
95  
96          cookiesObject = (Map<String, String>) CookieHelper.putAndMergeCookie(cookiesObject, newCookiesArray);
97  
98          assertEquals(2, cookiesObject.size());
99          assertEquals(COOKIE_1_NEW_VALUE, cookiesObject.get(COOKIE_1_NAME));
100         assertEquals(COOKIE_2_VALUE, cookiesObject.get(COOKIE_2_NAME));
101 
102         Map<String, String> unModifiedCookiesObject = (Map<String, String>) CookieHelper.putAndMergeCookie(
103             cookiesObject, (Cookie[]) null);
104         assertSame(cookiesObject, unModifiedCookiesObject);
105         assertEquals(2, cookiesObject.size());
106     }
107 
108     @Test
109     public void testPutAndMergeCookieObjectCookieArray_CookiesInArray_NewCookiesInArray()
110     {
111         Cookie[] cookiesObject = new Cookie[]{new Cookie(null, COOKIE_1_NAME, COOKIE_1_ORIGINAL_VALUE)};
112 
113         assertEquals(1, cookiesObject.length);
114 
115         Cookie[] newCookiesArray = new Cookie[]{new Cookie(null, COOKIE_1_NAME, COOKIE_1_NEW_VALUE),
116             new Cookie(null, COOKIE_2_NAME, COOKIE_2_VALUE)};
117 
118         cookiesObject = (Cookie[]) CookieHelper.putAndMergeCookie(cookiesObject, newCookiesArray);
119 
120         assertEquals(2, cookiesObject.length);
121 
122         assertEquals(COOKIE_1_NAME, cookiesObject[0].getName());
123         assertEquals(COOKIE_1_NEW_VALUE, cookiesObject[0].getValue());
124 
125         assertEquals(COOKIE_2_NAME, cookiesObject[1].getName());
126         assertEquals(COOKIE_2_VALUE, cookiesObject[1].getValue());
127 
128         Cookie[] unModifiedCookiesObject = (Cookie[]) CookieHelper.putAndMergeCookie(cookiesObject,
129             (Cookie[]) null);
130         assertSame(cookiesObject, unModifiedCookiesObject);
131         assertEquals(2, cookiesObject.length);
132     }
133 
134     @Test
135     public void testAsArrayOfCookies_CookiesInArray() throws Exception
136     {
137         Cookie[] cookiesObject = new Cookie[]{new Cookie()};
138         assertSame(cookiesObject, CookieHelper.asArrayOfCookies(cookiesObject));
139 
140         Cookie[] emptyArray = CookieHelper.asArrayOfCookies(null);
141         assertNotNull("A null cookiesObject should return a non null array", emptyArray);
142         assertEquals(0, emptyArray.length);
143     }
144 
145     @Test
146     public void testAsArrayOfCookies_CookiesInMap() throws Exception
147     {
148         Map<String, String> cookiesObject = new LinkedHashMap<String, String>();
149         cookiesObject.put(COOKIE_1_NAME, COOKIE_1_ORIGINAL_VALUE);
150         cookiesObject.put(COOKIE_2_NAME, COOKIE_2_VALUE);
151 
152         Cookie[] cookiesAsArray = CookieHelper.asArrayOfCookies(cookiesObject);
153         assertNotNull("Array of cookies should not be null", cookiesAsArray);
154 
155         assertEquals(2, cookiesAsArray.length);
156 
157         assertEquals(COOKIE_1_NAME, cookiesAsArray[0].getName());
158         assertEquals(COOKIE_1_ORIGINAL_VALUE, cookiesAsArray[0].getValue());
159 
160         assertEquals(COOKIE_2_NAME, cookiesAsArray[1].getName());
161         assertEquals(COOKIE_2_VALUE, cookiesAsArray[1].getValue());
162 
163     }
164 
165     @Test
166     public void testResolveCookieStorageType() throws Exception
167     {
168         assertSame(CookieStorageType.MAP_STRING_STRING,
169             CookieStorageType.resolveCookieStorageType(new HashMap<String, String>()));
170 
171         assertSame(CookieStorageType.ARRAY_OF_COOKIES, CookieStorageType.resolveCookieStorageType(null));
172 
173         assertSame(CookieStorageType.ARRAY_OF_COOKIES,
174             CookieStorageType.resolveCookieStorageType(new Cookie[2]));
175 
176         try
177         {
178             CookieStorageType.resolveCookieStorageType(new Object());
179             fail("It should have thrown an exception since Object it is not a valid type");
180         }
181         catch (IllegalArgumentException e)
182         {
183             assertTrue(e.getMessage().contains("Invalid cookiesObject"));
184         }
185     }
186 
187     @Test
188     public void formattingCookieWithExpiresHeaderShouldPreserveExpireDate() throws Exception
189     {
190         // The expire date, when parsed from the cookie, will have lost the millisecond precision.
191         // Make sure we start with a date that is comparable.
192         long timestampRoundedToSecond = System.currentTimeMillis() / 1000 * 1000;
193         Date expireDate = new Date(timestampRoundedToSecond);
194 
195         Cookie cookie = new Cookie(null, COOKIE_1_NAME, COOKIE_1_ORIGINAL_VALUE, null, expireDate, false);
196         String cookieString = CookieHelper.formatCookieForASetCookieHeader(cookie);
197         assertTrue(cookieString.contains("Expires="));
198 
199         assertExpireDateEquals(expireDate, cookieString);
200     }
201 
202     private void assertExpireDateEquals(Date expireDate, String cookieString) throws MalformedCookieException
203     {
204         Cookie[] cookies = CookieHelper.parseCookiesAsAClient(cookieString, null);
205         assertEquals(1, cookies.length);
206 
207         Date dateFromCookie = cookies[0].getExpiryDate();
208         assertEquals(expireDate, dateFromCookie);
209     }
210 
211     @Test
212     public void formattingCookieWithoutExpiresHeaderShouldNotHaveExpireDateSet() throws Exception
213     {
214         Cookie cookie = new Cookie(null, COOKIE_1_NAME, COOKIE_1_ORIGINAL_VALUE, null, -1, false);
215         String cookieStr = CookieHelper.formatCookieForASetCookieHeader(cookie);
216 
217         Cookie[] cookies = CookieHelper.parseCookiesAsAClient(cookieStr, null);
218         assertNull(cookies[0].getExpiryDate());
219     }
220 }