def test_put(self):
# PUT something for the first time
response = HTTPCaller()(r"""PUT /testfile.txt HTTP/1.1
Authorization: Basic bWdyOm1ncnB3
Content-Length: 20
Content-Type: text/plain
This is just a test.""")
self.assertEquals(response._response.getStatus(), 201)
self.assertEquals(response._response.getHeader("Location"),
"http://localhost/testfile.txt")
response = HTTPCaller()(r"""GET /testfile.txt HTTP/1.1
Authorization: Basic bWdyOm1ncnB3""")
self.assertEquals(response.getBody(), "This is just a test.")
# now modify it
response = HTTPCaller()(r"""PUT /testfile.txt HTTP/1.1
Authorization: Basic bWdyOm1ncnB3
Content-Length: 22
Content-Type: text/plain
And now it is modified.""")
self.assertEquals(response._response.getStatus(), 200)
self.assertEquals(response.getBody(), "")
response = HTTPCaller()(r"""GET /testfile.txt HTTP/1.1
Authorization: Basic bWdyOm1ncnB3""")
self.assertEquals(response.getBody(), "And now it is modified.")
def request(self, host, handler, request_body, verbose=0):
request = "POST %s HTTP/1.0\n" % (handler, )
request += "Content-Length: %i\n" % len(request_body)
request += "Content-Type: text/xml\n"
host, extra_headers, x509 = self.get_host_info(host)
if extra_headers:
request += "Authorization: %s\n" \
% (dict(extra_headers)["Authorization"],)
request += "\n" + request_body
response = HTTPCaller()(request, handle_errors=self.handleErrors)
errcode = response.getStatus()
errmsg = response.getStatusString()
# This is not the same way that the normal transport deals
# with the headers.
headers = response.getHeaders()
if errcode != 200:
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
return self._parse_response(StringIO.StringIO(response.getBody()),
sock=None)
def suiteFromPackage(name):
files = resource_listdir(__name__, name)
suite = unittest.TestSuite()
for filename in files:
if not filename.endswith('.py'):
continue
if filename == '__init__.py':
continue
if filename[0] in (
'.',
'#',
):
continue
dottedname = 'megrok.z3cpt.ftests.%s.%s' % (name, filename[:-3])
test = doctest.DocTestSuite(
dottedname,
setUp=setUp,
tearDown=tearDown,
checker=checker,
extraglobs=dict(http=HTTPCaller(),
getRootFolder=getRootFolder,
sync=sync),
optionflags=(doctest.ELLIPSIS + doctest.NORMALIZE_WHITESPACE +
doctest.REPORT_NDIFF))
test.layer = FunctionalLayer
suite.addTest(test)
return suite
def test_registered(self):
# The Navigation is registered and traversable over HTTP.
spph = self.makeSPPHWithChangelog()
lfa_url = spph.sourcepackagerelease.changelog.http_url
redir_url = (canonical_url(spph, path_only_if_possible=True) +
'/+files/changelog')
logout()
response = str(HTTPCaller()("GET %s HTTP/1.1\n\n" % redir_url))
self.assertThat(
response,
MatchesAll(Contains("HTTP/1.1 303 See Other"),
Contains("Location: %s" % lfa_url)))
def http_call(method, path, data=None, **kw):
"""Function to help make RESTful calls.
method - HTTP method to use
path - testbrowser style path
data - (body) data to submit
kw - any request parameters
"""
if path.startswith('http://localhost'):
path = path[len('http://localhost'):]
request_string = '%s %s HTTP/1.1\n' % (method, path)
for key, value in kw.items():
request_string += '%s: %s\n' % (key, value)
if data is not None:
request_string += '\r\n'
request_string += data
return HTTPCaller()(request_string, handle_errors=False)
def test_suite():
suite = unittest.TestSuite()
test_modules = ['catalog', 'xmlrpc']
for module in test_modules:
module_name = 'bookshelf.ftests.%s' % module
test = doctest.DocTestSuite(
module_name,
setUp=setUp,
tearDown=tearDown,
extraglobs=dict(http=HTTPCaller(),
getRootFolder=getRootFolder,
sync=sync),
optionflags=(doctest.ELLIPSIS + doctest.NORMALIZE_WHITESPACE +
doctest.REPORT_NDIFF))
test.layer = BookShelfFunctionalLayer
suite.addTest(test)
return suite
def FunctionalDocTestSuite(*paths, **kw):
globs = kw.setdefault('globs', {})
globs['http'] = HTTPCaller()
globs['getRootFolder'] = getRootFolder
globs['sync'] = sync
#kw['package'] = doctest._normalize_module(kw.get('package'))
kwsetUp = kw.get('setUp')
def setUp(test):
FunctionalTestSetup().setUp()
if kwsetUp is not None:
kwsetUp(test)
kw['setUp'] = setUp
kwtearDown = kw.get('tearDown')
def tearDown(test):
if kwtearDown is not None:
kwtearDown(test)
FunctionalTestSetup().tearDown()
kw['tearDown'] = tearDown
if 'optionflags' not in kw:
old = doctest.set_unittest_reportflags(0)
doctest.set_unittest_reportflags(old)
kw['optionflags'] = (old
| doctest.ELLIPSIS
| doctest.REPORT_NDIFF
| doctest.NORMALIZE_WHITESPACE)
suite = doctest.DocTestSuite(*paths, **kw)
suite.layer = Functional
return suite
def setUp(self):
TestCase.setUp(self)
self.http = HTTPCaller()
self.original_flag = haproxy.going_down_flag
self.addCleanup(haproxy.set_going_down_flag, self.original_flag)
def __init__(self, host):
httplib.HTTPConnection.__init__(self, host)
self.caller = HTTPCaller()
def __init__(self, host, timeout=None):
from zope.app.testing.functional import HTTPCaller
self.caller = HTTPCaller()
self.host = host
def serve(self, url=None, port=8000):
if url is None:
url = self.url
startServer(HTTPCaller(), url, self.username, self.password, port=port)
def http(indented_request_string, http_caller=HTTPCaller()):
"""Dedent the request string and perform the HTTP request."""
rq = textwrap.dedent(indented_request_string).strip()
return http_caller(rq, handle_errors=False)
