?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This commit was manufactured by cvs2svn to create tag 'r241c1'.
[python/dscho.git] / Lib / test / test_cookielib.py
blob78283262506f8317703d1c17ea548199c56a7f78
1 # -*- coding: utf-8 -*-
2 """Tests for cookielib.py."""
3
4 import re, os, time
5 from unittest import TestCase
6
7 from test import test_support
8
9 class DateTimeTests(TestCase):
10
11 def test_time2isoz(self):
12 from cookielib import time2isoz
13
14 base = 1019227000
15 day = 24*3600
16 self.assertEquals(time2isoz(base), "2002-04-19 14:36:40Z")
17 self.assertEquals(time2isoz(base+day), "2002-04-20 14:36:40Z")
18 self.assertEquals(time2isoz(base+2*day), "2002-04-21 14:36:40Z")
19 self.assertEquals(time2isoz(base+3*day), "2002-04-22 14:36:40Z")
20
21 az = time2isoz()
22 bz = time2isoz(500000)
23 for text in (az, bz):
24 self.assert_(re.search(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\dZ$", text),
25 "bad time2isoz format: %s %s" % (az, bz))
26
27 def test_http2time(self):
28 from cookielib import http2time
29
30 def parse_date(text):
31 return time.gmtime(http2time(text))[:6]
32
33 self.assertEquals(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0))
34
35 # this test will break around year 2070
36 self.assertEquals(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0))
37
38 # this test will break around year 2048
39 self.assertEquals(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0))
40
41 def test_http2time_formats(self):
42 from cookielib import http2time, time2isoz
43
44 # test http2time for supported dates. Test cases with 2 digit year
45 # will probably break in year 2044.
46 tests = [
47 'Thu, 03 Feb 1994 00:00:00 GMT', # proposed new HTTP format
48 'Thursday, 03-Feb-94 00:00:00 GMT', # old rfc850 HTTP format
49 'Thursday, 03-Feb-1994 00:00:00 GMT', # broken rfc850 HTTP format
50
51 '03 Feb 1994 00:00:00 GMT', # HTTP format (no weekday)
52 '03-Feb-94 00:00:00 GMT', # old rfc850 (no weekday)
53 '03-Feb-1994 00:00:00 GMT', # broken rfc850 (no weekday)
54 '03-Feb-1994 00:00 GMT', # broken rfc850 (no weekday, no seconds)
55 '03-Feb-1994 00:00', # broken rfc850 (no weekday, no seconds, no tz)
56
57 '03-Feb-94', # old rfc850 HTTP format (no weekday, no time)
58 '03-Feb-1994', # broken rfc850 HTTP format (no weekday, no time)
59 '03 Feb 1994', # proposed new HTTP format (no weekday, no time)
60
61 # A few tests with extra space at various places
62 ' 03 Feb 1994 0:00 ',
63 ' 03-Feb-1994 ',
64 ]
65
66 test_t = 760233600 # assume broken POSIX counting of seconds
67 result = time2isoz(test_t)
68 expected = "1994-02-03 00:00:00Z"
69 self.assertEquals(result, expected,
70 "%s => '%s' (%s)" % (test_t, result, expected))
71
72 for s in tests:
73 t = http2time(s)
74 t2 = http2time(s.lower())
75 t3 = http2time(s.upper())
76
77 self.assert_(t == t2 == t3 == test_t,
78 "'%s' => %s, %s, %s (%s)" % (s, t, t2, t3, test_t))
79
80 def test_http2time_garbage(self):
81 from cookielib import http2time
82
83 for test in [
84 '',
85 'Garbage',
86 'Mandag 16. September 1996',
87 '01-00-1980',
88 '01-13-1980',
89 '00-01-1980',
90 '32-01-1980',
91 '01-01-1980 25:00:00',
92 '01-01-1980 00:61:00',
93 '01-01-1980 00:00:62',
94 ]:
95 self.assert_(http2time(test) is None,
96 "http2time(%s) is not None\n"
97 "http2time(test) %s" % (test, http2time(test))
98 )
99
100
101 class HeaderTests(TestCase):
102 def test_parse_ns_headers(self):
103 from cookielib import parse_ns_headers
104
105 # quotes should be stripped
106 expected = [[('foo', 'bar'), ('expires', 2209069412L), ('version', '0')]]
107 for hdr in [
108 'foo=bar; expires=01 Jan 2040 22:23:32 GMT',
109 'foo=bar; expires="01 Jan 2040 22:23:32 GMT"',
110 ]:
111 self.assertEquals(parse_ns_headers([hdr]), expected)
112
113 def test_parse_ns_headers_special_names(self):
114 # names such as 'expires' are not special in first name=value pair
115 # of Set-Cookie: header
116 from cookielib import parse_ns_headers
117
118 # Cookie with name 'expires'
119 hdr = 'expires=01 Jan 2040 22:23:32 GMT'
120 expected = [[("expires", "01 Jan 2040 22:23:32 GMT"), ("version", "0")]]
121 self.assertEquals(parse_ns_headers([hdr]), expected)
122
123 def test_join_header_words(self):
124 from cookielib import join_header_words
125
126 joined = join_header_words([[("foo", None), ("bar", "baz")]])
127 self.assertEquals(joined, "foo; bar=baz")
128
129 self.assertEquals(join_header_words([[]]), "")
130
131 def test_split_header_words(self):
132 from cookielib import split_header_words
133
134 tests = [
135 ("foo", [[("foo", None)]]),
136 ("foo=bar", [[("foo", "bar")]]),
137 (" foo ", [[("foo", None)]]),
138 (" foo= ", [[("foo", "")]]),
139 (" foo=", [[("foo", "")]]),
140 (" foo= ; ", [[("foo", "")]]),
141 (" foo= ; bar= baz ", [[("foo", ""), ("bar", "baz")]]),
142 ("foo=bar bar=baz", [[("foo", "bar"), ("bar", "baz")]]),
143 # doesn't really matter if this next fails, but it works ATM
144 ("foo= bar=baz", [[("foo", "bar=baz")]]),
145 ("foo=bar;bar=baz", [[("foo", "bar"), ("bar", "baz")]]),
146 ('foo bar baz', [[("foo", None), ("bar", None), ("baz", None)]]),
147 ("a, b, c", [[("a", None)], [("b", None)], [("c", None)]]),
148 (r'foo; bar=baz, spam=, foo="\,\;\"", bar= ',
149 [[("foo", None), ("bar", "baz")],
150 [("spam", "")], [("foo", ',;"')], [("bar", "")]]),
151 ]
152
153 for arg, expect in tests:
154 try:
155 result = split_header_words([arg])
156 except:
157 import traceback, StringIO
158 f = StringIO.StringIO()
159 traceback.print_exc(None, f)
160 result = "(error -- traceback follows)\n\n%s" % f.getvalue()
161 self.assertEquals(result, expect, """
162 When parsing: '%s'
163 Expected: '%s'
164 Got: '%s'
165 """ % (arg, expect, result))
166
167 def test_roundtrip(self):
168 from cookielib import split_header_words, join_header_words
169
170 tests = [
171 ("foo", "foo"),
172 ("foo=bar", "foo=bar"),
173 (" foo ", "foo"),
174 ("foo=", 'foo=""'),
175 ("foo=bar bar=baz", "foo=bar; bar=baz"),
176 ("foo=bar;bar=baz", "foo=bar; bar=baz"),
177 ('foo bar baz', "foo; bar; baz"),
178 (r'foo="\"" bar="\\"', r'foo="\""; bar="\\"'),
179 ('foo,,,bar', 'foo, bar'),
180 ('foo=bar,bar=baz', 'foo=bar, bar=baz'),
181
182 ('text/html; charset=iso-8859-1',
183 'text/html; charset="iso-8859-1"'),
184
185 ('foo="bar"; port="80,81"; discard, bar=baz',
186 'foo=bar; port="80,81"; discard, bar=baz'),
187
188 (r'Basic realm="\"foo\\\\bar\""',
189 r'Basic; realm="\"foo\\\\bar\""')
190 ]
191
192 for arg, expect in tests:
193 input = split_header_words([arg])
194 res = join_header_words(input)
195 self.assertEquals(res, expect, """
196 When parsing: '%s'
197 Expected: '%s'
198 Got: '%s'
199 Input was: '%s'
200 """ % (arg, expect, res, input))
201
202
203 class FakeResponse:
204 def __init__(self, headers=[], url=None):
205 """
206 headers: list of RFC822-style 'Key: value' strings
207 """
208 import mimetools, StringIO
209 f = StringIO.StringIO("\n".join(headers))
210 self._headers = mimetools.Message(f)
211 self._url = url
212 def info(self): return self._headers
213
214 def interact_2965(cookiejar, url, *set_cookie_hdrs):
215 return _interact(cookiejar, url, set_cookie_hdrs, "Set-Cookie2")
216
217 def interact_netscape(cookiejar, url, *set_cookie_hdrs):
218 return _interact(cookiejar, url, set_cookie_hdrs, "Set-Cookie")
219
220 def _interact(cookiejar, url, set_cookie_hdrs, hdr_name):
221 """Perform a single request / response cycle, returning Cookie: header."""
222 from urllib2 import Request
223 req = Request(url)
224 cookiejar.add_cookie_header(req)
225 cookie_hdr = req.get_header("Cookie", "")
226 headers = []
227 for hdr in set_cookie_hdrs:
228 headers.append("%s: %s" % (hdr_name, hdr))
229 res = FakeResponse(headers, url)
230 cookiejar.extract_cookies(res, req)
231 return cookie_hdr
232
233
234 class FileCookieJarTests(TestCase):
235 def test_lwp_valueless_cookie(self):
236 # cookies with no value should be saved and loaded consistently
237 from cookielib import LWPCookieJar
238 filename = test_support.TESTFN
239 c = LWPCookieJar()
240 interact_netscape(c, "http://www.acme.com/", 'boo')
241 self.assertEqual(c._cookies["www.acme.com"]["/"]["boo"].value, None)
242 try:
243 c.save(filename, ignore_discard=True)
244 c = LWPCookieJar()
245 c.load(filename, ignore_discard=True)
246 finally:
247 try: os.unlink(filename)
248 except OSError: pass
249 self.assertEqual(c._cookies["www.acme.com"]["/"]["boo"].value, None)
250
251
252 class CookieTests(TestCase):
253 # XXX
254 # Get rid of string comparisons where not actually testing str / repr.
255 # .clear() etc.
256 # IP addresses like 50 (single number, no dot) and domain-matching
257 # functions (and is_HDN)? See draft RFC 2965 errata.
258 # Strictness switches
259 # is_third_party()
260 # unverifiability / third-party blocking
261 # Netscape cookies work the same as RFC 2965 with regard to port.
262 # Set-Cookie with negative max age.
263 # If turn RFC 2965 handling off, Set-Cookie2 cookies should not clobber
264 # Set-Cookie cookies.
265 # Cookie2 should be sent if *any* cookies are not V1 (ie. V0 OR V2 etc.).
266 # Cookies (V1 and V0) with no expiry date should be set to be discarded.
267 # RFC 2965 Quoting:
268 # Should accept unquoted cookie-attribute values? check errata draft.
269 # Which are required on the way in and out?
270 # Should always return quoted cookie-attribute values?
271 # Proper testing of when RFC 2965 clobbers Netscape (waiting for errata).
272 # Path-match on return (same for V0 and V1).
273 # RFC 2965 acceptance and returning rules
274 # Set-Cookie2 without version attribute is rejected.
275
276 # Netscape peculiarities list from Ronald Tschalar.
277 # The first two still need tests, the rest are covered.
278 ## - Quoting: only quotes around the expires value are recognized as such
279 ## (and yes, some folks quote the expires value); quotes around any other
280 ## value are treated as part of the value.
281 ## - White space: white space around names and values is ignored
282 ## - Default path: if no path parameter is given, the path defaults to the
283 ## path in the request-uri up to, but not including, the last '/'. Note
284 ## that this is entirely different from what the spec says.
285 ## - Commas and other delimiters: Netscape just parses until the next ';'.
286 ## This means it will allow commas etc inside values (and yes, both
287 ## commas and equals are commonly appear in the cookie value). This also
288 ## means that if you fold multiple Set-Cookie header fields into one,
289 ## comma-separated list, it'll be a headache to parse (at least my head
290 ## starts hurting everytime I think of that code).
291 ## - Expires: You'll get all sorts of date formats in the expires,
292 ## including emtpy expires attributes ("expires="). Be as flexible as you
293 ## can, and certainly don't expect the weekday to be there; if you can't
294 ## parse it, just ignore it and pretend it's a session cookie.
295 ## - Domain-matching: Netscape uses the 2-dot rule for _all_ domains, not
296 ## just the 7 special TLD's listed in their spec. And folks rely on
297 ## that...
298
299 def test_domain_return_ok(self):
300 # test optimization: .domain_return_ok() should filter out most
301 # domains in the CookieJar before we try to access them (because that
302 # may require disk access -- in particular, with MSIECookieJar)
303 # This is only a rough check for performance reasons, so it's not too
304 # critical as long as it's sufficiently liberal.
305 import cookielib, urllib2
306 pol = cookielib.DefaultCookiePolicy()
307 for url, domain, ok in [
308 ("http://foo.bar.com/", "blah.com", False),
309 ("http://foo.bar.com/", "rhubarb.blah.com", False),
310 ("http://foo.bar.com/", "rhubarb.foo.bar.com", False),
311 ("http://foo.bar.com/", ".foo.bar.com", True),
312 ("http://foo.bar.com/", "foo.bar.com", True),
313 ("http://foo.bar.com/", ".bar.com", True),
314 ("http://foo.bar.com/", "com", True),
315 ("http://foo.com/", "rhubarb.foo.com", False),
316 ("http://foo.com/", ".foo.com", True),
317 ("http://foo.com/", "foo.com", True),
318 ("http://foo.com/", "com", True),
319 ("http://foo/", "rhubarb.foo", False),
320 ("http://foo/", ".foo", True),
321 ("http://foo/", "foo", True),
322 ("http://foo/", "foo.local", True),
323 ("http://foo/", ".local", True),
324 ]:
325 request = urllib2.Request(url)
326 r = pol.domain_return_ok(domain, request)
327 if ok: self.assert_(r)
328 else: self.assert_(not r)
329
330 def test_missing_value(self):
331 from cookielib import MozillaCookieJar, lwp_cookie_str
332
333 # missing = sign in Cookie: header is regarded by Mozilla as a missing
334 # name, and by cookielib as a missing value
335 filename = test_support.TESTFN
336 c = MozillaCookieJar(filename)
337 interact_netscape(c, "http://www.acme.com/", 'eggs')
338 interact_netscape(c, "http://www.acme.com/", '"spam"; path=/foo/')
339 cookie = c._cookies["www.acme.com"]["/"]["eggs"]
340 self.assert_(cookie.value is None)
341 self.assertEquals(cookie.name, "eggs")
342 cookie = c._cookies["www.acme.com"]['/foo/']['"spam"']
343 self.assert_(cookie.value is None)
344 self.assertEquals(cookie.name, '"spam"')
345 self.assertEquals(lwp_cookie_str(cookie), (
346 r'"spam"; path="/foo/"; domain="www.acme.com"; '
347 'path_spec; discard; version=0'))
348 old_str = repr(c)
349 c.save(ignore_expires=True, ignore_discard=True)
350 try:
351 c = MozillaCookieJar(filename)
352 c.revert(ignore_expires=True, ignore_discard=True)
353 finally:
354 os.unlink(c.filename)
355 # cookies unchanged apart from lost info re. whether path was specified
356 self.assertEquals(
357 repr(c),
358 re.sub("path_specified=%s" % True, "path_specified=%s" % False,
359 old_str)
360 )
361 self.assertEquals(interact_netscape(c, "http://www.acme.com/foo/"),
362 '"spam"; eggs')
363
364 def test_ns_parser(self):
365 from cookielib import CookieJar, DEFAULT_HTTP_PORT
366
367 c = CookieJar()
368 interact_netscape(c, "http://www.acme.com/",
369 'spam=eggs; DoMain=.acme.com; port; blArgh="feep"')
370 interact_netscape(c, "http://www.acme.com/", 'ni=ni; port=80,8080')
371 interact_netscape(c, "http://www.acme.com:80/", 'nini=ni')
372 interact_netscape(c, "http://www.acme.com:80/", 'foo=bar; expires=')
373 interact_netscape(c, "http://www.acme.com:80/", 'spam=eggs; '
374 'expires="Foo Bar 25 33:22:11 3022"')
375
376 cookie = c._cookies[".acme.com"]["/"]["spam"]
377 self.assertEquals(cookie.domain, ".acme.com")
378 self.assert_(cookie.domain_specified)
379 self.assertEquals(cookie.port, DEFAULT_HTTP_PORT)
380 self.assert_(not cookie.port_specified)
381 # case is preserved
382 self.assert_(cookie.has_nonstandard_attr("blArgh") and
383 not cookie.has_nonstandard_attr("blargh"))
384
385 cookie = c._cookies["www.acme.com"]["/"]["ni"]
386 self.assertEquals(cookie.domain, "www.acme.com")
387 self.assert_(not cookie.domain_specified)
388 self.assertEquals(cookie.port, "80,8080")
389 self.assert_(cookie.port_specified)
390
391 cookie = c._cookies["www.acme.com"]["/"]["nini"]
392 self.assert_(cookie.port is None)
393 self.assert_(not cookie.port_specified)
394
395 # invalid expires should not cause cookie to be dropped
396 foo = c._cookies["www.acme.com"]["/"]["foo"]
397 spam = c._cookies["www.acme.com"]["/"]["foo"]
398 self.assert_(foo.expires is None)
399 self.assert_(spam.expires is None)
400
401 def test_ns_parser_special_names(self):
402 # names such as 'expires' are not special in first name=value pair
403 # of Set-Cookie: header
404 from cookielib import CookieJar
405
406 c = CookieJar()
407 interact_netscape(c, "http://www.acme.com/", 'expires=eggs')
408 interact_netscape(c, "http://www.acme.com/", 'version=eggs; spam=eggs')
409
410 cookies = c._cookies["www.acme.com"]["/"]
411 self.assert_('expires' in cookies)
412 self.assert_('version' in cookies)
413
414 def test_expires(self):
415 from cookielib import time2netscape, CookieJar
416
417 # if expires is in future, keep cookie...
418 c = CookieJar()
419 future = time2netscape(time.time()+3600)
420 interact_netscape(c, "http://www.acme.com/", 'spam="bar"; expires=%s' %
421 future)
422 self.assertEquals(len(c), 1)
423 now = time2netscape(time.time()-1)
424 # ... and if in past or present, discard it
425 interact_netscape(c, "http://www.acme.com/", 'foo="eggs"; expires=%s' %
426 now)
427 h = interact_netscape(c, "http://www.acme.com/")
428 self.assertEquals(len(c), 1)
429 self.assert_('spam="bar"' in h and "foo" not in h)
430
431 # max-age takes precedence over expires, and zero max-age is request to
432 # delete both new cookie and any old matching cookie
433 interact_netscape(c, "http://www.acme.com/", 'eggs="bar"; expires=%s' %
434 future)
435 interact_netscape(c, "http://www.acme.com/", 'bar="bar"; expires=%s' %
436 future)
437 self.assertEquals(len(c), 3)
438 interact_netscape(c, "http://www.acme.com/", 'eggs="bar"; '
439 'expires=%s; max-age=0' % future)
440 interact_netscape(c, "http://www.acme.com/", 'bar="bar"; '
441 'max-age=0; expires=%s' % future)
442 h = interact_netscape(c, "http://www.acme.com/")
443 self.assertEquals(len(c), 1)
444
445 # test expiry at end of session for cookies with no expires attribute
446 interact_netscape(c, "http://www.rhubarb.net/", 'whum="fizz"')
447 self.assertEquals(len(c), 2)
448 c.clear_session_cookies()
449 self.assertEquals(len(c), 1)
450 self.assert_('spam="bar"' in h)
451
452 # XXX RFC 2965 expiry rules (some apply to V0 too)
453
454 def test_default_path(self):
455 from cookielib import CookieJar, DefaultCookiePolicy
456
457 # RFC 2965
458 pol = DefaultCookiePolicy(rfc2965=True)
459
460 c = CookieJar(pol)
461 interact_2965(c, "http://www.acme.com/", 'spam="bar"; Version="1"')
462 self.assert_("/" in c._cookies["www.acme.com"])
463
464 c = CookieJar(pol)
465 interact_2965(c, "http://www.acme.com/blah", 'eggs="bar"; Version="1"')
466 self.assert_("/" in c._cookies["www.acme.com"])
467
468 c = CookieJar(pol)
469 interact_2965(c, "http://www.acme.com/blah/rhubarb",
470 'eggs="bar"; Version="1"')
471 self.assert_("/blah/" in c._cookies["www.acme.com"])
472
473 c = CookieJar(pol)
474 interact_2965(c, "http://www.acme.com/blah/rhubarb/",
475 'eggs="bar"; Version="1"')
476 self.assert_("/blah/rhubarb/" in c._cookies["www.acme.com"])
477
478 # Netscape
479
480 c = CookieJar()
481 interact_netscape(c, "http://www.acme.com/", 'spam="bar"')
482 self.assert_("/" in c._cookies["www.acme.com"])
483
484 c = CookieJar()
485 interact_netscape(c, "http://www.acme.com/blah", 'eggs="bar"')
486 self.assert_("/" in c._cookies["www.acme.com"])
487
488 c = CookieJar()
489 interact_netscape(c, "http://www.acme.com/blah/rhubarb", 'eggs="bar"')
490 self.assert_("/blah" in c._cookies["www.acme.com"])
491
492 c = CookieJar()
493 interact_netscape(c, "http://www.acme.com/blah/rhubarb/", 'eggs="bar"')
494 self.assert_("/blah/rhubarb" in c._cookies["www.acme.com"])
495
496 def test_escape_path(self):
497 from cookielib import escape_path
498 cases = [
499 # quoted safe
500 ("/foo%2f/bar", "/foo%2F/bar"),
501 ("/foo%2F/bar", "/foo%2F/bar"),
502 # quoted %
503 ("/foo%%/bar", "/foo%%/bar"),
504 # quoted unsafe
505 ("/fo%19o/bar", "/fo%19o/bar"),
506 ("/fo%7do/bar", "/fo%7Do/bar"),
507 # unquoted safe
508 ("/foo/bar&", "/foo/bar&"),
509 ("/foo//bar", "/foo//bar"),
510 ("\176/foo/bar", "\176/foo/bar"),
511 # unquoted unsafe
512 ("/foo\031/bar", "/foo%19/bar"),
513 ("/\175foo/bar", "/%7Dfoo/bar"),
514 # unicode
515 (u"/foo/bar\uabcd", "/foo/bar%EA%AF%8D"), # UTF-8 encoded
516 ]
517 for arg, result in cases:
518 self.assertEquals(escape_path(arg), result)
519
520 def test_request_path(self):
521 from urllib2 import Request
522 from cookielib import request_path
523 # with parameters
524 req = Request("http://www.example.com/rheum/rhaponicum;"
525 "foo=bar;sing=song?apples=pears&spam=eggs#ni")
526 self.assertEquals(request_path(req), "/rheum/rhaponicum;"
527 "foo=bar;sing=song?apples=pears&spam=eggs#ni")
528 # without parameters
529 req = Request("http://www.example.com/rheum/rhaponicum?"
530 "apples=pears&spam=eggs#ni")
531 self.assertEquals(request_path(req), "/rheum/rhaponicum?"
532 "apples=pears&spam=eggs#ni")
533 # missing final slash
534 req = Request("http://www.example.com")
535 self.assertEquals(request_path(req), "/")
536
537 def test_request_port(self):
538 from urllib2 import Request
539 from cookielib import request_port, DEFAULT_HTTP_PORT
540 req = Request("http://www.acme.com:1234/",
541 headers={"Host": "www.acme.com:4321"})
542 self.assertEquals(request_port(req), "1234")
543 req = Request("http://www.acme.com/",
544 headers={"Host": "www.acme.com:4321"})
545 self.assertEquals(request_port(req), DEFAULT_HTTP_PORT)
546
547 def test_request_host(self):
548 from urllib2 import Request
549 from cookielib import request_host
550 # this request is illegal (RFC2616, 14.2.3)
551 req = Request("http://1.1.1.1/",
552 headers={"Host": "www.acme.com:80"})
553 # libwww-perl wants this response, but that seems wrong (RFC 2616,
554 # section 5.2, point 1., and RFC 2965 section 1, paragraph 3)
555 #self.assertEquals(request_host(req), "www.acme.com")
556 self.assertEquals(request_host(req), "1.1.1.1")
557 req = Request("http://www.acme.com/",
558 headers={"Host": "irrelevant.com"})
559 self.assertEquals(request_host(req), "www.acme.com")
560 # not actually sure this one is valid Request object, so maybe should
561 # remove test for no host in url in request_host function?
562 req = Request("/resource.html",
563 headers={"Host": "www.acme.com"})
564 self.assertEquals(request_host(req), "www.acme.com")
565 # port shouldn't be in request-host
566 req = Request("http://www.acme.com:2345/resource.html",
567 headers={"Host": "www.acme.com:5432"})
568 self.assertEquals(request_host(req), "www.acme.com")
569
570 def test_is_HDN(self):
571 from cookielib import is_HDN
572 self.assert_(is_HDN("foo.bar.com"))
573 self.assert_(is_HDN("1foo2.3bar4.5com"))
574 self.assert_(not is_HDN("192.168.1.1"))
575 self.assert_(not is_HDN(""))
576 self.assert_(not is_HDN("."))
577 self.assert_(not is_HDN(".foo.bar.com"))
578 self.assert_(not is_HDN("..foo"))
579 self.assert_(not is_HDN("foo."))
580
581 def test_reach(self):
582 from cookielib import reach
583 self.assertEquals(reach("www.acme.com"), ".acme.com")
584 self.assertEquals(reach("acme.com"), "acme.com")
585 self.assertEquals(reach("acme.local"), ".local")
586 self.assertEquals(reach(".local"), ".local")
587 self.assertEquals(reach(".com"), ".com")
588 self.assertEquals(reach("."), ".")
589 self.assertEquals(reach(""), "")
590 self.assertEquals(reach("192.168.0.1"), "192.168.0.1")
591
592 def test_domain_match(self):
593 from cookielib import domain_match, user_domain_match
594 self.assert_(domain_match("192.168.1.1", "192.168.1.1"))
595 self.assert_(not domain_match("192.168.1.1", ".168.1.1"))
596 self.assert_(domain_match("x.y.com", "x.Y.com"))
597 self.assert_(domain_match("x.y.com", ".Y.com"))
598 self.assert_(not domain_match("x.y.com", "Y.com"))
599 self.assert_(domain_match("a.b.c.com", ".c.com"))
600 self.assert_(not domain_match(".c.com", "a.b.c.com"))
601 self.assert_(domain_match("example.local", ".local"))
602 self.assert_(not domain_match("blah.blah", ""))
603 self.assert_(not domain_match("", ".rhubarb.rhubarb"))
604 self.assert_(domain_match("", ""))
605
606 self.assert_(user_domain_match("acme.com", "acme.com"))
607 self.assert_(not user_domain_match("acme.com", ".acme.com"))
608 self.assert_(user_domain_match("rhubarb.acme.com", ".acme.com"))
609 self.assert_(user_domain_match("www.rhubarb.acme.com", ".acme.com"))
610 self.assert_(user_domain_match("x.y.com", "x.Y.com"))
611 self.assert_(user_domain_match("x.y.com", ".Y.com"))
612 self.assert_(not user_domain_match("x.y.com", "Y.com"))
613 self.assert_(user_domain_match("y.com", "Y.com"))
614 self.assert_(not user_domain_match(".y.com", "Y.com"))
615 self.assert_(user_domain_match(".y.com", ".Y.com"))
616 self.assert_(user_domain_match("x.y.com", ".com"))
617 self.assert_(not user_domain_match("x.y.com", "com"))
618 self.assert_(not user_domain_match("x.y.com", "m"))
619 self.assert_(not user_domain_match("x.y.com", ".m"))
620 self.assert_(not user_domain_match("x.y.com", ""))
621 self.assert_(not user_domain_match("x.y.com", "."))
622 self.assert_(user_domain_match("192.168.1.1", "192.168.1.1"))
623 # not both HDNs, so must string-compare equal to match
624 self.assert_(not user_domain_match("192.168.1.1", ".168.1.1"))
625 self.assert_(not user_domain_match("192.168.1.1", "."))
626 # empty string is a special case
627 self.assert_(not user_domain_match("192.168.1.1", ""))
628
629 def test_wrong_domain(self):
630 # Cookies whose effective request-host name does not domain-match the
631 # domain are rejected.
632
633 # XXX far from complete
634 from cookielib import CookieJar
635 c = CookieJar()
636 interact_2965(c, "http://www.nasty.com/",
637 'foo=bar; domain=friendly.org; Version="1"')
638 self.assertEquals(len(c), 0)
639
640 def test_two_component_domain_ns(self):
641 # Netscape: .www.bar.com, www.bar.com, .bar.com, bar.com, no domain
642 # should all get accepted, as should .acme.com, acme.com and no domain
643 # for 2-component domains like acme.com.
644 from cookielib import CookieJar, DefaultCookiePolicy
645
646 c = CookieJar()
647
648 # two-component V0 domain is OK
649 interact_netscape(c, "http://foo.net/", 'ns=bar')
650 self.assertEquals(len(c), 1)
651 self.assertEquals(c._cookies["foo.net"]["/"]["ns"].value, "bar")
652 self.assertEquals(interact_netscape(c, "http://foo.net/"), "ns=bar")
653 # *will* be returned to any other domain (unlike RFC 2965)...
654 self.assertEquals(interact_netscape(c, "http://www.foo.net/"),
655 "ns=bar")
656 # ...unless requested otherwise
657 pol = DefaultCookiePolicy(
658 strict_ns_domain=DefaultCookiePolicy.DomainStrictNonDomain)
659 c.set_policy(pol)
660 self.assertEquals(interact_netscape(c, "http://www.foo.net/"), "")
661
662 # unlike RFC 2965, even explicit two-component domain is OK,
663 # because .foo.net matches foo.net
664 interact_netscape(c, "http://foo.net/foo/",
665 'spam1=eggs; domain=foo.net')
666 # even if starts with a dot -- in NS rules, .foo.net matches foo.net!
667 interact_netscape(c, "http://foo.net/foo/bar/",
668 'spam2=eggs; domain=.foo.net')
669 self.assertEquals(len(c), 3)
670 self.assertEquals(c._cookies[".foo.net"]["/foo"]["spam1"].value,
671 "eggs")
672 self.assertEquals(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value,
673 "eggs")
674 self.assertEquals(interact_netscape(c, "http://foo.net/foo/bar/"),
675 "spam2=eggs; spam1=eggs; ns=bar")
676
677 # top-level domain is too general
678 interact_netscape(c, "http://foo.net/", 'nini="ni"; domain=.net')
679 self.assertEquals(len(c), 3)
680
681 ## # Netscape protocol doesn't allow non-special top level domains (such
682 ## # as co.uk) in the domain attribute unless there are at least three
683 ## # dots in it.
684 # Oh yes it does! Real implementations don't check this, and real
685 # cookies (of course) rely on that behaviour.
686 interact_netscape(c, "http://foo.co.uk", 'nasty=trick; domain=.co.uk')
687 ## self.assertEquals(len(c), 2)
688 self.assertEquals(len(c), 4)
689
690 def test_two_component_domain_rfc2965(self):
691 from cookielib import CookieJar, DefaultCookiePolicy
692
693 pol = DefaultCookiePolicy(rfc2965=True)
694 c = CookieJar(pol)
695
696 # two-component V1 domain is OK
697 interact_2965(c, "http://foo.net/", 'foo=bar; Version="1"')
698 self.assertEquals(len(c), 1)
699 self.assertEquals(c._cookies["foo.net"]["/"]["foo"].value, "bar")
700 self.assertEquals(interact_2965(c, "http://foo.net/"),
701 "$Version=1; foo=bar")
702 # won't be returned to any other domain (because domain was implied)
703 self.assertEquals(interact_2965(c, "http://www.foo.net/"), "")
704
705 # unless domain is given explicitly, because then it must be
706 # rewritten to start with a dot: foo.net --> .foo.net, which does
707 # not domain-match foo.net
708 interact_2965(c, "http://foo.net/foo",
709 'spam=eggs; domain=foo.net; path=/foo; Version="1"')
710 self.assertEquals(len(c), 1)
711 self.assertEquals(interact_2965(c, "http://foo.net/foo"),
712 "$Version=1; foo=bar")
713
714 # explicit foo.net from three-component domain www.foo.net *does* get
715 # set, because .foo.net domain-matches .foo.net
716 interact_2965(c, "http://www.foo.net/foo/",
717 'spam=eggs; domain=foo.net; Version="1"')
718 self.assertEquals(c._cookies[".foo.net"]["/foo/"]["spam"].value,
719 "eggs")
720 self.assertEquals(len(c), 2)
721 self.assertEquals(interact_2965(c, "http://foo.net/foo/"),
722 "$Version=1; foo=bar")
723 self.assertEquals(interact_2965(c, "http://www.foo.net/foo/"),
724 '$Version=1; spam=eggs; $Domain="foo.net"')
725
726 # top-level domain is too general
727 interact_2965(c, "http://foo.net/",
728 'ni="ni"; domain=".net"; Version="1"')
729 self.assertEquals(len(c), 2)
730
731 # RFC 2965 doesn't require blocking this
732 interact_2965(c, "http://foo.co.uk/",
733 'nasty=trick; domain=.co.uk; Version="1"')
734 self.assertEquals(len(c), 3)
735
736 def test_domain_allow(self):
737 from cookielib import CookieJar, DefaultCookiePolicy
738 from urllib2 import Request
739
740 c = CookieJar(policy=DefaultCookiePolicy(
741 blocked_domains=["acme.com"],
742 allowed_domains=["www.acme.com"]))
743
744 req = Request("http://acme.com/")
745 headers = ["Set-Cookie: CUSTOMER=WILE_E_COYOTE; path=/"]
746 res = FakeResponse(headers, "http://acme.com/")
747 c.extract_cookies(res, req)
748 self.assertEquals(len(c), 0)
749
750 req = Request("http://www.acme.com/")
751 res = FakeResponse(headers, "http://www.acme.com/")
752 c.extract_cookies(res, req)
753 self.assertEquals(len(c), 1)
754
755 req = Request("http://www.coyote.com/")
756 res = FakeResponse(headers, "http://www.coyote.com/")
757 c.extract_cookies(res, req)
758 self.assertEquals(len(c), 1)
759
760 # set a cookie with non-allowed domain...
761 req = Request("http://www.coyote.com/")
762 res = FakeResponse(headers, "http://www.coyote.com/")
763 cookies = c.make_cookies(res, req)
764 c.set_cookie(cookies[0])
765 self.assertEquals(len(c), 2)
766 # ... and check is doesn't get returned
767 c.add_cookie_header(req)
768 self.assert_(not req.has_header("Cookie"))
769
770 def test_domain_block(self):
771 from cookielib import CookieJar, DefaultCookiePolicy
772 from urllib2 import Request
773
774 pol = DefaultCookiePolicy(
775 rfc2965=True, blocked_domains=[".acme.com"])
776 c = CookieJar(policy=pol)
777 headers = ["Set-Cookie: CUSTOMER=WILE_E_COYOTE; path=/"]
778
779 req = Request("http://www.acme.com/")
780 res = FakeResponse(headers, "http://www.acme.com/")
781 c.extract_cookies(res, req)
782 self.assertEquals(len(c), 0)
783
784 p = pol.set_blocked_domains(["acme.com"])
785 c.extract_cookies(res, req)
786 self.assertEquals(len(c), 1)
787
788 c.clear()
789 req = Request("http://www.roadrunner.net/")
790 res = FakeResponse(headers, "http://www.roadrunner.net/")
791 c.extract_cookies(res, req)
792 self.assertEquals(len(c), 1)
793 req = Request("http://www.roadrunner.net/")
794 c.add_cookie_header(req)
795 self.assert_((req.has_header("Cookie") and
796 req.has_header("Cookie2")))
797
798 c.clear()
799 pol.set_blocked_domains([".acme.com"])
800 c.extract_cookies(res, req)
801 self.assertEquals(len(c), 1)
802
803 # set a cookie with blocked domain...
804 req = Request("http://www.acme.com/")
805 res = FakeResponse(headers, "http://www.acme.com/")
806 cookies = c.make_cookies(res, req)
807 c.set_cookie(cookies[0])
808 self.assertEquals(len(c), 2)
809 # ... and check is doesn't get returned
810 c.add_cookie_header(req)
811 self.assert_(not req.has_header("Cookie"))
812
813 def test_secure(self):
814 from cookielib import CookieJar, DefaultCookiePolicy
815
816 for ns in True, False:
817 for whitespace in " ", "":
818 c = CookieJar()
819 if ns:
820 pol = DefaultCookiePolicy(rfc2965=False)
821 int = interact_netscape
822 vs = ""
823 else:
824 pol = DefaultCookiePolicy(rfc2965=True)
825 int = interact_2965
826 vs = "; Version=1"
827 c.set_policy(pol)
828 url = "http://www.acme.com/"
829 int(c, url, "foo1=bar%s%s" % (vs, whitespace))
830 int(c, url, "foo2=bar%s; secure%s" % (vs, whitespace))
831 self.assert_(
832 not c._cookies["www.acme.com"]["/"]["foo1"].secure,
833 "non-secure cookie registered secure")
834 self.assert_(
835 c._cookies["www.acme.com"]["/"]["foo2"].secure,
836 "secure cookie registered non-secure")
837
838 def test_quote_cookie_value(self):
839 from cookielib import CookieJar, DefaultCookiePolicy
840 c = CookieJar(policy=DefaultCookiePolicy(rfc2965=True))
841 interact_2965(c, "http://www.acme.com/", r'foo=\b"a"r; Version=1')
842 h = interact_2965(c, "http://www.acme.com/")
843 self.assertEquals(h, r'$Version=1; foo=\\b\"a\"r')
844
845 def test_missing_final_slash(self):
846 # Missing slash from request URL's abs_path should be assumed present.
847 from cookielib import CookieJar, DefaultCookiePolicy
848 from urllib2 import Request
849 url = "http://www.acme.com"
850 c = CookieJar(DefaultCookiePolicy(rfc2965=True))
851 interact_2965(c, url, "foo=bar; Version=1")
852 req = Request(url)
853 self.assertEquals(len(c), 1)
854 c.add_cookie_header(req)
855 self.assert_(req.has_header("Cookie"))
856
857 def test_domain_mirror(self):
858 from cookielib import CookieJar, DefaultCookiePolicy
859
860 pol = DefaultCookiePolicy(rfc2965=True)
861
862 c = CookieJar(pol)
863 url = "http://foo.bar.com/"
864 interact_2965(c, url, "spam=eggs; Version=1")
865 h = interact_2965(c, url)
866 self.assert_("Domain" not in h,
867 "absent domain returned with domain present")
868
869 c = CookieJar(pol)
870 url = "http://foo.bar.com/"
871 interact_2965(c, url, 'spam=eggs; Version=1; Domain=.bar.com')
872 h = interact_2965(c, url)
873 self.assert_('$Domain=".bar.com"' in h, "domain not returned")
874
875 c = CookieJar(pol)
876 url = "http://foo.bar.com/"
877 # note missing initial dot in Domain
878 interact_2965(c, url, 'spam=eggs; Version=1; Domain=bar.com')
879 h = interact_2965(c, url)
880 self.assert_('$Domain="bar.com"' in h, "domain not returned")
881
882 def test_path_mirror(self):
883 from cookielib import CookieJar, DefaultCookiePolicy
884
885 pol = DefaultCookiePolicy(rfc2965=True)
886
887 c = CookieJar(pol)
888 url = "http://foo.bar.com/"
889 interact_2965(c, url, "spam=eggs; Version=1")
890 h = interact_2965(c, url)
891 self.assert_("Path" not in h,
892 "absent path returned with path present")
893
894 c = CookieJar(pol)
895 url = "http://foo.bar.com/"
896 interact_2965(c, url, 'spam=eggs; Version=1; Path=/')
897 h = interact_2965(c, url)
898 self.assert_('$Path="/"' in h, "path not returned")
899
900 def test_port_mirror(self):
901 from cookielib import CookieJar, DefaultCookiePolicy
902
903 pol = DefaultCookiePolicy(rfc2965=True)
904
905 c = CookieJar(pol)
906 url = "http://foo.bar.com/"
907 interact_2965(c, url, "spam=eggs; Version=1")
908 h = interact_2965(c, url)
909 self.assert_("Port" not in h,
910 "absent port returned with port present")
911
912 c = CookieJar(pol)
913 url = "http://foo.bar.com/"
914 interact_2965(c, url, "spam=eggs; Version=1; Port")
915 h = interact_2965(c, url)
916 self.assert_(re.search("\$Port([^=]|$)", h),
917 "port with no value not returned with no value")
918
919 c = CookieJar(pol)
920 url = "http://foo.bar.com/"
921 interact_2965(c, url, 'spam=eggs; Version=1; Port="80"')
922 h = interact_2965(c, url)
923 self.assert_('$Port="80"' in h,
924 "port with single value not returned with single value")
925
926 c = CookieJar(pol)
927 url = "http://foo.bar.com/"
928 interact_2965(c, url, 'spam=eggs; Version=1; Port="80,8080"')
929 h = interact_2965(c, url)
930 self.assert_('$Port="80,8080"' in h,
931 "port with multiple values not returned with multiple "
932 "values")
933
934 def test_no_return_comment(self):
935 from cookielib import CookieJar, DefaultCookiePolicy
936
937 c = CookieJar(DefaultCookiePolicy(rfc2965=True))
938 url = "http://foo.bar.com/"
939 interact_2965(c, url, 'spam=eggs; Version=1; '
940 'Comment="does anybody read these?"; '
941 'CommentURL="http://foo.bar.net/comment.html"')
942 h = interact_2965(c, url)
943 self.assert_(
944 "Comment" not in h,
945 "Comment or CommentURL cookie-attributes returned to server")
946
947 def test_Cookie_iterator(self):
948 from cookielib import CookieJar, Cookie, DefaultCookiePolicy
949
950 cs = CookieJar(DefaultCookiePolicy(rfc2965=True))
951 # add some random cookies
952 interact_2965(cs, "http://blah.spam.org/", 'foo=eggs; Version=1; '
953 'Comment="does anybody read these?"; '
954 'CommentURL="http://foo.bar.net/comment.html"')
955 interact_netscape(cs, "http://www.acme.com/blah/", "spam=bar; secure")
956 interact_2965(cs, "http://www.acme.com/blah/",
957 "foo=bar; secure; Version=1")
958 interact_2965(cs, "http://www.acme.com/blah/",
959 "foo=bar; path=/; Version=1")
960 interact_2965(cs, "http://www.sol.no",
961 r'bang=wallop; version=1; domain=".sol.no"; '
962 r'port="90,100, 80,8080"; '
963 r'max-age=100; Comment = "Just kidding! (\"|\\\\) "')
964
965 versions = [1, 1, 1, 0, 1]
966 names = ["bang", "foo", "foo", "spam", "foo"]
967 domains = [".sol.no", "blah.spam.org", "www.acme.com",
968 "www.acme.com", "www.acme.com"]
969 paths = ["/", "/", "/", "/blah", "/blah/"]
970
971 for i in range(4):
972 i = 0
973 for c in cs:
974 self.assert_(isinstance(c, Cookie))
975 self.assertEquals(c.version, versions[i])
976 self.assertEquals(c.name, names[i])
977 self.assertEquals(c.domain, domains[i])
978 self.assertEquals(c.path, paths[i])
979 i = i + 1
980
981 def test_parse_ns_headers(self):
982 from cookielib import parse_ns_headers
983
984 # missing domain value (invalid cookie)
985 self.assertEquals(
986 parse_ns_headers(["foo=bar; path=/; domain"]),
987 [[("foo", "bar"),
988 ("path", "/"), ("domain", None), ("version", "0")]]
989 )
990 # invalid expires value
991 self.assertEquals(
992 parse_ns_headers(["foo=bar; expires=Foo Bar 12 33:22:11 2000"]),
993 [[("foo", "bar"), ("expires", None), ("version", "0")]]
994 )
995 # missing cookie value (valid cookie)
996 self.assertEquals(
997 parse_ns_headers(["foo"]),
998 [[("foo", None), ("version", "0")]]
999 )
1000 # shouldn't add version if header is empty
1001 self.assertEquals(parse_ns_headers([""]), [])
1002
1003 def test_bad_cookie_header(self):
1004
1005 def cookiejar_from_cookie_headers(headers):
1006 from cookielib import CookieJar
1007 from urllib2 import Request
1008 c = CookieJar()
1009 req = Request("http://www.example.com/")
1010 r = FakeResponse(headers, "http://www.example.com/")
1011 c.extract_cookies(r, req)
1012 return c
1013
1014 # none of these bad headers should cause an exception to be raised
1015 for headers in [
1016 ["Set-Cookie: "], # actually, nothing wrong with this
1017 ["Set-Cookie2: "], # ditto
1018 # missing domain value
1019 ["Set-Cookie2: a=foo; path=/; Version=1; domain"],
1020 # bad max-age
1021 ["Set-Cookie: b=foo; max-age=oops"],
1022 ]:
1023 c = cookiejar_from_cookie_headers(headers)
1024 # these bad cookies shouldn't be set
1025 self.assertEquals(len(c), 0)
1026
1027 # cookie with invalid expires is treated as session cookie
1028 headers = ["Set-Cookie: c=foo; expires=Foo Bar 12 33:22:11 2000"]
1029 c = cookiejar_from_cookie_headers(headers)
1030 cookie = c._cookies["www.example.com"]["/"]["c"]
1031 self.assert_(cookie.expires is None)
1032
1033
1034 class LWPCookieTests(TestCase):
1035 # Tests taken from libwww-perl, with a few modifications and additions.
1036
1037 def test_netscape_example_1(self):
1038 from cookielib import CookieJar, DefaultCookiePolicy
1039 from urllib2 import Request
1040
1041 #-------------------------------------------------------------------
1042 # First we check that it works for the original example at
1043 # http://www.netscape.com/newsref/std/cookie_spec.html
1044
1045 # Client requests a document, and receives in the response:
1046 #
1047 # Set-Cookie: CUSTOMER=WILE_E_COYOTE; path=/; expires=Wednesday, 09-Nov-99 23:12:40 GMT
1048 #
1049 # When client requests a URL in path "/" on this server, it sends:
1050 #
1051 # Cookie: CUSTOMER=WILE_E_COYOTE
1052 #
1053 # Client requests a document, and receives in the response:
1054 #
1055 # Set-Cookie: PART_NUMBER=ROCKET_LAUNCHER_0001; path=/
1056 #
1057 # When client requests a URL in path "/" on this server, it sends:
1058 #
1059 # Cookie: CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKET_LAUNCHER_0001
1060 #
1061 # Client receives:
1062 #
1063 # Set-Cookie: SHIPPING=FEDEX; path=/fo
1064 #
1065 # When client requests a URL in path "/" on this server, it sends:
1066 #
1067 # Cookie: CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKET_LAUNCHER_0001
1068 #
1069 # When client requests a URL in path "/foo" on this server, it sends:
1070 #
1071 # Cookie: CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKET_LAUNCHER_0001; SHIPPING=FEDEX
1072 #
1073 # The last Cookie is buggy, because both specifications say that the
1074 # most specific cookie must be sent first. SHIPPING=FEDEX is the
1075 # most specific and should thus be first.
1076
1077 year_plus_one = time.localtime()[0] + 1
1078
1079 headers = []
1080
1081 c = CookieJar(DefaultCookiePolicy(rfc2965 = True))
1082
1083 #req = Request("http://1.1.1.1/",
1084 # headers={"Host": "www.acme.com:80"})
1085 req = Request("http://www.acme.com:80/",
1086 headers={"Host": "www.acme.com:80"})
1087
1088 headers.append(
1089 "Set-Cookie: CUSTOMER=WILE_E_COYOTE; path=/ ; "
1090 "expires=Wednesday, 09-Nov-%d 23:12:40 GMT" % year_plus_one)
1091 res = FakeResponse(headers, "http://www.acme.com/")
1092 c.extract_cookies(res, req)
1093
1094 req = Request("http://www.acme.com/")
1095 c.add_cookie_header(req)
1096
1097 self.assertEqual(req.get_header("Cookie"), "CUSTOMER=WILE_E_COYOTE")
1098 self.assertEqual(req.get_header("Cookie2"), '$Version="1"')
1099
1100 headers.append("Set-Cookie: PART_NUMBER=ROCKET_LAUNCHER_0001; path=/")
1101 res = FakeResponse(headers, "http://www.acme.com/")
1102 c.extract_cookies(res, req)
1103
1104 req = Request("http://www.acme.com/foo/bar")
1105 c.add_cookie_header(req)
1106
1107 h = req.get_header("Cookie")
1108 self.assert_("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and
1109 "CUSTOMER=WILE_E_COYOTE" in h)
1110
1111 headers.append('Set-Cookie: SHIPPING=FEDEX; path=/foo')
1112 res = FakeResponse(headers, "http://www.acme.com")
1113 c.extract_cookies(res, req)
1114
1115 req = Request("http://www.acme.com/")
1116 c.add_cookie_header(req)
1117
1118 h = req.get_header("Cookie")
1119 self.assert_("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and
1120 "CUSTOMER=WILE_E_COYOTE" in h and
1121 "SHIPPING=FEDEX" not in h)
1122
1123 req = Request("http://www.acme.com/foo/")
1124 c.add_cookie_header(req)
1125
1126 h = req.get_header("Cookie")
1127 self.assert_(("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and
1128 "CUSTOMER=WILE_E_COYOTE" in h and
1129 h.startswith("SHIPPING=FEDEX;")))
1130
1131 def test_netscape_example_2(self):
1132 from cookielib import CookieJar
1133 from urllib2 import Request
1134
1135 # Second Example transaction sequence:
1136 #
1137 # Assume all mappings from above have been cleared.
1138 #
1139 # Client receives:
1140 #
1141 # Set-Cookie: PART_NUMBER=ROCKET_LAUNCHER_0001; path=/
1142 #
1143 # When client requests a URL in path "/" on this server, it sends:
1144 #
1145 # Cookie: PART_NUMBER=ROCKET_LAUNCHER_0001
1146 #
1147 # Client receives:
1148 #
1149 # Set-Cookie: PART_NUMBER=RIDING_ROCKET_0023; path=/ammo
1150 #
1151 # When client requests a URL in path "/ammo" on this server, it sends:
1152 #
1153 # Cookie: PART_NUMBER=RIDING_ROCKET_0023; PART_NUMBER=ROCKET_LAUNCHER_0001
1154 #
1155 # NOTE: There are two name/value pairs named "PART_NUMBER" due to
1156 # the inheritance of the "/" mapping in addition to the "/ammo" mapping.
1157
1158 c = CookieJar()
1159 headers = []
1160
1161 req = Request("http://www.acme.com/")
1162 headers.append("Set-Cookie: PART_NUMBER=ROCKET_LAUNCHER_0001; path=/")
1163 res = FakeResponse(headers, "http://www.acme.com/")
1164
1165 c.extract_cookies(res, req)
1166
1167 req = Request("http://www.acme.com/")
1168 c.add_cookie_header(req)
1169
1170 self.assertEquals(req.get_header("Cookie"),
1171 "PART_NUMBER=ROCKET_LAUNCHER_0001")
1172
1173 headers.append(
1174 "Set-Cookie: PART_NUMBER=RIDING_ROCKET_0023; path=/ammo")
1175 res = FakeResponse(headers, "http://www.acme.com/")
1176 c.extract_cookies(res, req)
1177
1178 req = Request("http://www.acme.com/ammo")
1179 c.add_cookie_header(req)
1180
1181 self.assert_(re.search(r"PART_NUMBER=RIDING_ROCKET_0023;\s*"
1182 "PART_NUMBER=ROCKET_LAUNCHER_0001",
1183 req.get_header("Cookie")))
1184
1185 def test_ietf_example_1(self):
1186 from cookielib import CookieJar, DefaultCookiePolicy
1187 #-------------------------------------------------------------------
1188 # Then we test with the examples from draft-ietf-http-state-man-mec-03.txt
1189 #
1190 # 5. EXAMPLES
1191
1192 c = CookieJar(DefaultCookiePolicy(rfc2965=True))
1193
1194 #
1195 # 5.1 Example 1
1196 #
1197 # Most detail of request and response headers has been omitted. Assume
1198 # the user agent has no stored cookies.
1199 #
1200 # 1. User Agent -> Server
1201 #
1202 # POST /acme/login HTTP/1.1
1203 # [form data]
1204 #
1205 # User identifies self via a form.
1206 #
1207 # 2. Server -> User Agent
1208 #
1209 # HTTP/1.1 200 OK
1210 # Set-Cookie2: Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"
1211 #
1212 # Cookie reflects user's identity.
1213
1214 cookie = interact_2965(
1215 c, 'http://www.acme.com/acme/login',
1216 'Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"')
1217 self.assert_(not cookie)
1218
1219 #
1220 # 3. User Agent -> Server
1221 #
1222 # POST /acme/pickitem HTTP/1.1
1223 # Cookie: $Version="1"; Customer="WILE_E_COYOTE"; $Path="/acme"
1224 # [form data]
1225 #
1226 # User selects an item for ``shopping basket.''
1227 #
1228 # 4. Server -> User Agent
1229 #
1230 # HTTP/1.1 200 OK
1231 # Set-Cookie2: Part_Number="Rocket_Launcher_0001"; Version="1";
1232 # Path="/acme"
1233 #
1234 # Shopping basket contains an item.
1235
1236 cookie = interact_2965(c, 'http://www.acme.com/acme/pickitem',
1237 'Part_Number="Rocket_Launcher_0001"; '
1238 'Version="1"; Path="/acme"');
1239 self.assert_(re.search(
1240 r'^\$Version="?1"?; Customer="?WILE_E_COYOTE"?; \$Path="/acme"$',
1241 cookie))
1242
1243 #
1244 # 5. User Agent -> Server
1245 #
1246 # POST /acme/shipping HTTP/1.1
1247 # Cookie: $Version="1";
1248 # Customer="WILE_E_COYOTE"; $Path="/acme";
1249 # Part_Number="Rocket_Launcher_0001"; $Path="/acme"
1250 # [form data]
1251 #
1252 # User selects shipping method from form.
1253 #
1254 # 6. Server -> User Agent
1255 #
1256 # HTTP/1.1 200 OK
1257 # Set-Cookie2: Shipping="FedEx"; Version="1"; Path="/acme"
1258 #
1259 # New cookie reflects shipping method.
1260
1261 cookie = interact_2965(c, "http://www.acme.com/acme/shipping",
1262 'Shipping="FedEx"; Version="1"; Path="/acme"')
1263
1264 self.assert_(re.search(r'^\$Version="?1"?;', cookie))
1265 self.assert_(re.search(r'Part_Number="?Rocket_Launcher_0001"?;'
1266 '\s*\$Path="\/acme"', cookie))
1267 self.assert_(re.search(r'Customer="?WILE_E_COYOTE"?;\s*\$Path="\/acme"',
1268 cookie))
1269
1270 #
1271 # 7. User Agent -> Server
1272 #
1273 # POST /acme/process HTTP/1.1
1274 # Cookie: $Version="1";
1275 # Customer="WILE_E_COYOTE"; $Path="/acme";
1276 # Part_Number="Rocket_Launcher_0001"; $Path="/acme";
1277 # Shipping="FedEx"; $Path="/acme"
1278 # [form data]
1279 #
1280 # User chooses to process order.
1281 #
1282 # 8. Server -> User Agent
1283 #
1284 # HTTP/1.1 200 OK
1285 #
1286 # Transaction is complete.
1287
1288 cookie = interact_2965(c, "http://www.acme.com/acme/process")
1289 self.assert_(
1290 re.search(r'Shipping="?FedEx"?;\s*\$Path="\/acme"', cookie) and
1291 "WILE_E_COYOTE" in cookie)
1292
1293 #
1294 # The user agent makes a series of requests on the origin server, after
1295 # each of which it receives a new cookie. All the cookies have the same
1296 # Path attribute and (default) domain. Because the request URLs all have
1297 # /acme as a prefix, and that matches the Path attribute, each request
1298 # contains all the cookies received so far.
1299
1300 def test_ietf_example_2(self):
1301 from cookielib import CookieJar, DefaultCookiePolicy
1302
1303 # 5.2 Example 2
1304 #
1305 # This example illustrates the effect of the Path attribute. All detail
1306 # of request and response headers has been omitted. Assume the user agent
1307 # has no stored cookies.
1308
1309 c = CookieJar(DefaultCookiePolicy(rfc2965=True))
1310
1311 # Imagine the user agent has received, in response to earlier requests,
1312 # the response headers
1313 #
1314 # Set-Cookie2: Part_Number="Rocket_Launcher_0001"; Version="1";
1315 # Path="/acme"
1316 #
1317 # and
1318 #
1319 # Set-Cookie2: Part_Number="Riding_Rocket_0023"; Version="1";
1320 # Path="/acme/ammo"
1321
1322 interact_2965(
1323 c, "http://www.acme.com/acme/ammo/specific",
1324 'Part_Number="Rocket_Launcher_0001"; Version="1"; Path="/acme"',
1325 'Part_Number="Riding_Rocket_0023"; Version="1"; Path="/acme/ammo"')
1326
1327 # A subsequent request by the user agent to the (same) server for URLs of
1328 # the form /acme/ammo/... would include the following request header:
1329 #
1330 # Cookie: $Version="1";
1331 # Part_Number="Riding_Rocket_0023"; $Path="/acme/ammo";
1332 # Part_Number="Rocket_Launcher_0001"; $Path="/acme"
1333 #
1334 # Note that the NAME=VALUE pair for the cookie with the more specific Path
1335 # attribute, /acme/ammo, comes before the one with the less specific Path
1336 # attribute, /acme. Further note that the same cookie name appears more
1337 # than once.
1338
1339 cookie = interact_2965(c, "http://www.acme.com/acme/ammo/...")
1340 self.assert_(
1341 re.search(r"Riding_Rocket_0023.*Rocket_Launcher_0001", cookie))
1342
1343 # A subsequent request by the user agent to the (same) server for a URL of
1344 # the form /acme/parts/ would include the following request header:
1345 #
1346 # Cookie: $Version="1"; Part_Number="Rocket_Launcher_0001"; $Path="/acme"
1347 #
1348 # Here, the second cookie's Path attribute /acme/ammo is not a prefix of
1349 # the request URL, /acme/parts/, so the cookie does not get forwarded to
1350 # the server.
1351
1352 cookie = interact_2965(c, "http://www.acme.com/acme/parts/")
1353 self.assert_("Rocket_Launcher_0001" in cookie and
1354 "Riding_Rocket_0023" not in cookie)
1355
1356 def test_rejection(self):
1357 # Test rejection of Set-Cookie2 responses based on domain, path, port.
1358 from cookielib import DefaultCookiePolicy, LWPCookieJar
1359
1360 pol = DefaultCookiePolicy(rfc2965=True)
1361
1362 c = LWPCookieJar(policy=pol)
1363
1364 max_age = "max-age=3600"
1365
1366 # illegal domain (no embedded dots)
1367 cookie = interact_2965(c, "http://www.acme.com",
1368 'foo=bar; domain=".com"; version=1')
1369 self.assert_(not c)
1370
1371 # legal domain
1372 cookie = interact_2965(c, "http://www.acme.com",
1373 'ping=pong; domain="acme.com"; version=1')
1374 self.assertEquals(len(c), 1)
1375
1376 # illegal domain (host prefix "www.a" contains a dot)
1377 cookie = interact_2965(c, "http://www.a.acme.com",
1378 'whiz=bang; domain="acme.com"; version=1')
1379 self.assertEquals(len(c), 1)
1380
1381 # legal domain
1382 cookie = interact_2965(c, "http://www.a.acme.com",
1383 'wow=flutter; domain=".a.acme.com"; version=1')
1384 self.assertEquals(len(c), 2)
1385
1386 # can't partially match an IP-address
1387 cookie = interact_2965(c, "http://125.125.125.125",
1388 'zzzz=ping; domain="125.125.125"; version=1')
1389 self.assertEquals(len(c), 2)
1390
1391 # illegal path (must be prefix of request path)
1392 cookie = interact_2965(c, "http://www.sol.no",
1393 'blah=rhubarb; domain=".sol.no"; path="/foo"; '
1394 'version=1')
1395 self.assertEquals(len(c), 2)
1396
1397 # legal path
1398 cookie = interact_2965(c, "http://www.sol.no/foo/bar",
1399 'bing=bong; domain=".sol.no"; path="/foo"; '
1400 'version=1')
1401 self.assertEquals(len(c), 3)
1402
1403 # illegal port (request-port not in list)
1404 cookie = interact_2965(c, "http://www.sol.no",
1405 'whiz=ffft; domain=".sol.no"; port="90,100"; '
1406 'version=1')
1407 self.assertEquals(len(c), 3)
1408
1409 # legal port
1410 cookie = interact_2965(
1411 c, "http://www.sol.no",
1412 r'bang=wallop; version=1; domain=".sol.no"; '
1413 r'port="90,100, 80,8080"; '
1414 r'max-age=100; Comment = "Just kidding! (\"|\\\\) "')
1415 self.assertEquals(len(c), 4)
1416
1417 # port attribute without any value (current port)
1418 cookie = interact_2965(c, "http://www.sol.no",
1419 'foo9=bar; version=1; domain=".sol.no"; port; '
1420 'max-age=100;')
1421 self.assertEquals(len(c), 5)
1422
1423 # encoded path
1424 # LWP has this test, but unescaping allowed path characters seems
1425 # like a bad idea, so I think this should fail:
1426 ## cookie = interact_2965(c, "http://www.sol.no/foo/",
1427 ## r'foo8=bar; version=1; path="/%66oo"')
1428 # but this is OK, because '<' is not an allowed HTTP URL path
1429 # character:
1430 cookie = interact_2965(c, "http://www.sol.no/<oo/",
1431 r'foo8=bar; version=1; path="/%3coo"')
1432 self.assertEquals(len(c), 6)
1433
1434 # save and restore
1435 filename = test_support.TESTFN
1436
1437 try:
1438 c.save(filename, ignore_discard=True)
1439 old = repr(c)
1440
1441 c = LWPCookieJar(policy=pol)
1442 c.load(filename, ignore_discard=True)
1443 finally:
1444 try: os.unlink(filename)
1445 except OSError: pass
1446
1447 self.assertEquals(old, repr(c))
1448
1449 def test_url_encoding(self):
1450 # Try some URL encodings of the PATHs.
1451 # (the behaviour here has changed from libwww-perl)
1452 from cookielib import CookieJar, DefaultCookiePolicy
1453
1454 c = CookieJar(DefaultCookiePolicy(rfc2965=True))
1455 interact_2965(c, "http://www.acme.com/foo%2f%25/%3c%3c%0Anew%E5/%E5",
1456 "foo = bar; version = 1")
1457
1458 cookie = interact_2965(
1459 c, "http://www.acme.com/foo%2f%25/<<%0anewå/æøå",
1460 'bar=baz; path="/foo/"; version=1');
1461 version_re = re.compile(r'^\$version=\"?1\"?', re.I)
1462 self.assert_("foo=bar" in cookie and version_re.search(cookie))
1463
1464 cookie = interact_2965(
1465 c, "http://www.acme.com/foo/%25/<<%0anewå/æøå")
1466 self.assert_(not cookie)
1467
1468 # unicode URL doesn't raise exception
1469 cookie = interact_2965(c, u"http://www.acme.com/\xfc")
1470
1471 def test_mozilla(self):
1472 # Save / load Mozilla/Netscape cookie file format.
1473 from cookielib import MozillaCookieJar, DefaultCookiePolicy
1474
1475 year_plus_one = time.localtime()[0] + 1
1476
1477 filename = test_support.TESTFN
1478
1479 c = MozillaCookieJar(filename,
1480 policy=DefaultCookiePolicy(rfc2965=True))
1481 interact_2965(c, "http://www.acme.com/",
1482 "foo1=bar; max-age=100; Version=1")
1483 interact_2965(c, "http://www.acme.com/",
1484 'foo2=bar; port="80"; max-age=100; Discard; Version=1')
1485 interact_2965(c, "http://www.acme.com/", "foo3=bar; secure; Version=1")
1486
1487 expires = "expires=09-Nov-%d 23:12:40 GMT" % (year_plus_one,)
1488 interact_netscape(c, "http://www.foo.com/",
1489 "fooa=bar; %s" % expires)
1490 interact_netscape(c, "http://www.foo.com/",
1491 "foob=bar; Domain=.foo.com; %s" % expires)
1492 interact_netscape(c, "http://www.foo.com/",
1493 "fooc=bar; Domain=www.foo.com; %s" % expires)
1494
1495 def save_and_restore(cj, ignore_discard):
1496 try:
1497 cj.save(ignore_discard=ignore_discard)
1498 new_c = MozillaCookieJar(filename,
1499 DefaultCookiePolicy(rfc2965=True))
1500 new_c.load(ignore_discard=ignore_discard)
1501 finally:
1502 try: os.unlink(filename)
1503 except OSError: pass
1504 return new_c
1505
1506 new_c = save_and_restore(c, True)
1507 self.assertEquals(len(new_c), 6) # none discarded
1508 self.assert_("name='foo1', value='bar'" in repr(new_c))
1509
1510 new_c = save_and_restore(c, False)
1511 self.assertEquals(len(new_c), 4) # 2 of them discarded on save
1512 self.assert_("name='foo1', value='bar'" in repr(new_c))
1513
1514 def test_netscape_misc(self):
1515 # Some additional Netscape cookies tests.
1516 from cookielib import CookieJar
1517 from urllib2 import Request
1518
1519 c = CookieJar()
1520 headers = []
1521 req = Request("http://foo.bar.acme.com/foo")
1522
1523 # Netscape allows a host part that contains dots
1524 headers.append("Set-Cookie: Customer=WILE_E_COYOTE; domain=.acme.com")
1525 res = FakeResponse(headers, "http://www.acme.com/foo")
1526 c.extract_cookies(res, req)
1527
1528 # and that the domain is the same as the host without adding a leading
1529 # dot to the domain. Should not quote even if strange chars are used
1530 # in the cookie value.
1531 headers.append("Set-Cookie: PART_NUMBER=3,4; domain=foo.bar.acme.com")
1532 res = FakeResponse(headers, "http://www.acme.com/foo")
1533 c.extract_cookies(res, req)
1534
1535 req = Request("http://foo.bar.acme.com/foo")
1536 c.add_cookie_header(req)
1537 self.assert_(
1538 "PART_NUMBER=3,4" in req.get_header("Cookie") and
1539 "Customer=WILE_E_COYOTE" in req.get_header("Cookie"))
1540
1541 def test_intranet_domains_2965(self):
1542 # Test handling of local intranet hostnames without a dot.
1543 from cookielib import CookieJar, DefaultCookiePolicy
1544
1545 c = CookieJar(DefaultCookiePolicy(rfc2965=True))
1546 interact_2965(c, "http://example/",
1547 "foo1=bar; PORT; Discard; Version=1;")
1548 cookie = interact_2965(c, "http://example/",
1549 'foo2=bar; domain=".local"; Version=1')
1550 self.assert_("foo1=bar" in cookie)
1551
1552 interact_2965(c, "http://example/", 'foo3=bar; Version=1')
1553 cookie = interact_2965(c, "http://example/")
1554 self.assert_("foo2=bar" in cookie and len(c) == 3)
1555
1556 def test_intranet_domains_ns(self):
1557 from cookielib import CookieJar, DefaultCookiePolicy
1558
1559 c = CookieJar(DefaultCookiePolicy(rfc2965 = False))
1560 interact_netscape(c, "http://example/", "foo1=bar")
1561 cookie = interact_netscape(c, "http://example/",
1562 'foo2=bar; domain=.local')
1563 self.assertEquals(len(c), 2)
1564 self.assert_("foo1=bar" in cookie)
1565
1566 cookie = interact_netscape(c, "http://example/")
1567 self.assert_("foo2=bar" in cookie)
1568 self.assertEquals(len(c), 2)
1569
1570 def test_empty_path(self):
1571 from cookielib import CookieJar, DefaultCookiePolicy
1572 from urllib2 import Request
1573
1574 # Test for empty path
1575 # Broken web-server ORION/1.3.38 returns to the client response like
1576 #
1577 # Set-Cookie: JSESSIONID=ABCDERANDOM123; Path=
1578 #
1579 # ie. with Path set to nothing.
1580 # In this case, extract_cookies() must set cookie to / (root)
1581 c = CookieJar(DefaultCookiePolicy(rfc2965 = True))
1582 headers = []
1583
1584 req = Request("http://www.ants.com/")
1585 headers.append("Set-Cookie: JSESSIONID=ABCDERANDOM123; Path=")
1586 res = FakeResponse(headers, "http://www.ants.com/")
1587 c.extract_cookies(res, req)
1588
1589 req = Request("http://www.ants.com/")
1590 c.add_cookie_header(req)
1591
1592 self.assertEquals(req.get_header("Cookie"),
1593 "JSESSIONID=ABCDERANDOM123")
1594 self.assertEquals(req.get_header("Cookie2"), '$Version="1"')
1595
1596 # missing path in the request URI
1597 req = Request("http://www.ants.com:8080")
1598 c.add_cookie_header(req)
1599
1600 self.assertEquals(req.get_header("Cookie"),
1601 "JSESSIONID=ABCDERANDOM123")
1602 self.assertEquals(req.get_header("Cookie2"), '$Version="1"')
1603
1604 def test_session_cookies(self):
1605 from cookielib import CookieJar
1606 from urllib2 import Request
1607
1608 year_plus_one = time.localtime()[0] + 1
1609
1610 # Check session cookies are deleted properly by
1611 # CookieJar.clear_session_cookies method
1612
1613 req = Request('http://www.perlmeister.com/scripts')
1614 headers = []
1615 headers.append("Set-Cookie: s1=session;Path=/scripts")
1616 headers.append("Set-Cookie: p1=perm; Domain=.perlmeister.com;"
1617 "Path=/;expires=Fri, 02-Feb-%d 23:24:20 GMT" %
1618 year_plus_one)
1619 headers.append("Set-Cookie: p2=perm;Path=/;expires=Fri, "
1620 "02-Feb-%d 23:24:20 GMT" % year_plus_one)
1621 headers.append("Set-Cookie: s2=session;Path=/scripts;"
1622 "Domain=.perlmeister.com")
1623 headers.append('Set-Cookie2: s3=session;Version=1;Discard;Path="/"')
1624 res = FakeResponse(headers, 'http://www.perlmeister.com/scripts')
1625
1626 c = CookieJar()
1627 c.extract_cookies(res, req)
1628 # How many session/permanent cookies do we have?
1629 counter = {"session_after": 0,
1630 "perm_after": 0,
1631 "session_before": 0,
1632 "perm_before": 0}
1633 for cookie in c:
1634 key = "%s_before" % cookie.value
1635 counter[key] = counter[key] + 1
1636 c.clear_session_cookies()
1637 # How many now?
1638 for cookie in c:
1639 key = "%s_after" % cookie.value
1640 counter[key] = counter[key] + 1
1641
1642 self.assert_(not (
1643 # a permanent cookie got lost accidently
1644 counter["perm_after"] != counter["perm_before"] or
1645 # a session cookie hasn't been cleared
1646 counter["session_after"] != 0 or
1647 # we didn't have session cookies in the first place
1648 counter["session_before"] == 0))
1649
1650
1651 def test_main(verbose=None):
1652 from test import test_sets
1653 test_support.run_unittest(
1654 DateTimeTests,
1655 HeaderTests,
1656 CookieTests,
1657 FileCookieJarTests,
1658 LWPCookieTests,
1659 )
1660
1661 if __name__ == "__main__":
1662 test_main(verbose=True)