[wwwsearch-commits] r32770 - wwwsearch/mechanize/trunk/test
jjlee at codespeak.net
jjlee at codespeak.net
Sat Sep 30 20:46:39 CEST 2006
Author: jjlee
Date: Sat Sep 30 20:46:36 2006
New Revision: 32770
Added:
wwwsearch/mechanize/trunk/test/test_browser.py
- copied unchanged from r32768, wwwsearch/mechanize/trunk/test/test_mechanize.py
wwwsearch/mechanize/trunk/test/test_response.py
- copied unchanged from r32768, wwwsearch/mechanize/trunk/test/test_misc.py
Removed:
wwwsearch/mechanize/trunk/test/test_mechanize.py
wwwsearch/mechanize/trunk/test/test_misc.py
Log:
Rename some test files
Deleted: /wwwsearch/mechanize/trunk/test/test_mechanize.py
==============================================================================
--- /wwwsearch/mechanize/trunk/test/test_mechanize.py Sat Sep 30 20:46:36 2006
+++ (empty file)
@@ -1,720 +0,0 @@
-#!/usr/bin/env python
-"""Tests for mechanize.Browser."""
-
-import sys, os, random
-from unittest import TestCase
-import StringIO, re, urllib2
-
-import mechanize
-FACTORY_CLASSES = [mechanize.DefaultFactory]
-try:
- import BeautifulSoup
-except ImportError:
- import warnings
- warnings.warn("skipping tests involving BeautifulSoup")
-else:
- FACTORY_CLASSES.append(mechanize.RobustFactory)
-
-
-# XXX these 'mock' classes are badly in need of simplification / removal
-# (note this stuff is also used by test_useragent.py)
-class MockMethod:
- def __init__(self, meth_name, action, handle):
- self.meth_name = meth_name
- self.handle = handle
- self.action = action
- def __call__(self, *args):
- return apply(self.handle, (self.meth_name, self.action)+args)
-
-class MockHeaders(dict):
- def getheaders(self, name):
- name = name.lower()
- return [v for k, v in self.iteritems() if name == k.lower()]
-
-class MockResponse:
- closeable_response = None
- def __init__(self, url="http://example.com/", data=None, info=None):
- self.url = url
- self.fp = StringIO.StringIO(data)
- if info is None: info = {}
- self._info = MockHeaders(info)
- self.source = "%d%d" % (id(self), random.randint(0, sys.maxint-1))
- # otherwise we can't test for "same_response" in test_history
- self.read_complete = True
- def info(self): return self._info
- def geturl(self): return self.url
- def read(self, size=-1): return self.fp.read(size)
- def seek(self, whence):
- assert whence == 0
- self.fp.seek(0)
- def close(self): pass
- def get_data(self): pass
- def __getstate__(self):
- state = self.__dict__
- state['source'] = self.source
- return state
- def __setstate__(self, state):
- self.__dict__ = state
-
-def make_mock_handler():
- class MockHandler:
- processor_order = 500
- handler_order = -1
- def __init__(self, methods):
- self._define_methods(methods)
- def _define_methods(self, methods):
- for name, action in methods:
- if name.endswith("_open"):
- meth = MockMethod(name, action, self.handle)
- else:
- meth = MockMethod(name, action, self.process)
- setattr(self.__class__, name, meth)
- def handle(self, fn_name, response, *args, **kwds):
- self.parent.calls.append((self, fn_name, args, kwds))
- if response:
- if isinstance(response, urllib2.HTTPError):
- raise response
- r = response
- r.seek(0)
- else:
- r = MockResponse()
- req = args[0]
- r.url = req.get_full_url()
- return r
- def process(self, fn_name, action, *args, **kwds):
- self.parent.calls.append((self, fn_name, args, kwds))
- if fn_name.endswith("_request"):
- return args[0]
- else:
- return args[1]
- def close(self): pass
- def add_parent(self, parent):
- self.parent = parent
- self.parent.calls = []
- def __lt__(self, other):
- if not hasattr(other, "handler_order"):
- # Try to preserve the old behavior of having custom classes
- # inserted after default ones (works only for custom user
- # classes which are not aware of handler_order).
- return True
- return self.handler_order < other.handler_order
- return MockHandler
-
-class TestBrowser(mechanize.Browser):
- default_features = ["_seek"]
- default_others = []
- default_schemes = []
-
-
-class BrowserTests(TestCase):
-
- def test_referer(self):
- b = TestBrowser()
- url = "http://www.example.com/"
- r = MockResponse(url,
-"""<html>
-<head><title>Title</title></head>
-<body>
-<form name="form1">
- <input type="hidden" name="foo" value="bar"></input>
- <input type="submit"></input>
- </form>
-<a href="http://example.com/foo/bar.html" name="apples"></a>
-<a href="https://example.com/spam/eggs.html" name="secure"></a>
-<a href="blah://example.com/" name="pears"></a>
-</body>
-</html>
-""", {"content-type": "text/html"})
- b.add_handler(make_mock_handler()([("http_open", r)]))
-
- # Referer not added by .open()...
- req = mechanize.Request(url)
- b.open(req)
- self.assert_(req.get_header("Referer") is None)
- # ...even if we're visiting a document
- b.open(req)
- self.assert_(req.get_header("Referer") is None)
- # Referer added by .click_link() and .click()
- b.select_form("form1")
- req2 = b.click()
- self.assertEqual(req2.get_header("Referer"), url)
- r2 = b.open(req2)
- req3 = b.click_link(name="apples")
- self.assertEqual(req3.get_header("Referer"), url+"?foo=bar")
- # Referer not added when going from https to http URL
- b.add_handler(make_mock_handler()([("https_open", r)]))
- r3 = b.open(req3)
- req4 = b.click_link(name="secure")
- self.assertEqual(req4.get_header("Referer"),
- "http://example.com/foo/bar.html")
- r4 = b.open(req4)
- req5 = b.click_link(name="apples")
- self.assert_(not req5.has_header("Referer"))
- # Referer not added for non-http, non-https requests
- b.add_handler(make_mock_handler()([("blah_open", r)]))
- req6 = b.click_link(name="pears")
- self.assert_(not req6.has_header("Referer"))
- # Referer not added when going from non-http, non-https URL
- r4 = b.open(req6)
- req7 = b.click_link(name="apples")
- self.assert_(not req7.has_header("Referer"))
-
- # XXX Referer added for redirect
-
- def test_encoding(self):
- import mechanize
- from StringIO import StringIO
- import urllib, mimetools
- # always take first encoding, since that's the one from the real HTTP
- # headers, rather than from HTTP-EQUIV
- b = mechanize.Browser()
- for s, ct in [("", mechanize._html.DEFAULT_ENCODING),
-
- ("Foo: Bar\r\n\r\n", mechanize._html.DEFAULT_ENCODING),
-
- ("Content-Type: text/html; charset=UTF-8\r\n\r\n",
- "UTF-8"),
-
- ("Content-Type: text/html; charset=UTF-8\r\n"
- "Content-Type: text/html; charset=KOI8-R\r\n\r\n",
- "UTF-8"),
- ]:
- msg = mimetools.Message(StringIO(s))
- r = urllib.addinfourl(StringIO(""), msg, "http://www.example.com/")
- b.set_response(r)
- self.assertEqual(b.encoding(), ct)
-
- def test_history(self):
- import mechanize
-
- def same_response(ra, rb):
- return ra.source == rb.source
-
- b = TestBrowser()
- b.add_handler(make_mock_handler()([("http_open", None)]))
- self.assertRaises(mechanize.BrowserStateError, b.back)
- r1 = b.open("http://example.com/")
- self.assertRaises(mechanize.BrowserStateError, b.back)
- r2 = b.open("http://example.com/foo")
- self.assert_(same_response(b.back(), r1))
- r3 = b.open("http://example.com/bar")
- r4 = b.open("http://example.com/spam")
- self.assert_(same_response(b.back(), r3))
- self.assert_(same_response(b.back(), r1))
- self.assertRaises(mechanize.BrowserStateError, b.back)
- # reloading does a real HTTP fetch rather than using history cache
- r5 = b.reload()
- self.assert_(not same_response(r5, r1))
- # .geturl() gets fed through to b.response
- self.assertEquals(b.geturl(), "http://example.com/")
- # can go back n times
- r6 = b.open("spam")
- self.assertEquals(b.geturl(), "http://example.com/spam")
- r7 = b.open("/spam")
- self.assert_(same_response(b.response(), r7))
- self.assertEquals(b.geturl(), "http://example.com/spam")
- self.assert_(same_response(b.back(2), r5))
- self.assertEquals(b.geturl(), "http://example.com/")
- self.assertRaises(mechanize.BrowserStateError, b.back, 2)
- r8 = b.open("/spam")
-
- # even if we get a HTTPError, history and .response() should still get
- # updated
- error = urllib2.HTTPError("http://example.com/bad", 503, "Oops",
- MockHeaders(), StringIO.StringIO())
- b.add_handler(make_mock_handler()([("https_open", error)]))
- self.assertRaises(urllib2.HTTPError, b.open, "https://example.com/badreq")
- self.assertEqual(b.response().geturl(), error.geturl())
- self.assertEqual(b.request.get_full_url(), "https://example.com/badreq")
- self.assert_(same_response(b.back(), r8))
-
- b.close()
- # XXX assert BrowserStateError
-
- def test_reload_read_incomplete(self):
- import mechanize
- from mechanize._response import test_response
- class Browser(TestBrowser):
- def __init__(self):
- TestBrowser.__init__(self)
- self.reloaded = False
- def reload(self):
- self.reloaded = True
- TestBrowser.reload(self)
- br = Browser()
- data = "<html><head><title></title></head><body>%s</body></html>"
- data = data % ("The quick brown fox jumps over the lazy dog."*100)
- r = test_response(data, [("content-type", "text/html")])
- br.add_handler(make_mock_handler()([("http_open", r)]))
-
- # .reload() on .back() if the whole response hasn't already been read
- # (.read_incomplete is True)
- r = br.open(r.geturl())
- r.read(10)
- br.open('http://www.example.com/blah')
- self.failIf(br.reloaded)
- br.back()
- self.assert_(br.reloaded)
-
- # don't reload if already read
- br.reloaded = False
- br.response().read()
- br.open('http://www.example.com/blah')
- br.back()
- self.failIf(br.reloaded)
-
- def test_viewing_html(self):
- # XXX not testing multiple Content-Type headers
- import mechanize
- url = "http://example.com/"
-
- for allow_xhtml in False, True:
- for ct, expect in [
- (None, False),
- ("text/plain", False),
- ("text/html", True),
-
- # don't try to handle XML until we can do it right!
- ("text/xhtml", allow_xhtml),
- ("text/xml", allow_xhtml),
- ("application/xml", allow_xhtml),
- ("application/xhtml+xml", allow_xhtml),
-
- ("text/html; charset=blah", True),
- (" text/html ; charset=ook ", True),
- ]:
- b = TestBrowser(mechanize.DefaultFactory(
- i_want_broken_xhtml_support=allow_xhtml))
- hdrs = {}
- if ct is not None:
- hdrs["Content-Type"] = ct
- b.add_handler(make_mock_handler()([("http_open",
- MockResponse(url, "", hdrs))]))
- r = b.open(url)
- self.assertEqual(b.viewing_html(), expect)
-
- for allow_xhtml in False, True:
- for ext, expect in [
- (".htm", True),
- (".html", True),
-
- # don't try to handle XML until we can do it right!
- (".xhtml", allow_xhtml),
-
- (".html?foo=bar&a=b;whelk#kool", True),
- (".txt", False),
- (".xml", False),
- ("", False),
- ]:
- b = TestBrowser(mechanize.DefaultFactory(
- i_want_broken_xhtml_support=allow_xhtml))
- url = "http://example.com/foo"+ext
- b.add_handler(make_mock_handler()(
- [("http_open", MockResponse(url, "", {}))]))
- r = b.open(url)
- self.assertEqual(b.viewing_html(), expect)
-
- def test_empty(self):
- import mechanize
- url = "http://example.com/"
-
- b = TestBrowser()
- b.add_handler(make_mock_handler()([("http_open", MockResponse(url, "", {}))]))
- r = b.open(url)
- self.assert_(not b.viewing_html())
- self.assertRaises(mechanize.BrowserStateError, b.links)
- self.assertRaises(mechanize.BrowserStateError, b.forms)
- self.assertRaises(mechanize.BrowserStateError, b.title)
- self.assertRaises(mechanize.BrowserStateError, b.select_form)
- self.assertRaises(mechanize.BrowserStateError, b.select_form,
- name="blah")
- self.assertRaises(mechanize.BrowserStateError, b.find_link,
- name="blah")
-
- b = TestBrowser()
- r = MockResponse(url,
-"""<html>
-<head><title>Title</title></head>
-<body>
-</body>
-</html>
-""", {"content-type": "text/html"})
- b.add_handler(make_mock_handler()([("http_open", r)]))
- r = b.open(url)
- self.assertEqual(b.title(), "Title")
- self.assertEqual(len(list(b.links())), 0)
- self.assertEqual(len(list(b.forms())), 0)
- self.assertRaises(ValueError, b.select_form)
- self.assertRaises(mechanize.FormNotFoundError, b.select_form,
- name="blah")
- self.assertRaises(mechanize.FormNotFoundError, b.select_form,
- predicate=lambda x: True)
- self.assertRaises(mechanize.LinkNotFoundError, b.find_link,
- name="blah")
- self.assertRaises(mechanize.LinkNotFoundError, b.find_link,
- predicate=lambda x: True)
-
- def test_forms(self):
- for factory_class in FACTORY_CLASSES:
- self._test_forms(factory_class())
- def _test_forms(self, factory):
- import mechanize
- url = "http://example.com"
-
- b = TestBrowser(factory=factory)
- r = MockResponse(url,
-"""<html>
-<head><title>Title</title></head>
-<body>
-<form name="form1">
- <input type="text"></input>
- <input type="checkbox" name="cheeses" value="cheddar"></input>
- <input type="checkbox" name="cheeses" value="edam"></input>
- <input type="submit" name="one"></input>
-</form>
-<a href="http://example.com/foo/bar.html" name="apples">
-<form name="form2">
- <input type="submit" name="two">
-</form>
-</body>
-</html>
-""", {"content-type": "text/html"})
- b.add_handler(make_mock_handler()([("http_open", r)]))
- r = b.open(url)
-
- forms = list(b.forms())
- self.assertEqual(len(forms), 2)
- for got, expect in zip([f.name for f in forms], [
- "form1", "form2"]):
- self.assertEqual(got, expect)
-
- self.assertRaises(mechanize.FormNotFoundError, b.select_form, "foo")
-
- # no form is set yet
- self.assertRaises(AttributeError, getattr, b, "possible_items")
- b.select_form("form1")
- # now unknown methods are fed through to selected ClientForm.HTMLForm
- self.assertEqual(
- [i.name for i in b.find_control("cheeses").items],
- ["cheddar", "edam"])
- b["cheeses"] = ["cheddar", "edam"]
- self.assertEqual(b.click_pairs(), [
- ("cheeses", "cheddar"), ("cheeses", "edam"), ("one", "")])
-
- b.select_form(nr=1)
- self.assertEqual(b.name, "form2")
- self.assertEqual(b.click_pairs(), [("two", "")])
-
- def test_link_encoding(self):
- for factory_class in FACTORY_CLASSES:
- self._test_link_encoding(factory_class())
- def _test_link_encoding(self, factory):
- import urllib
- import mechanize
- from mechanize._html import clean_url
- url = "http://example.com/"
- for encoding in ["UTF-8", "latin-1"]:
- encoding_decl = "; charset=%s" % encoding
- b = TestBrowser(factory=factory)
- r = MockResponse(url, """\
-<a href="http://example.com/foo/bar——.html"
- name="name0——">blah——</a>
-""", #"
-{"content-type": "text/html%s" % encoding_decl})
- b.add_handler(make_mock_handler()([("http_open", r)]))
- r = b.open(url)
-
- Link = mechanize.Link
- try:
- mdashx2 = u"\u2014".encode(encoding)*2
- except UnicodeError:
- mdashx2 = '——'
- qmdashx2 = clean_url(mdashx2, encoding)
- # base_url, url, text, tag, attrs
- exp = Link(url, "http://example.com/foo/bar%s.html" % qmdashx2,
- "blah"+mdashx2, "a",
- [("href", "http://example.com/foo/bar%s.html" % mdashx2),
- ("name", "name0%s" % mdashx2)])
- # nr
- link = b.find_link()
-## print
-## print exp
-## print link
- self.assertEqual(link, exp)
-
- def test_link_whitespace(self):
- from mechanize import Link
- for factory_class in FACTORY_CLASSES:
- base_url = "http://example.com/"
- url = " http://example.com/foo.html%20+ "
- stripped_url = url.strip()
- html = '<a href="%s"></a>' % url
- b = TestBrowser(factory=factory_class())
- r = MockResponse(base_url, html, {"content-type": "text/html"})
- b.add_handler(make_mock_handler()([("http_open", r)]))
- r = b.open(base_url)
- link = b.find_link(nr=0)
- self.assertEqual(
- link,
- Link(base_url, stripped_url, "", "a", [("href", url)])
- )
-
- def test_links(self):
- for factory_class in FACTORY_CLASSES:
- self._test_links(factory_class())
- def _test_links(self, factory):
- import mechanize
- from mechanize import Link
- url = "http://example.com/"
-
- b = TestBrowser(factory=factory)
- r = MockResponse(url,
-"""<html>
-<head><title>Title</title></head>
-<body>
-<a href="http://example.com/foo/bar.html" name="apples"></a>
-<a name="pears"></a>
-<a href="spam" name="pears"></a>
-<area href="blah" name="foo"></area>
-<form name="form2">
- <input type="submit" name="two">
-</form>
-<frame name="name" href="href" src="src"></frame>
-<iframe name="name2" href="href" src="src"></iframe>
-<a name="name3" href="one">yada yada</a>
-<a name="pears" href="two" weird="stuff">rhubarb</a>
-<a></a>
-<iframe src="foo"></iframe>
-</body>
-</html>
-""", {"content-type": "text/html"})
- b.add_handler(make_mock_handler()([("http_open", r)]))
- r = b.open(url)
-
- exp_links = [
- # base_url, url, text, tag, attrs
- Link(url, "http://example.com/foo/bar.html", "", "a",
- [("href", "http://example.com/foo/bar.html"),
- ("name", "apples")]),
- Link(url, "spam", "", "a", [("href", "spam"), ("name", "pears")]),
- Link(url, "blah", None, "area",
- [("href", "blah"), ("name", "foo")]),
- Link(url, "src", None, "frame",
- [("name", "name"), ("href", "href"), ("src", "src")]),
- Link(url, "src", None, "iframe",
- [("name", "name2"), ("href", "href"), ("src", "src")]),
- Link(url, "one", "yada yada", "a",
- [("name", "name3"), ("href", "one")]),
- Link(url, "two", "rhubarb", "a",
- [("name", "pears"), ("href", "two"), ("weird", "stuff")]),
- Link(url, "foo", None, "iframe",
- [("src", "foo")]),
- ]
- links = list(b.links())
- self.assertEqual(len(links), len(exp_links))
- for got, expect in zip(links, exp_links):
- self.assertEqual(got, expect)
- # nr
- l = b.find_link()
- self.assertEqual(l.url, "http://example.com/foo/bar.html")
- l = b.find_link(nr=1)
- self.assertEqual(l.url, "spam")
- # text
- l = b.find_link(text="yada yada")
- self.assertEqual(l.url, "one")
- self.assertRaises(mechanize.LinkNotFoundError,
- b.find_link, text="da ya")
- l = b.find_link(text_regex=re.compile("da ya"))
- self.assertEqual(l.url, "one")
- l = b.find_link(text_regex="da ya")
- self.assertEqual(l.url, "one")
- # name
- l = b.find_link(name="name3")
- self.assertEqual(l.url, "one")
- l = b.find_link(name_regex=re.compile("oo"))
- self.assertEqual(l.url, "blah")
- l = b.find_link(name_regex="oo")
- self.assertEqual(l.url, "blah")
- # url
- l = b.find_link(url="spam")
- self.assertEqual(l.url, "spam")
- l = b.find_link(url_regex=re.compile("pam"))
- self.assertEqual(l.url, "spam")
- l = b.find_link(url_regex="pam")
- self.assertEqual(l.url, "spam")
- # tag
- l = b.find_link(tag="area")
- self.assertEqual(l.url, "blah")
- # predicate
- l = b.find_link(predicate=
- lambda l: dict(l.attrs).get("weird") == "stuff")
- self.assertEqual(l.url, "two")
- # combinations
- l = b.find_link(name="pears", nr=1)
- self.assertEqual(l.text, "rhubarb")
- l = b.find_link(url="src", nr=0, name="name2")
- self.assertEqual(l.tag, "iframe")
- self.assertEqual(l.url, "src")
- self.assertRaises(mechanize.LinkNotFoundError, b.find_link,
- url="src", nr=1, name="name2")
- l = b.find_link(tag="a", predicate=
- lambda l: dict(l.attrs).get("weird") == "stuff")
- self.assertEqual(l.url, "two")
-
- # .links()
- self.assertEqual(list(b.links(url="src")), [
- Link(url, url="src", text=None, tag="frame",
- attrs=[("name", "name"), ("href", "href"), ("src", "src")]),
- Link(url, url="src", text=None, tag="iframe",
- attrs=[("name", "name2"), ("href", "href"), ("src", "src")]),
- ])
-
- def test_base_uri(self):
- import mechanize
- url = "http://example.com/"
-
- for html, urls in [
- (
-"""<base href="http://www.python.org/foo/">
-<a href="bar/baz.html"></a>
-<a href="/bar/baz.html"></a>
-<a href="http://example.com/bar %2f%2Fblah;/baz@~._-.html"></a>
-""",
- [
- "http://www.python.org/foo/bar/baz.html",
- "http://www.python.org/bar/baz.html",
- "http://example.com/bar%20%2f%2Fblah;/baz@~._-.html",
- ]),
- (
-"""<a href="bar/baz.html"></a>
-<a href="/bar/baz.html"></a>
-<a href="http://example.com/bar/baz.html"></a>
-""",
- [
- "http://example.com/bar/baz.html",
- "http://example.com/bar/baz.html",
- "http://example.com/bar/baz.html",
- ]
- ),
- ]:
- b = TestBrowser()
- r = MockResponse(url, html, {"content-type": "text/html"})
- b.add_handler(make_mock_handler()([("http_open", r)]))
- r = b.open(url)
- self.assertEqual([link.absolute_url for link in b.links()], urls)
-
- def test_set_cookie(self):
- class CookieTestBrowser(TestBrowser):
- default_features = list(TestBrowser.default_features)+["_cookies"]
-
- # have to be visiting HTTP/HTTPS URL
- url = "ftp://example.com/"
- br = CookieTestBrowser()
- r = mechanize.make_response(
- "<html><head><title>Title</title></head><body></body></html>",
- [("content-type", "text/html")],
- url,
- 200, "OK",
- )
- br.add_handler(make_mock_handler()([("http_open", r)]))
- handler = br._ua_handlers["_cookies"]
- cj = handler.cookiejar
- self.assertRaises(mechanize.BrowserStateError,
- br.set_cookie, "foo=bar")
- self.assertEqual(len(cj), 0)
-
-
- url = "http://example.com/"
- br = CookieTestBrowser()
- r = mechanize.make_response(
- "<html><head><title>Title</title></head><body></body></html>",
- [("content-type", "text/html")],
- url,
- 200, "OK",
- )
- br.add_handler(make_mock_handler()([("http_open", r)]))
- handler = br._ua_handlers["_cookies"]
- cj = handler.cookiejar
-
- # have to be visiting a URL
- self.assertRaises(mechanize.BrowserStateError,
- br.set_cookie, "foo=bar")
- self.assertEqual(len(cj), 0)
-
-
- # normal case
- br.open(url)
- br.set_cookie("foo=bar")
- self.assertEqual(len(cj), 1)
- self.assertEqual(cj._cookies["example.com"]["/"]["foo"].value, "bar")
-
-
-class ResponseTests(TestCase):
-
- def test_set_response(self):
- import copy
- from mechanize import response_seek_wrapper
-
- br = TestBrowser()
- url = "http://example.com/"
- html = """<html><body><a href="spam">click me</a></body></html>"""
- headers = {"content-type": "text/html"}
- r = response_seek_wrapper(MockResponse(url, html, headers))
- br.add_handler(make_mock_handler()([("http_open", r)]))
-
- r = br.open(url)
- self.assertEqual(r.read(), html)
- r.seek(0)
- self.assertEqual(copy.copy(r).read(), html)
- self.assertEqual(list(br.links())[0].url, "spam")
-
- newhtml = """<html><body><a href="eggs">click me</a></body></html>"""
-
- r.set_data(newhtml)
- self.assertEqual(r.read(), newhtml)
- self.assertEqual(br.response().read(), html)
- br.response().set_data(newhtml)
- self.assertEqual(br.response().read(), html)
- self.assertEqual(list(br.links())[0].url, "spam")
- r.seek(0)
-
- br.set_response(r)
- self.assertEqual(br.response().read(), newhtml)
- self.assertEqual(list(br.links())[0].url, "eggs")
-
- def test_str(self):
- import mimetools
- from mechanize import _response
-
- br = TestBrowser()
- self.assertEqual(
- str(br),
- "<TestBrowser (not visiting a URL)>"
- )
-
- fp = StringIO.StringIO('<html><form name="f"><input /></form></html>')
- headers = mimetools.Message(
- StringIO.StringIO("Content-type: text/html"))
- response = _response.response_seek_wrapper(
- _response.closeable_response(
- fp, headers, "http://example.com/", 200, "OK"))
- br.set_response(response)
- self.assertEqual(
- str(br),
- "<TestBrowser visiting http://example.com/>"
- )
-
- br.select_form(nr=0)
- self.assertEqual(
- str(br),
- """\
-<TestBrowser visiting http://example.com/
- selected form:
- <f GET http://example.com/ application/x-www-form-urlencoded
- <TextControl(<None>=)>>
->""")
-
-
-if __name__ == "__main__":
- import unittest
- unittest.main()
Deleted: /wwwsearch/mechanize/trunk/test/test_misc.py
==============================================================================
--- /wwwsearch/mechanize/trunk/test/test_misc.py Sat Sep 30 20:46:36 2006
+++ (empty file)
@@ -1,218 +0,0 @@
-"""Tests for mechanize._response.seek_wrapper and friends."""
-
-import copy
-import cStringIO
-from unittest import TestCase
-
-class TestUnSeekable:
- def __init__(self, text):
- self._file = cStringIO.StringIO(text)
- self.log = []
-
- def tell(self): return self._file.tell()
-
- def seek(self, offset, whence=0): assert False
-
- def read(self, size=-1):
- self.log.append(("read", size))
- return self._file.read(size)
-
- def readline(self, size=-1):
- self.log.append(("readline", size))
- return self._file.readline(size)
-
- def readlines(self, sizehint=-1):
- self.log.append(("readlines", sizehint))
- return self._file.readlines(sizehint)
-
-class TestUnSeekableResponse(TestUnSeekable):
- def __init__(self, text, headers):
- TestUnSeekable.__init__(self, text)
- self.code = 200
- self.msg = "OK"
- self.headers = headers
- self.url = "http://example.com/"
-
- def geturl(self):
- return self.url
-
- def info(self):
- return self.headers
-
- def close(self):
- pass
-
-
-class SeekableTests(TestCase):
-
- text = """\
-The quick brown fox
-jumps over the lazy
-
-dog.
-
-"""
- text_lines = map(lambda l: l+"\n", text.split("\n")[:-1])
-
- def testSeekable(self):
- from mechanize._response import seek_wrapper
- text = self.text
- text_lines = self.text_lines
-
- for ii in range(1, 6):
- fh = TestUnSeekable(text)
- sfh = seek_wrapper(fh)
- test = getattr(self, "_test%d" % ii)
- test(sfh)
-
- # copies have independent seek positions
- fh = TestUnSeekable(text)
- sfh = seek_wrapper(fh)
- self._testCopy(sfh)
-
- def _testCopy(self, sfh):
- sfh2 = copy.copy(sfh)
- sfh.read(10)
- text = self.text
- self.assertEqual(sfh2.read(10), text[:10])
- sfh2.seek(5)
- self.assertEqual(sfh.read(10), text[10:20])
- self.assertEqual(sfh2.read(10), text[5:15])
- sfh.seek(0)
- sfh2.seek(0)
- return sfh2
-
- def _test1(self, sfh):
- text = self.text
- text_lines = self.text_lines
- assert sfh.read(10) == text[:10] # calls fh.read
- assert sfh.log[-1] == ("read", 10) # .log delegated to fh
- sfh.seek(0) # doesn't call fh.seek
- assert sfh.read(10) == text[:10] # doesn't call fh.read
- assert len(sfh.log) == 1
- sfh.seek(0)
- assert sfh.read(5) == text[:5] # read only part of cached data
- assert len(sfh.log) == 1
- sfh.seek(0)
- assert sfh.read(25) == text[:25] # calls fh.read
- assert sfh.log[1] == ("read", 15)
- lines = []
- sfh.seek(-1, 1)
- while 1:
- l = sfh.readline()
- if l == "": break
- lines.append(l)
- assert lines == ["s over the lazy\n"]+text_lines[2:]
- assert sfh.log[2:] == [("readline", -1)]*5
- sfh.seek(0)
- lines = []
- while 1:
- l = sfh.readline()
- if l == "": break
- lines.append(l)
- assert lines == text_lines
-
- def _test2(self, sfh):
- text = self.text
- sfh.read(5)
- sfh.seek(0)
- assert sfh.read() == text
- assert sfh.read() == ""
- sfh.seek(0)
- assert sfh.read() == text
- sfh.seek(0)
- assert sfh.readline(5) == "The q"
- assert sfh.read() == text[5:]
- sfh.seek(0)
- assert sfh.readline(5) == "The q"
- assert sfh.readline() == "uick brown fox\n"
-
- def _test3(self, sfh):
- text = self.text
- text_lines = self.text_lines
- sfh.read(25)
- sfh.seek(-1, 1)
- self.assertEqual(sfh.readlines(), ["s over the lazy\n"]+text_lines[2:])
- nr_logs = len(sfh.log)
- sfh.seek(0)
- assert sfh.readlines() == text_lines
-
- def _test4(self, sfh):
- text = self.text
- text_lines = self.text_lines
- count = 0
- limit = 10
- while count < limit:
- if count == 5:
- self.assertRaises(StopIteration, sfh.next)
- break
- else:
- sfh.next() == text_lines[count]
- count = count + 1
- else:
- assert False, "StopIteration not raised"
-
- def _test5(self, sfh):
- text = self.text
- sfh.read(10)
- sfh.seek(5)
- self.assert_(sfh.invariant())
- sfh.seek(0, 2)
- self.assert_(sfh.invariant())
- sfh.seek(0)
- self.assertEqual(sfh.read(), text)
-
- def testResponseSeekWrapper(self):
- from mechanize import response_seek_wrapper
- hdrs = {"Content-type": "text/html"}
- r = TestUnSeekableResponse(self.text, hdrs)
- rsw = response_seek_wrapper(r)
- rsw2 = self._testCopy(rsw)
- self.assert_(rsw is not rsw2)
- self.assertEqual(rsw.info(), rsw2.info())
- self.assert_(rsw.info() is not rsw2.info())
-
- # should be able to close already-closed object
- rsw2.close()
- rsw2.close()
-
- def testSetResponseData(self):
- from mechanize import response_seek_wrapper
- r = TestUnSeekableResponse(self.text, {'blah': 'yawn'})
- rsw = response_seek_wrapper(r)
- rsw.set_data("""\
-A Seeming somwhat more than View;
- That doth instruct the Mind
- In Things that ly behind,
-""")
- self.assertEqual(rsw.read(9), "A Seeming")
- self.assertEqual(rsw.read(13), " somwhat more")
- rsw.seek(0)
- self.assertEqual(rsw.read(9), "A Seeming")
- self.assertEqual(rsw.readline(), " somwhat more than View;\n")
- rsw.seek(0)
- self.assertEqual(rsw.readline(), "A Seeming somwhat more than View;\n")
- rsw.seek(-1, 1)
- self.assertEqual(rsw.read(7), "\n That")
-
- r = TestUnSeekableResponse(self.text, {'blah': 'yawn'})
- rsw = response_seek_wrapper(r)
- rsw.set_data(self.text)
- self._test2(rsw)
- rsw.seek(0)
- self._test4(rsw)
-
- def testGetResponseData(self):
- from mechanize import response_seek_wrapper
- r = TestUnSeekableResponse(self.text, {'blah': 'yawn'})
- rsw = response_seek_wrapper(r)
-
- self.assertEqual(rsw.get_data(), self.text)
- self._test2(rsw)
- rsw.seek(0)
- self._test4(rsw)
-
-
-if __name__ == "__main__":
- import unittest
- unittest.main()
More information about the wwwsearch-commits
mailing list