KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > httpclient > cookie > TestCookieRFC2109Spec


1 /*
2  * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//httpclient/src/test/org/apache/commons/httpclient/cookie/TestCookieRFC2109Spec.java,v 1.3 2004/06/05 16:49:20 olegk Exp $
3  * $Revision: 480424 $
4  * $Date: 2006-11-29 05:56:49 +0000 (Wed, 29 Nov 2006) $
5  * ====================================================================
6  *
7  * Licensed to the Apache Software Foundation (ASF) under one or more
8  * contributor license agreements. See the NOTICE file distributed with
9  * this work for additional information regarding copyright ownership.
10  * The ASF licenses this file to You under the Apache License, Version 2.0
11  * (the "License"); you may not use this file except in compliance with
12  * the License. You may obtain a copy of the License at
13  *
14  * http://www.apache.org/licenses/LICENSE-2.0
15  *
16  * Unless required by applicable law or agreed to in writing, software
17  * distributed under the License is distributed on an "AS IS" BASIS,
18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19  * See the License for the specific language governing permissions and
20  * limitations under the License.
21  * ====================================================================
22  *
23  * This software consists of voluntary contributions made by many
24  * individuals on behalf of the Apache Software Foundation. For more
25  * information on the Apache Software Foundation, please see
26  * <http://www.apache.org/>.
27  *
28  */
29
30 package org.apache.commons.httpclient.cookie;
31
32 import junit.framework.Test;
33 import junit.framework.TestSuite;
34
35 import org.apache.commons.httpclient.Cookie;
36 import org.apache.commons.httpclient.Header;
37 import org.apache.commons.httpclient.NameValuePair;
38
39 /**
40  * Test cases for RFC2109 cookie spec
41  *
42  * @author <a HREF="mailto:oleg@ural.ru">Oleg Kalnichevski</a>
43  *
44  * @version $Revision: 480424 $
45  */
46 public class TestCookieRFC2109Spec extends TestCookieBase {
47
48
49     // ------------------------------------------------------------ Constructor
50
51     public TestCookieRFC2109Spec(String JavaDoc name) {
52         super(name);
53     }
54
55     // ------------------------------------------------------- TestCase Methods
56
57     public static Test suite() {
58         return new TestSuite(TestCookieRFC2109Spec.class);
59     }
60
61     public void testParseAttributeInvalidAttrib() throws Exception JavaDoc {
62         CookieSpec cookiespec = new RFC2109Spec();
63         try {
64             cookiespec.parseAttribute(null, null);
65             fail("IllegalArgumentException must have been thrown");
66         } catch (IllegalArgumentException JavaDoc expected) {
67         }
68     }
69
70     public void testParseAttributeInvalidCookie() throws Exception JavaDoc {
71         CookieSpec cookiespec = new RFC2109Spec();
72         try {
73             cookiespec.parseAttribute(new NameValuePair("name", "value"), null);
74             fail("IllegalArgumentException must have been thrown");
75         } catch (IllegalArgumentException JavaDoc expected) {
76         }
77     }
78
79     public void testParseAttributeNullPath() throws Exception JavaDoc {
80         CookieSpec cookiespec = new RFC2109Spec();
81         try {
82             Cookie cookie = new Cookie();
83             cookiespec.parseAttribute(new NameValuePair("path", null), cookie);
84             fail("MalformedCookieException must have been thrown");
85         } catch (MalformedCookieException expected) {
86         }
87     }
88
89     public void testParseAttributeBlankPath() throws Exception JavaDoc {
90         CookieSpec cookiespec = new RFC2109Spec();
91         try {
92             Cookie cookie = new Cookie();
93             cookiespec.parseAttribute(new NameValuePair("path", " "), cookie);
94             fail("MalformedCookieException must have been thrown");
95         } catch (MalformedCookieException expected) {
96         }
97     }
98
99     public void testParseAttributeNullVersion() throws Exception JavaDoc {
100         CookieSpec cookiespec = new RFC2109Spec();
101         try {
102             Cookie cookie = new Cookie();
103             cookiespec.parseAttribute(new NameValuePair("version", null), cookie);
104             fail("MalformedCookieException must have been thrown");
105         } catch (MalformedCookieException expected) {
106         }
107     }
108
109     public void testParseAttributeInvalidVersion() throws Exception JavaDoc {
110         CookieSpec cookiespec = new RFC2109Spec();
111         try {
112             Cookie cookie = new Cookie();
113             cookiespec.parseAttribute(new NameValuePair("version", "nonsense"), cookie);
114             fail("MalformedCookieException must have been thrown");
115         } catch (MalformedCookieException expected) {
116         }
117     }
118
119     public void testParseVersion() throws Exception JavaDoc {
120         Header header = new Header("Set-Cookie","cookie-name=cookie-value; version=1");
121
122         CookieSpec cookiespec = new RFC2109Spec();
123         Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
124         assertEquals("Found 1 cookie.",1,parsed.length);
125         assertEquals("Name","cookie-name",parsed[0].getName());
126         assertEquals("Value","cookie-value",parsed[0].getValue());
127         assertEquals("Version",1,parsed[0].getVersion());
128     }
129
130     /**
131      * Test domain equals host
132      */
133     public void testParseDomainEqualsHost() throws Exception JavaDoc {
134         Header header = new Header("Set-Cookie",
135             "cookie-name=cookie-value; domain=www.b.com; version=1");
136
137         CookieSpec cookiespec = new RFC2109Spec();
138         Cookie[] parsed = cookieParse(cookiespec, "www.b.com", 80, "/", false, header);
139         assertNotNull(parsed);
140         assertEquals(1, parsed.length);
141         assertEquals("www.b.com", parsed[0].getDomain());
142     }
143
144     /**
145      * Domain does not start with a dot
146      */
147     public void testParseWithIllegalDomain1() throws Exception JavaDoc {
148         Header header = new Header("Set-Cookie",
149             "cookie-name=cookie-value; domain=a.b.com; version=1");
150
151         CookieSpec cookiespec = new RFC2109Spec();
152         try {
153             Cookie[] parsed = cookieParse(cookiespec, "www.a.b.com", 80, "/", false, header);
154             fail("MalformedCookieException should have been thrown");
155         } catch (MalformedCookieException e) {
156             // expected
157 }
158     }
159
160     /**
161      * Domain must have alt least one embedded dot
162      */
163     public void testParseWithIllegalDomain2() throws Exception JavaDoc {
164         Header header = new Header("Set-Cookie",
165             "cookie-name=cookie-value; domain=.com; version=1");
166
167         CookieSpec cookiespec = new RFC2109Spec();
168         try {
169             Cookie[] parsed = cookieParse(cookiespec, "b.com", 80, "/", false, header);
170             fail("MalformedCookieException should have been thrown");
171         } catch (MalformedCookieException e) {
172             // expected
173 }
174     }
175     /**
176      * Domain must have alt least one embedded dot
177      */
178     public void testParseWithIllegalDomain3() throws Exception JavaDoc {
179         Header header = new Header("Set-Cookie",
180             "cookie-name=cookie-value; domain=.com.; version=1");
181
182         CookieSpec cookiespec = new RFC2109Spec();
183         try {
184             Cookie[] parsed = cookieParse(cookiespec, "b.com", 80, "/", false, header);
185             fail("HttpException exception should have been thrown");
186         } catch (MalformedCookieException e) {
187             // expected
188 }
189     }
190
191     /**
192      * Host minus domain may not contain any dots
193      */
194     public void testParseWithIllegalDomain4() throws Exception JavaDoc {
195         Header header = new Header("Set-Cookie",
196             "cookie-name=cookie-value; domain=.c.com; version=1");
197
198         CookieSpec cookiespec = new RFC2109Spec();
199         try {
200             Cookie[] parsed = cookieParse(cookiespec, "a.b.c.com", 80, "/", false, header);
201             fail("MalformedCookieException should have been thrown");
202         } catch (MalformedCookieException e) {
203             // expected
204 }
205     }
206
207     /**
208      * Tests if that invalid second domain level cookie gets
209      * rejected in the strict mode, but gets accepted in the
210      * browser compatibility mode.
211      */
212     public void testSecondDomainLevelCookie() throws Exception JavaDoc {
213         Cookie cookie = new Cookie(".sourceforge.net", "name", null, "/", null, false);
214         cookie.setDomainAttributeSpecified(true);
215         cookie.setPathAttributeSpecified(true);
216
217         CookieSpec cookiespec = new RFC2109Spec();
218         try {
219             cookiespec.validate("sourceforge.net", 80, "/", false, cookie);
220             fail("MalformedCookieException should have been thrown");
221         } catch (MalformedCookieException e) {
222             // Expected
223 }
224     }
225
226     public void testSecondDomainLevelCookieMatch() throws Exception JavaDoc {
227         Cookie cookie = new Cookie(".sourceforge.net", "name", null, "/", null, false);
228         cookie.setDomainAttributeSpecified(true);
229         cookie.setPathAttributeSpecified(true);
230
231         CookieSpec cookiespec = new RFC2109Spec();
232         assertFalse(cookiespec.match("sourceforge.net", 80, "/", false, cookie));
233     }
234     
235     public void testParseWithWrongPath() throws Exception JavaDoc {
236         Header header = new Header("Set-Cookie",
237             "cookie-name=cookie-value; domain=127.0.0.1; path=/not/just/root");
238
239         CookieSpec cookiespec = new RFC2109Spec();
240         try {
241             Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
242             fail("HttpException exception should have been thrown");
243         } catch (MalformedCookieException e) {
244             // expected
245 }
246     }
247
248     /**
249      * Tests if cookie constructor rejects cookie name containing blanks.
250      */
251     public void testCookieNameWithBlanks() throws Exception JavaDoc {
252         Header setcookie = new Header("Set-Cookie", "invalid name=");
253         CookieSpec cookiespec = new RFC2109Spec();
254         try {
255             Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, setcookie);
256             fail("MalformedCookieException exception should have been thrown");
257         } catch (MalformedCookieException e) {
258             // expected
259 }
260     }
261
262
263     /**
264      * Tests if cookie constructor rejects cookie name starting with $.
265      */
266     public void testCookieNameStartingWithDollarSign() throws Exception JavaDoc {
267         Header setcookie = new Header("Set-Cookie", "$invalid_name=");
268         CookieSpec cookiespec = new RFC2109Spec();
269         try {
270             Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, setcookie);
271             fail("MalformedCookieException exception should have been thrown");
272         } catch (MalformedCookieException e) {
273             // expected
274 }
275     }
276
277     /**
278      * Tests if default cookie validator rejects cookies originating from a host without domain
279      * where domain attribute does not match the host of origin
280      */
281     public void testInvalidDomainWithSimpleHostName() throws Exception JavaDoc {
282         CookieSpec cookiespec = new RFC2109Spec();
283         Header header = new Header("Set-Cookie",
284             "name=\"value\"; version=\"1\"; path=\"/\"; domain=\".mydomain.com\"");
285         Cookie[]cookies = cookiespec.parse("host", 80, "/", false, header );
286         try {
287             cookiespec.validate("host", 80, "/", false, cookies[0]);
288             fail("MalformedCookieException must have thrown");
289         }
290         catch(MalformedCookieException expected) {
291         }
292         header = new Header("Set-Cookie",
293             "name=\"value\"; version=\"1\"; path=\"/\"; domain=\"host1\"");
294         cookies = cookiespec.parse("host2", 80, "/", false, header );
295         try {
296             cookiespec.validate("host2", 80, "/", false, cookies[0]);
297             fail("MalformedCookieException must have thrown");
298         }
299         catch(MalformedCookieException expected) {
300         }
301     }
302
303     /**
304      * Tests if cookie values with embedded comma are handled correctly.
305      */
306     public void testCookieWithComma() throws Exception JavaDoc {
307         Header header = new Header("Set-Cookie", "a=b,c");
308
309         CookieSpec cookiespec = new RFC2109Spec();
310         Cookie[] cookies = cookiespec.parse("localhost", 80, "/", false, header);
311         assertEquals("number of cookies", 2, cookies.length);
312         assertEquals("a", cookies[0].getName());
313         assertEquals("b", cookies[0].getValue());
314         assertEquals("c", cookies[1].getName());
315         assertEquals(null, cookies[1].getValue());
316     }
317
318     public void testFormatInvalidCookies() throws Exception JavaDoc {
319         CookieSpec cookiespec = new RFC2109Spec();
320         try {
321             String JavaDoc s = cookiespec.formatCookie(null);
322             fail("IllegalArgumentException nust have been thrown");
323         } catch (IllegalArgumentException JavaDoc expected) {
324         }
325     }
326
327     /**
328      * Tests RFC 2109 compiant cookie formatting.
329      */
330     public void testRFC2109CookieFormatting() throws Exception JavaDoc {
331         CookieSpec cookiespec = new RFC2109Spec();
332         Header header = new Header("Set-Cookie",
333             "name=\"value\"; version=\"1\"; path=\"/\"; domain=\".mydomain.com\"");
334         Cookie[] cookies = cookiespec.parse("myhost.mydomain.com", 80, "/", false, header );
335         cookiespec.validate("myhost.mydomain.com", 80, "/", false, cookies[0]);
336         String JavaDoc s1 = cookiespec.formatCookie(cookies[0]);
337         assertEquals(s1, "$Version=\"1\"; name=\"value\"; $Path=\"/\"; $Domain=\".mydomain.com\"");
338
339         header = new Header( "Set-Cookie",
340             "name=value; path=/; domain=.mydomain.com");
341         cookies = cookiespec.parse("myhost.mydomain.com", 80, "/", false, header );
342         cookiespec.validate("myhost.mydomain.com", 80, "/", false, cookies[0]);
343         String JavaDoc s2 = cookiespec.formatCookie(cookies[0]);
344         assertEquals(s2, "$Version=0; name=value; $Path=/; $Domain=.mydomain.com");
345     }
346
347     public void testRFC2109CookiesFormatting() throws Exception JavaDoc {
348         CookieSpec cookiespec = new RFC2109Spec();
349         Header header = new Header("Set-Cookie",
350             "name1=value1; path=/; domain=.mydomain.com, " +
351             "name2=\"value2\"; version=\"1\"; path=\"/\"; domain=\".mydomain.com\"");
352         Cookie[] cookies = cookieParse(cookiespec, "myhost.mydomain.com", 80, "/", false, header);
353         assertNotNull(cookies);
354         assertEquals(2, cookies.length);
355         String JavaDoc s1 = cookiespec.formatCookies(cookies);
356         assertEquals(s1,
357             "$Version=0; name1=value1; $Path=/; $Domain=.mydomain.com; " +
358             "name2=value2; $Path=/; $Domain=.mydomain.com");
359
360         header = new Header("Set-Cookie",
361             "name1=value1; version=1; path=/; domain=.mydomain.com, " +
362             "name2=\"value2\"; version=\"1\"; path=\"/\"; domain=\".mydomain.com\"");
363         cookies = cookieParse(cookiespec, "myhost.mydomain.com", 80, "/", false, header);
364         assertNotNull(cookies);
365         assertEquals(2, cookies.length);
366         String JavaDoc s2 = cookiespec.formatCookies(cookies);
367         assertEquals(s2,
368             "$Version=\"1\"; name1=\"value1\"; $Path=\"/\"; $Domain=\".mydomain.com\"; " +
369             "name2=\"value2\"; $Path=\"/\"; $Domain=\".mydomain.com\"");
370     }
371     
372     /**
373      * Tests if null cookie values are handled correctly.
374      */
375     public void testNullCookieValueFormatting() {
376         Cookie cookie = new Cookie(".whatever.com", "name", null, "/", null, false);
377         cookie.setDomainAttributeSpecified(true);
378         cookie.setPathAttributeSpecified(true);
379
380         CookieSpec cookiespec = new RFC2109Spec();
381         String JavaDoc s = cookiespec.formatCookie(cookie);
382         assertEquals("$Version=0; name=; $Path=/; $Domain=.whatever.com", s);
383
384         cookie.setVersion(1);
385         s = cookiespec.formatCookie(cookie);
386         assertEquals("$Version=\"1\"; name=\"\"; $Path=\"/\"; $Domain=\".whatever.com\"", s);
387     }
388
389     public void testCookieNullDomainNullPathFormatting() {
390         Cookie cookie = new Cookie(null, "name", null, "/", null, false);
391         cookie.setDomainAttributeSpecified(true);
392         cookie.setPathAttributeSpecified(true);
393
394         CookieSpec cookiespec = new RFC2109Spec();
395         String JavaDoc s = cookiespec.formatCookie(cookie);
396         assertEquals("$Version=0; name=; $Path=/", s);
397
398         cookie.setDomainAttributeSpecified(false);
399         cookie.setPathAttributeSpecified(false);
400         s = cookiespec.formatCookie(cookie);
401         assertEquals("$Version=0; name=", s);
402     }
403
404 }
405
406
Popular Tags