[wwwsearch-commits] r51911 - in wwwsearch/mechanize/trunk: . mechanize test test-tools test-tools/support
jjlee at codespeak.net
jjlee at codespeak.net
Thu Feb 28 00:22:23 CET 2008
Author: jjlee
Date: Thu Feb 28 00:22:22 2008
New Revision: 51911
Added:
wwwsearch/mechanize/trunk/mechanize/_firefox3cookiejar.py
wwwsearch/mechanize/trunk/test-tools/support/
Modified:
wwwsearch/mechanize/trunk/functional_tests.py
wwwsearch/mechanize/trunk/mechanize/__init__.py
wwwsearch/mechanize/trunk/test-tools/cookietest.cgi
wwwsearch/mechanize/trunk/test/test_cookies.py
Log:
* Add support for Firefox 3 cookie jars ("cookies.sqlite")
* Fix a couple of test typos re tempfile cleanup
* Add a functional test for seek-wrapped HTTPError repr
Modified: wwwsearch/mechanize/trunk/functional_tests.py
==============================================================================
--- wwwsearch/mechanize/trunk/functional_tests.py (original)
+++ wwwsearch/mechanize/trunk/functional_tests.py Thu Feb 28 00:22:22 2008
@@ -4,7 +4,7 @@
# thanks Moof (aka Giles Antonio Radford) for some of these
-import os, sys, urllib
+import os, sys, urllib, tempfile, errno
from unittest import TestCase
import mechanize
@@ -159,6 +159,14 @@
r.get_data(),
"Hello ClientCookie functional test suite.\n")
+ def test_seek_wrapper_class_name(self):
+ opener = mechanize.UserAgent()
+ opener.set_seekable_responses(True)
+ try:
+ opener.open(urljoin(self.uri, "nonexistent"))
+ except mechanize.HTTPError, exc:
+ self.assert_("HTTPError instance" in repr(exc))
+
def test_no_seek(self):
# should be possible to turn off UserAgent's .seek() functionality
def check_no_seek(opener):
@@ -395,6 +403,65 @@
## r.close()
## self.assert_(data1 != data2)
+
+class CookieJarTests(TestCase):
+
+ def test_mozilla_cookiejar(self):
+ filename = tempfile.mktemp()
+ try:
+ def get_cookiejar():
+ cj = mechanize.MozillaCookieJar(filename=filename)
+ try:
+ cj.revert()
+ except IOError, exc:
+ if exc.errno != errno.ENOENT:
+ raise
+ return cj
+ def commit(cj):
+ cj.save()
+ self._test_cookiejar(get_cookiejar, commit)
+ finally:
+ try:
+ os.remove(filename)
+ except OSError, exc:
+ if exc.errno != errno.ENOENT:
+ raise
+
+ def test_firefox3_cookiejar(self):
+ filename = tempfile.mktemp()
+ try:
+ def get_cookiejar():
+ cj = mechanize.Firefox3CookieJar(filename=filename)
+ cj.connect()
+ return cj
+ def commit(cj):
+ pass
+ self._test_cookiejar(get_cookiejar, commit)
+ finally:
+ os.remove(filename)
+
+ def _test_cookiejar(self, get_cookiejar, commit):
+ cookiejar = get_cookiejar()
+ br = mechanize.Browser()
+ br.set_cookiejar(cookiejar)
+ br.set_handle_refresh(False)
+ url = urljoin(self.uri, "/cgi-bin/cookietest.cgi")
+ # no cookie was set on the first request
+ html = br.open(url).read()
+ self.assertEquals(html.find("Your browser supports cookies!"), -1)
+ self.assertEquals(len(cookiejar), 1)
+ # ... but now we have the cookie
+ html = br.open(url).read()
+ self.assert_("Your browser supports cookies!" in html)
+ commit(cookiejar)
+
+ # should still have the cookie when we load afresh
+ cookiejar = get_cookiejar()
+ br.set_cookiejar(cookiejar)
+ html = br.open(url).read()
+ self.assert_("Your browser supports cookies!" in html)
+
+
class CallbackVerifier:
# for .test_urlretrieve()
def __init__(self, testcase):
Modified: wwwsearch/mechanize/trunk/mechanize/__init__.py
==============================================================================
--- wwwsearch/mechanize/trunk/mechanize/__init__.py (original)
+++ wwwsearch/mechanize/trunk/mechanize/__init__.py Thu Feb 28 00:22:22 2008
@@ -115,6 +115,7 @@
from _clientcookie import Cookie, CookiePolicy, DefaultCookiePolicy, \
CookieJar, FileCookieJar, LoadError, request_host
from _lwpcookiejar import LWPCookieJar, lwp_cookie_str
+from _firefox3cookiejar import Firefox3CookieJar
from _mozillacookiejar import MozillaCookieJar
from _msiecookiejar import MSIECookieJar
Added: wwwsearch/mechanize/trunk/mechanize/_firefox3cookiejar.py
==============================================================================
--- (empty file)
+++ wwwsearch/mechanize/trunk/mechanize/_firefox3cookiejar.py Thu Feb 28 00:22:22 2008
@@ -0,0 +1,245 @@
+"""Firefox 3 "cookies.sqlite" cookie persistence.
+
+Copyright 2008 John J Lee <jjl at pobox.com>
+
+This code is free software; you can redistribute it and/or modify it
+under the terms of the BSD or ZPL 2.1 licenses (see the file
+COPYING.txt included with the distribution).
+
+"""
+
+import logging
+import time
+
+from _clientcookie import CookieJar, Cookie, MappingIterator
+from _util import isstringlike
+debug = logging.getLogger("mechanize.cookies").debug
+
+
+try:
+ import sqlite3
+except ImportError:
+ pass
+else:
+ class Firefox3CookieJar(CookieJar):
+
+ """Firefox 3 cookie jar.
+
+ The cookies are stored in Firefox 3's "cookies.sqlite" format.
+
+ Constructor arguments:
+
+ filename: filename of cookies.sqlite (typically found at the top level
+ of a firefox profile directory)
+ autoconnect: as a convenience, connect to the SQLite cookies database at
+ Firefox3CookieJar construction time (default True)
+ policy: an object satisfying the mechanize.CookiePolicy interface
+
+ Note that this is NOT a FileCookieJar, and there are no .load(),
+ .save() or .restore() methods. The database is in sync with the
+ cookiejar object's state after each public method call.
+
+ Following Firefox's own behaviour, session cookies are never saved to
+ the database.
+
+ The file is created, and an sqlite database written to it, if it does
+ not already exist. The moz_cookies database table is created if it does
+ not already exist.
+ """
+
+ def __init__(self, filename, autoconnect=True, policy=None):
+ CookieJar.__init__(self, policy)
+ if filename is not None and not isstringlike(filename):
+ raise ValueError("filename must be string-like")
+ self.filename = filename
+ self._conn = None
+ if autoconnect:
+ self.connect()
+
+ def connect(self):
+ self._conn = sqlite3.connect(self.filename)
+ self._conn.isolation_level = "DEFERRED"
+ self._create_table_if_necessary()
+
+ def close(self):
+ self._conn.close()
+
+ def _transaction(self, func):
+ try:
+ cur = self._conn.cursor()
+ try:
+ result = func(cur)
+ finally:
+ cur.close()
+ except:
+ self._conn.rollback()
+ raise
+ else:
+ self._conn.commit()
+ return result
+
+ def _execute(self, query, params=()):
+ return self._transaction(lambda cur: cur.execute(query, params))
+
+ def _query(self, query, params=()):
+ # XXX should we bother with a transaction?
+ cur = self._conn.cursor()
+ try:
+ cur.execute(query, params)
+ for row in cur.fetchall():
+ yield row
+ finally:
+ cur.close()
+
+ def _create_table_if_necessary(self):
+ self._execute("""\
+CREATE TABLE IF NOT EXISTS moz_cookies (id INTEGER PRIMARY KEY, name TEXT,
+ value TEXT, host TEXT, path TEXT,expiry INTEGER,
+ lastAccessed INTEGER, isSecure INTEGER, isHttpOnly INTEGER)""")
+
+ def _cookie_from_row(self, row):
+ (pk, name, value, domain, path, expires,
+ last_accessed, secure, http_only) = row
+
+ version = 0
+ domain = domain.encode("ascii", "ignore")
+ path = path.encode("ascii", "ignore")
+ name = name.encode("ascii", "ignore")
+ value = value.encode("ascii", "ignore")
+ secure = bool(secure)
+
+ # last_accessed isn't a cookie attribute, so isn't added to rest
+ rest = {}
+ if http_only:
+ rest["HttpOnly"] = None
+
+ if name == "":
+ name = value
+ value = None
+
+ initial_dot = domain.startswith(".")
+ domain_specified = initial_dot
+
+ discard = False
+ if expires == "":
+ expires = None
+ discard = True
+
+ return Cookie(version, name, value,
+ None, False,
+ domain, domain_specified, initial_dot,
+ path, False,
+ secure,
+ expires,
+ discard,
+ None,
+ None,
+ rest)
+
+ def clear(self, domain=None, path=None, name=None):
+ CookieJar.clear(self, domain, path, name)
+ where_parts = []
+ sql_params = []
+ if domain is not None:
+ where_parts.append("host = ?")
+ sql_params.append(domain)
+ if path is not None:
+ where_parts.append("path = ?")
+ sql_params.append(path)
+ if name is not None:
+ where_parts.append("name = ?")
+ sql_params.append(name)
+ where = " AND ".join(where_parts)
+ if where:
+ where = " WHERE " + where
+ def clear(cur):
+ cur.execute("DELETE FROM moz_cookies%s" % where,
+ tuple(sql_params))
+ self._transaction(clear)
+
+ def _row_from_cookie(self, cookie, cur):
+ expires = cookie.expires
+ if cookie.discard:
+ expires = ""
+
+ domain = unicode(cookie.domain)
+ path = unicode(cookie.path)
+ name = unicode(cookie.name)
+ value = unicode(cookie.value)
+ secure = bool(int(cookie.secure))
+
+ if value is None:
+ value = name
+ name = ""
+
+ last_accessed = int(time.time())
+ http_only = cookie.has_nonstandard_attr("HttpOnly")
+
+ query = cur.execute("""SELECT MAX(id) + 1 from moz_cookies""")
+ pk = query.fetchone()[0]
+ if pk is None:
+ pk = 1
+
+ return (pk, name, value, domain, path, expires,
+ last_accessed, secure, http_only)
+
+ def set_cookie(self, cookie):
+ if cookie.discard:
+ CookieJar.set_cookie(self, cookie)
+ return
+
+ def set_cookie(cur):
+ row = self._row_from_cookie(cookie, cur)
+ name, unused, domain, path = row[1:5]
+ cur.execute("""\
+DELETE FROM moz_cookies WHERE host = ? AND path = ? AND name = ?""",
+ (domain, path, name))
+ cur.execute("""\
+INSERT INTO moz_cookies VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+""", row)
+ self._transaction(set_cookie)
+
+ def __iter__(self):
+ # session (non-persistent) cookies
+ for cookie in MappingIterator(self._cookies):
+ yield cookie
+ # persistent cookies
+ for row in self._query("""\
+SELECT * FROM moz_cookies ORDER BY name, path, host"""):
+ yield self._cookie_from_row(row)
+
+ def _cookies_for_request(self, request):
+ session_cookies = CookieJar._cookies_for_request(self, request)
+ def get_cookies(cur):
+ query = cur.execute("SELECT host from moz_cookies")
+ domains = [row[0] for row in query.fetchmany()]
+ cookies = []
+ for domain in domains:
+ cookies += self._persistent_cookies_for_domain(domain,
+ request, cur)
+ return cookies
+ persistent_coookies = self._transaction(get_cookies)
+ return session_cookies + persistent_coookies
+
+ def _persistent_cookies_for_domain(self, domain, request, cur):
+ cookies = []
+ if not self._policy.domain_return_ok(domain, request):
+ return []
+ debug("Checking %s for cookies to return", domain)
+ query = cur.execute("""\
+SELECT * from moz_cookies WHERE host = ? ORDER BY path""",
+ (domain,))
+ cookies = [self._cookie_from_row(row) for row in query.fetchmany()]
+ last_path = None
+ r = []
+ for cookie in cookies:
+ if (cookie.path != last_path and
+ not self._policy.path_return_ok(cookie.path, request)):
+ last_path = cookie.path
+ continue
+ if not self._policy.return_ok(cookie, request):
+ debug(" not returning cookie")
+ continue
+ debug(" it's a match")
+ r.append(cookie)
+ return r
Modified: wwwsearch/mechanize/trunk/test-tools/cookietest.cgi
==============================================================================
--- wwwsearch/mechanize/trunk/test-tools/cookietest.cgi (original)
+++ wwwsearch/mechanize/trunk/test-tools/cookietest.cgi Thu Feb 28 00:22:22 2008
@@ -5,8 +5,12 @@
#import cgitb; cgitb.enable()
+import time
+
print "Content-Type: text/html"
-print "Set-Cookie: foo=bar\n"
+year_plus_one = time.localtime(time.time())[0] + 1
+expires = "expires=09-Nov-%d 23:12:40 GMT" % (year_plus_one,)
+print "Set-Cookie: foo=bar; %s\n" % expires
import sys, os, string, cgi, Cookie, urllib
from xml.sax import saxutils
Modified: wwwsearch/mechanize/trunk/test/test_cookies.py
==============================================================================
--- wwwsearch/mechanize/trunk/test/test_cookies.py (original)
+++ wwwsearch/mechanize/trunk/test/test_cookies.py Thu Feb 28 00:22:22 2008
@@ -35,6 +35,25 @@
return cookie_hdr
+class TempfileTestMixin():
+
+ def setUp(self):
+ self._tempfiles = []
+
+ def tearDown(self):
+ for fn in self._tempfiles:
+ try:
+ os.remove(fn)
+ except IOError, exc:
+ if exc.errno != errno.ENOENT:
+ raise
+
+ def mktemp(self):
+ fn = tempfile.mktemp()
+ self._tempfiles.append(fn)
+ return fn
+
+
class CookieTests(TestCase):
# XXX
# Get rid of string comparisons where not actually testing str / repr.
@@ -864,7 +883,196 @@
assert cookie.expires is None
-class LWPCookieTests(TestCase):
+class CookieJarPersistenceTests(TempfileTestMixin, TestCase):
+
+ def _interact(self, cj):
+ year_plus_one = localtime(time.time())[0] + 1
+ interact_2965(cj, "http://www.acme.com/",
+ "foo1=bar; max-age=100; Version=1")
+ interact_2965(cj, "http://www.acme.com/",
+ 'foo2=bar; port="80"; max-age=100; Discard; Version=1')
+ interact_2965(cj, "http://www.acme.com/", "foo3=bar; secure; Version=1")
+
+ expires = "expires=09-Nov-%d 23:12:40 GMT" % (year_plus_one,)
+ interact_netscape(cj, "http://www.foo.com/",
+ "fooa=bar; %s" % expires)
+ interact_netscape(cj, "http://www.foo.com/",
+ "foob=bar; Domain=.foo.com; %s" % expires)
+ interact_netscape(cj, "http://www.foo.com/",
+ "fooc=bar; Domain=www.foo.com; %s" % expires)
+
+ def test_firefox3_cookiejar_restore(self):
+ try:
+ from mechanize import Firefox3CookieJar
+ except ImportError:
+ pass
+ else:
+ from mechanize import DefaultCookiePolicy
+ filename = self.mktemp()
+ def create_cookiejar():
+ cj = Firefox3CookieJar(filename,
+ policy=DefaultCookiePolicy(rfc2965=True))
+ cj.connect()
+ return cj
+ cj = create_cookiejar()
+ self._interact(cj)
+ self.assertEquals(len(cj), 6)
+ cj.close()
+ cj = create_cookiejar()
+ self.assert_("name='foo1', value='bar'" in repr(cj))
+ self.assertEquals(len(cj), 4)
+
+ def test_firefox3_cookiejar_iteration(self):
+ try:
+ from mechanize import Firefox3CookieJar
+ except ImportError:
+ pass
+ else:
+ from mechanize import DefaultCookiePolicy, Cookie
+ filename = self.mktemp()
+ cj = Firefox3CookieJar(filename,
+ policy=DefaultCookiePolicy(rfc2965=True))
+ cj.connect()
+ self._interact(cj)
+ summary = "\n".join([str(cookie) for cookie in cj])
+ self.assertEquals(summary,
+ """\
+<Cookie foo2=bar for www.acme.com:80/>
+<Cookie foo3=bar for www.acme.com/>
+<Cookie foo1=bar for www.acme.com/>
+<Cookie fooa=bar for www.foo.com/>
+<Cookie foob=bar for .foo.com/>
+<Cookie fooc=bar for .www.foo.com/>""")
+
+ def test_firefox3_cookiejar_clear(self):
+ try:
+ from mechanize import Firefox3CookieJar
+ except ImportError:
+ pass
+ else:
+ from mechanize import DefaultCookiePolicy, Cookie
+ filename = self.mktemp()
+ cj = Firefox3CookieJar(filename,
+ policy=DefaultCookiePolicy(rfc2965=True))
+ cj.connect()
+ self._interact(cj)
+ cj.clear("www.acme.com", "/", "foo2")
+ def summary(): return "\n".join([str(cookie) for cookie in cj])
+ self.assertEquals(summary(),
+ """\
+<Cookie foo3=bar for www.acme.com/>
+<Cookie foo1=bar for www.acme.com/>
+<Cookie fooa=bar for www.foo.com/>
+<Cookie foob=bar for .foo.com/>
+<Cookie fooc=bar for .www.foo.com/>""")
+ cj.clear("www.acme.com")
+ self.assertEquals(summary(),
+ """\
+<Cookie fooa=bar for www.foo.com/>
+<Cookie foob=bar for .foo.com/>
+<Cookie fooc=bar for .www.foo.com/>""")
+ # if name is given, so must path and domain
+ self.assertRaises(ValueError, cj.clear, domain=".foo.com",
+ name="foob")
+ # nonexistent domain
+ self.assertRaises(KeyError, cj.clear, domain=".spam.com")
+
+ def test_firefox3_cookiejar_add_cookie_header(self):
+ try:
+ from mechanize import Firefox3CookieJar
+ except ImportError:
+ pass
+ else:
+ from mechanize import DefaultCookiePolicy, Request
+ filename = self.mktemp()
+ cj = Firefox3CookieJar(filename)
+ cj.connect()
+ # Session cookies (true .discard) and persistent cookies (false
+ # .discard) are stored differently. Check they both get sent.
+ year_plus_one = localtime(time.time())[0] + 1
+ expires = "expires=09-Nov-%d 23:12:40 GMT" % (year_plus_one,)
+ interact_netscape(cj, "http://www.foo.com/", "fooa=bar")
+ interact_netscape(cj, "http://www.foo.com/",
+ "foob=bar; %s" % expires)
+ ca, cb = cj
+ self.assert_(ca.discard)
+ self.assertFalse(cb.discard)
+ request = Request("http://www.foo.com/")
+ cj.add_cookie_header(request)
+ self.assertEquals(request.get_header("Cookie"),
+ "fooa=bar; foob=bar")
+
+ def test_mozilla_cookiejar(self):
+ # Save / load Mozilla/Netscape cookie file format.
+ from mechanize import MozillaCookieJar, DefaultCookiePolicy
+ filename = tempfile.mktemp()
+ c = MozillaCookieJar(filename,
+ policy=DefaultCookiePolicy(rfc2965=True))
+ self._interact(c)
+
+ def save_and_restore(cj, ignore_discard, filename=filename):
+ from mechanize import MozillaCookieJar, DefaultCookiePolicy
+ try:
+ cj.save(ignore_discard=ignore_discard)
+ new_c = MozillaCookieJar(filename,
+ DefaultCookiePolicy(rfc2965=True))
+ new_c.load(ignore_discard=ignore_discard)
+ finally:
+ try: os.unlink(filename)
+ except OSError: pass
+ return new_c
+
+ new_c = save_and_restore(c, True)
+ assert len(new_c) == 6 # none discarded
+ assert repr(new_c).find("name='foo1', value='bar'") != -1
+
+ new_c = save_and_restore(c, False)
+ assert len(new_c) == 4 # 2 of them discarded on save
+ assert repr(new_c).find("name='foo1', value='bar'") != -1
+
+ def test_mozilla_cookiejar_embedded_tab(self):
+ from mechanize import MozillaCookieJar
+ filename = tempfile.mktemp()
+ fh = open(filename, "w")
+ try:
+ fh.write(
+ MozillaCookieJar.header + "\n" +
+ "a.com\tFALSE\t/\tFALSE\t\tname\tval\tstillthevalue\n"
+ "a.com\tFALSE\t/\tFALSE\t\tname2\tvalue\n")
+ fh.close()
+ cj = MozillaCookieJar(filename)
+ cj.revert(ignore_discard=True)
+ cookies = cj._cookies["a.com"]["/"]
+ self.assertEquals(cookies["name"].value, "val\tstillthevalue")
+ self.assertEquals(cookies["name2"].value, "value")
+ finally:
+ try:
+ os.remove(filename)
+ except IOError, exc:
+ if exc.errno != errno.ENOENT:
+ raise
+
+ def test_mozilla_cookiejar_initial_dot_violation(self):
+ from mechanize import MozillaCookieJar, LoadError
+ filename = tempfile.mktemp()
+ fh = open(filename, "w")
+ try:
+ fh.write(
+ MozillaCookieJar.header + "\n" +
+ ".a.com\tFALSE\t/\tFALSE\t\tname\tvalue\n")
+ fh.close()
+ cj = MozillaCookieJar(filename)
+ self.assertRaises(LoadError, cj.revert, ignore_discard=True)
+ finally:
+ try:
+ os.remove(filename)
+ except IOError, exc:
+ if exc.errno != errno.ENOENT:
+ raise
+
+
+
+class LWPCookieTests(TestCase, TempfileTestMixin):
# Tests taken from libwww-perl, with a few modifications.
def test_netscape_example_1(self):
@@ -1300,90 +1508,6 @@
# unicode URL doesn't raise exception, as it used to!
cookie = interact_2965(c, u"http://www.acme.com/\xfc")
- def test_mozilla(self):
- # Save / load Mozilla/Netscape cookie file format.
- from mechanize import MozillaCookieJar, DefaultCookiePolicy
-
- year_plus_one = localtime(time.time())[0] + 1
-
- filename = tempfile.mktemp()
-
- c = MozillaCookieJar(filename,
- policy=DefaultCookiePolicy(rfc2965=True))
- interact_2965(c, "http://www.acme.com/",
- "foo1=bar; max-age=100; Version=1")
- interact_2965(c, "http://www.acme.com/",
- 'foo2=bar; port="80"; max-age=100; Discard; Version=1')
- interact_2965(c, "http://www.acme.com/", "foo3=bar; secure; Version=1")
-
- expires = "expires=09-Nov-%d 23:12:40 GMT" % (year_plus_one,)
- interact_netscape(c, "http://www.foo.com/",
- "fooa=bar; %s" % expires)
- interact_netscape(c, "http://www.foo.com/",
- "foob=bar; Domain=.foo.com; %s" % expires)
- interact_netscape(c, "http://www.foo.com/",
- "fooc=bar; Domain=www.foo.com; %s" % expires)
-
- def save_and_restore(cj, ignore_discard, filename=filename):
- from mechanize import MozillaCookieJar, DefaultCookiePolicy
- try:
- cj.save(ignore_discard=ignore_discard)
- new_c = MozillaCookieJar(filename,
- DefaultCookiePolicy(rfc2965=True))
- new_c.load(ignore_discard=ignore_discard)
- finally:
- try: os.unlink(filename)
- except OSError: pass
- return new_c
-
- new_c = save_and_restore(c, True)
- assert len(new_c) == 6 # none discarded
- assert repr(new_c).find("name='foo1', value='bar'") != -1
-
- new_c = save_and_restore(c, False)
- assert len(new_c) == 4 # 2 of them discarded on save
- assert repr(new_c).find("name='foo1', value='bar'") != -1
-
- def test_mozilla_cookiejar_embedded_tab(self):
- from mechanize import MozillaCookieJar
- filename = tempfile.mktemp()
- fh = open(filename, "w")
- try:
- fh.write(
- MozillaCookieJar.header + "\n" +
- "a.com\tFALSE\t/\tFALSE\t\tname\tval\tstillthevalue\n"
- "a.com\tFALSE\t/\tFALSE\t\tname2\tvalue\n")
- fh.close()
- cj = MozillaCookieJar(filename)
- cj.revert(ignore_discard=True)
- cookies = cj._cookies["a.com"]["/"]
- self.assertEquals(cookies["name"].value, "val\tstillthevalue")
- self.assertEquals(cookies["name2"].value, "value")
- finally:
- try:
- os.remove(filename)
- except OSError, exc:
- if exc.errno != errno.EEXIST:
- raise
-
- def test_mozilla_cookiejar_initial_dot_violation(self):
- from mechanize import MozillaCookieJar, LoadError
- filename = tempfile.mktemp()
- fh = open(filename, "w")
- try:
- fh.write(
- MozillaCookieJar.header + "\n" +
- ".a.com\tFALSE\t/\tFALSE\t\tname\tvalue\n")
- fh.close()
- cj = MozillaCookieJar(filename)
- self.assertRaises(LoadError, cj.revert, ignore_discard=True)
- finally:
- try:
- os.remove(filename)
- except OSError, exc:
- if exc.errno != errno.EEXIST:
- raise
-
def test_netscape_misc(self):
# Some additional Netscape cookies tests.
from mechanize import CookieJar, Request
More information about the wwwsearch-commits
mailing list