def testIfModSince(self):
now = time.time()
e = {'SERVER_NAME': 'foo',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET'}
# not modified since
t_notmod = rfc1123_date(now)
e['HTTP_IF_MODIFIED_SINCE'] = t_notmod
out = BytesIO()
resp = HTTPResponse(stdout=out)
req = HTTPRequest(sys.stdin, e, resp)
data = self.file.index_html(req, resp)
self.assertEqual(resp.getStatus(), 304)
self.assertEqual(data, b'')
# modified since
t_mod = rfc1123_date(now - 100)
e['HTTP_IF_MODIFIED_SINCE'] = t_mod
out = BytesIO()
resp = HTTPResponse(stdout=out)
req = HTTPRequest(sys.stdin, e, resp)
data = self.file.index_html(req, resp)
self.assertEqual(resp.getStatus(), 200)
self.assertEqual(data, bytes(self.file.data))
def getRenderingTemplate(self, templatename, request=None):
"""
"""
skin = self.portal_skins.cmfplomino_templates
if hasattr(skin, templatename):
pt = getattr(skin, templatename)
if request:
pt.REQUEST = request
else:
request = getattr(pt, 'REQUEST', None)
proper_request = request and pt.REQUEST.__class__.__name__ == 'HTTPRequest'
if not proper_request:
# XXX What *else* could REQUEST be here?
# we are not in an actual web context, but we a need a
# request object to have the template working
response = HTTPResponse(stdout=sys.stdout)
env = {
'SERVER_NAME': 'fake_server',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET'
}
pt.REQUEST = HTTPRequest(sys.stdin, env, response)
# we also need a RESPONSE
if not pt.REQUEST.has_key('RESPONSE'):
pt.REQUEST['RESPONSE'] = HTTPResponse()
return pt
else:
return None
def getRenderingTemplate(self, templatename, request=None):
""" Look up a Plomino form or field template from portal skin layers.
"""
# The portal_skins machinery will look through layers in order
if hasattr(self.portal_skins, templatename):
pt = getattr(self.portal_skins, templatename)
if request:
pt.REQUEST = request
else:
request = getattr(pt, 'REQUEST', None)
proper_request = (request and pt.REQUEST.__class__.__name__
== 'HTTPRequest')
if not proper_request:
# XXX What *else* could REQUEST be here?
# we are not in an actual web context, but we a need a
# request object to have the template working
response = HTTPResponse(stdout=sys.stdout)
env = {
'SERVER_NAME': 'fake_server',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET'
}
pt.REQUEST = HTTPRequest(sys.stdin, env, response)
# we also need a RESPONSE
if 'RESPONSE' not in pt.REQUEST:
pt.REQUEST['RESPONSE'] = HTTPResponse()
return pt
def test_setHeader_drops_LF(self):
from ZPublisher.HTTPResponse import HTTPResponse
response = HTTPResponse()
response.setHeader('Location',
'http://www.ietf.org/rfc/\nrfc2616.txt')
self.assertEqual(response.headers['location'],
'http://www.ietf.org/rfc/rfc2616.txt')
def test_no_registry(self):
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished()
GZipTransform(published, request).transformUnicode(u"", "utf-8")
self.assertEqual(0, response.enableHTTPCompression(query=True))
def test_no_registry(self):
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished()
GZipTransform(published, request).transformUnicode(u"", "utf-8")
self.assertEquals(0, response.enableHTTPCompression(query=True))
def setBody(self, body, title='', is_error=0):
if isinstance(body, file) or IStreamIterator.providedBy(body):
body.seek(0, 2)
length = body.tell()
body.seek(0)
self.setHeader('Content-Length', '%d' % length)
self.body = body
else:
HTTPResponse.setBody(self, body, title, is_error)
def setBody(self, body, title='', is_error=0):
if isinstance(body, file) or IStreamIterator.providedBy(body):
body.seek(0, 2)
length = body.tell()
body.seek(0)
self.setHeader('Content-Length', '%d' % length)
self.body = body
else:
HTTPResponse.setBody(self, body, title, is_error)
def testRangeSupport(self):
"""
functionnal test of range support
"""
self.loginAsPortalOwner()
# Create content
content_id = 'test_file'
file_content = self.addFileByFileUpload(self.test_folder, content_id)
# Get file field
file_field = file_content.getField('file')
file_content = file_field.get(file_content)
# do an simple request
e = {
'SERVER_NAME': 'foo',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET'
}
out = StringIO()
resp = HTTPResponse(stdout=out)
req = HTTPRequest(sys.stdin, e, resp)
req.RESPONSE = resp
data = file_content.index_html(req, resp)
self.failUnless(
len(data) == len(file_content), 'not good lenght data ')
# now do an range request with one range
e = {
'SERVER_NAME': 'foo',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET',
'HTTP_RANGE': 'bytes=0-10'
}
resp = HTTPResponse(stdout=out)
req = HTTPRequest(sys.stdin, e, resp)
req.RESPONSE = resp
data = file_content.index_html(req, resp)
read_data = ''
for d in data:
read_data += d
self.failUnless(
len(read_data) == 11, 'not good lenght data <%s>' % len(read_data))
# now mulitple range
e = {
'SERVER_NAME': 'foo',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET',
'HTTP_RANGE': 'bytes=0-10, 50-80'
}
resp = HTTPResponse(stdout=out)
req = HTTPRequest(sys.stdin, e, resp)
req.RESPONSE = resp
data = file_content.index_html(req, resp)
def setBody(self, body, title='', is_error=0, **kw):
""" Accept either a stream iterator or a string as the body """
if IStreamIterator.isImplementedBy(body):
assert(self.headers.has_key('content-length'))
# wrap the iterator up in a producer that medusa can understand
self._bodyproducer = iterator_producer(body)
HTTPResponse.setBody(self, '', title, is_error, **kw)
return self
else:
HTTPResponse.setBody(self, body, title, is_error, **kw)
def setBody(self, body, title='', is_error=0, **kw):
""" Accept either a stream iterator or a string as the body """
if IStreamIterator.providedBy(body):
assert (self.headers.has_key('content-length'))
# wrap the iterator up in a producer that medusa can understand
self._bodyproducer = iterator_producer(body)
HTTPResponse.setBody(self, '', title, is_error, **kw)
return self
else:
HTTPResponse.setBody(self, body, title, is_error, **kw)
def testSwordService(self):
request = self.portal.REQUEST
# Check that 'sword' ends up at a browser view
view = self.portal.restrictedTraverse('sword')
assert isinstance(view, BrowserView)
# Test service-document
view = self.portal.unrestrictedTraverse('sword/servicedocument')
assert isinstance(view, ServiceDocument)
assert "<sword:error" not in view()
# Upload a zip file
zipfilename = os.path.join(DIRNAME, 'data', 'multipart.txt')
zipfile = open(zipfilename, 'r')
env = {
'CONTENT_TYPE': 'application/zip',
'CONTENT_LENGTH': os.path.getsize(zipfilename),
'CONTENT_DISPOSITION': 'attachment; filename=multipart.txt',
'REQUEST_METHOD': 'POST',
'SERVER_NAME': 'nohost',
'SERVER_PORT': '80',
'IN_PROGRESS': 'true',
}
uploadresponse = HTTPResponse(stdout=StringIO())
uploadrequest = clone_request(self.app.REQUEST, uploadresponse, env)
uploadrequest.set('BODYFILE', zipfile)
# Fake PARENTS
uploadrequest.set('PARENTS', [self.folder])
# Call the sword view on this request to perform the upload
self.setRoles(('Manager',))
xml = getMultiAdapter(
(self.folder, uploadrequest), Interface, 'sword')()
zipfile.close()
assert bool(xml), "Upload view does not return a result"
assert "<sword:error" not in xml, xml
# Test that we can still reach the edit-iri
assert self.folder.unrestrictedTraverse('multipart-txt/sword/edit')
# Test publish
env = {
'CONTENT_LENGTH': '0',
'REQUEST_METHOD': 'POST',
'SERVER_NAME': 'nohost',
'SERVER_PORT': '80'
}
publishresponse = HTTPResponse(stdout=StringIO())
publishrequest = clone_request(self.app.REQUEST, publishresponse, env)
publishrequest.set('PARENTS', [self.folder])
xml = getMultiAdapter(
(self.folder['multipart-txt'], publishrequest), ISWORDEditIRI)()
self.assertTrue(bool(xml), "Publish returned nothing")
self.assertTrue("<sword:error" not in xml, xml)
def testStreaming(self):
out = StringIO()
response = HTTPResponse(stdout=out)
response.write('datachunk1')
response.write('datachunk2')
events = self.reporter.events
self.assertEqual(len(events), 1)
self.assert_(isinstance(events[0], PubBeforeStreaming))
self.assertEqual(events[0].response, response)
self.assertTrue('datachunk1datachunk2' in out.getvalue())
def testStreaming(self):
out = StringIO()
response = HTTPResponse(stdout=out)
response.write('datachunk1')
response.write('datachunk2')
events = self.reporter.events
self.assertEqual(len(events), 1)
self.assert_(isinstance(events[0], PubBeforeStreaming))
self.assertEqual(events[0].response, response)
self.assertTrue('datachunk1datachunk2' in out.getvalue())
def test_disabled(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished()
GZipTransform(published, request).transformUnicode(u"", "utf-8")
self.assertEquals(0, response.enableHTTPCompression(query=True))
def test_disabled(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished()
GZipTransform(published, request).transformUnicode(u"", "utf-8")
self.assertEqual(0, response.enableHTTPCompression(query=True))
def FakeRequest(method="GET", add_auth=False, **kwargs):
environ = {}
environ.setdefault("SERVER_NAME", "foo")
environ.setdefault("SERVER_PORT", "80")
environ.setdefault("REQUEST_METHOD", method)
if api.env.plone_version() < "5.2":
# manually set stdout for Plone < 5.2
request = HTTPRequest(sys.stdin, environ,
HTTPResponse(stdout=BytesIO()))
else:
request = HTTPRequest(sys.stdin, environ, HTTPResponse())
request.form = kwargs
if add_auth:
request.form["_authenticator"] = plone.protect.createToken()
return request
def wrap_with_request(app):
from StringIO import StringIO
from ZPublisher.HTTPRequest import HTTPRequest
from ZPublisher.HTTPResponse import HTTPResponse
from Acquisition import Implicit
class FakeRootObject(Implicit):
pass
fake_root = FakeRootObject()
fake_root.app = app
stdin = StringIO()
environ = {
'REQUEST_METHOD': 'GET',
'SERVER_NAME': 'nohost',
'SERVER_PORT': '80'
}
request = HTTPRequest(stdin, environ, HTTPResponse(), clean=1)
anonymous_user = fake_root.app.acl_users._nobody
request.AUTHENTICATED_USER = anonymous_user
fake_root.REQUEST = request
return fake_root
def test_LastModified(self):
from plone.app.caching.operations.etags import LastModified
mod = datetime(2010, 1, 2, 3, 4, 5, 6, tzlocal())
utcStamp = time.mktime(mod.utctimetuple())
class DummyLastModified(object):
implements(ILastModified)
adapts(DummyPublished)
def __init__(self, context):
self.context = context
def __call__(self):
return mod
provideAdapter(DummyLastModified)
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished(DummyContext())
etag = LastModified(published, request)
self.assertEqual(str(utcStamp), etag())
def test_CatalogCounter(self):
from plone.app.caching.operations.etags import CatalogCounter
class DummyCatalog(object):
def getCounter(self):
return 10
class DummyTools(object):
implements(Interface)
adapts(DummyContext, Interface)
def __init__(self, context, request):
pass
def catalog(self):
return DummyCatalog()
provideAdapter(DummyTools, name=u"plone_tools")
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished(DummyContext())
etag = CatalogCounter(published, request)
self.assertEqual('10', etag())
def test_default_viewname_overrides_fti(self):
response = HTTPResponse()
environment = {
'URL': '',
'PARENTS': [self.site],
'REQUEST_METHOD': 'GET',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET',
'steps': [],
'SERVER_NAME': 'localhost',
'_hacked_path': 0
}
r = HTTPRequest(StringIO(), environment, response)
r.other.update(environment)
alsoProvides(r, IBrowserRequest)
# we define a Zope3-style default view name for which a view
# actually exists
defineDefaultViewName('index.html', DummyContent)
provideAdapter(DummyView, (DummyContent, IBrowserRequest),
IBrowserView, 'index.html')
r.traverse('foo')
self.assertEqual(r.URL, '/foo/index.html')
self.assertEqual(r.response.base, '/foo/')
def _getContext(app):
request = HTTPRequest(None, {
'SERVER_NAME': 'localhost',
'SERVER_PORT': '8080',
'REQUEST_METHOD': 'GET'
}, HTTPResponse(stdout=None))
return app.__of__(RequestContainer(REQUEST=request))
def test_Roles_member(self):
from plone.app.caching.operations.etags import Roles
class DummyMember(object):
def getRolesInContext(self, context):
return ['Member', 'Manager']
class DummyPortalState(object):
implements(Interface)
adapts(DummyContext, Interface)
def __init__(self, context, request):
pass
def anonymous(self):
return False
def member(self):
return DummyMember()
provideAdapter(DummyPortalState, name=u"plone_portal_state")
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished(DummyContext())
etag = Roles(published, request)
self.assertEqual('Manager;Member', etag())
def test_UserID_member(self):
from plone.app.caching.operations.etags import UserID
class DummyMember(object):
def getId(self):
return 'bob'
class DummyPortalState(object):
implements(Interface)
adapts(DummyContext, Interface)
def __init__(self, context, request):
pass
def member(self):
return DummyMember()
provideAdapter(DummyPortalState, name=u"plone_portal_state")
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished(DummyContext())
etag = UserID(published, request)
self.assertEqual('bob', etag())
def test_Roles_anonymous(self):
from plone.app.caching.operations.etags import Roles
@implementer(Interface)
@adapter(DummyContext, Interface)
class DummyPortalState(object):
def __init__(self, context, request):
pass
def anonymous(self):
return True
def member(self):
return None
provideAdapter(DummyPortalState, name=u'plone_portal_state')
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished(DummyContext())
etag = Roles(published, request)
self.assertEqual('Anonymous', etag())
def test_enabled_accepted(self):
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(IPloneCacheSettings)
ploneSettings = registry.forInterface(IPloneCacheSettings)
ploneSettings.enableCompression = True
environ = {'SERVER_NAME': 'example.com', 'SERVER_PORT': '80', 'HTTP_ACCEPT_ENCODING': 'gzip'}
response = HTTPResponse()
request = HTTPRequest(StringIO(), environ, response)
published = DummyPublished()
GZipTransform(published, request).transformUnicode(u"", "utf-8")
self.assertEqual(1, response.enableHTTPCompression(query=True))
def _makeRequest(self,
stdin=None,
environ=None,
response=None,
clean=1,
stdout=None):
from ZPublisher.HTTPRequest import HTTPRequest
from ZPublisher.HTTPResponse import HTTPResponse
if stdin is None:
from StringIO import StringIO
stdin = StringIO()
if stdout is None:
from StringIO import StringIO
stdout = StringIO()
if environ is None:
environ = {}
if 'SERVER_NAME' not in environ:
environ['SERVER_NAME'] = 'http://localhost'
if 'SERVER_PORT' not in environ:
environ['SERVER_PORT'] = '8080'
if response is None:
response = HTTPResponse(stdout=stdout)
req = HTTPRequest(stdin, environ, response, clean)
setDefaultSkin(req)
return req
def testMultipart(self):
view = self.portal.restrictedTraverse('sword')
# Upload a zip file
body_content = os.path.join(DIRNAME, 'data', 'multipart.txt')
file = open(body_content, 'r')
env = {
'CONTENT_TYPE': 'multipart/related; boundary="===============1338623209=="',
'SLUG': 'multipart',
'CONTENT_LENGTH': os.path.getsize(body_content),
'REQUEST_METHOD': 'POST',
'SERVER_NAME': 'nohost',
'SERVER_PORT': '80'
}
uploadresponse = HTTPResponse(stdout=StringIO())
uploadrequest = clone_request(self.app.REQUEST, uploadresponse, env)
uploadrequest.stdin = file
# Fake PARENTS
uploadrequest.set('PARENTS', [self.folder])
# Call the sword view on this request to perform the upload
self.setRoles(('Manager',))
adapter = getMultiAdapter(
(self.folder, uploadrequest), Interface, 'sword')
xml = adapter()
file.close()
self.assertTrue(bool(xml), "Upload view does not return a result")
self.assertTrue("<sword:error" not in xml, xml)
self.assertTrue('multipart' in self.folder.objectIds(), "upload failed")
def listHeaders(self):
result = []
if self._server_version:
result.append(('Server', self._server_version))
result.append(('Date', build_http_date(_now())))
result.extend(HTTPResponse.listHeaders(self))
return result
def listHeaders(self):
result = []
if self._server_version:
result.append(('Server', self._server_version))
result.append(('Date', build_http_date(_now())))
result.extend(HTTPResponse.listHeaders(self))
return result
def makeBaseRequest(self):
response = HTTPResponse()
environment = { 'URL': '',
'PARENTS': [self.root],
'steps': [],
'_hacked_path': 0,
'_test_counter': 0,
'response': response }
return BaseRequest(environment)
def test_basic(self):
response = HTTPResponse()
self.setCookie(response, "secret", "euphorie", "123")
self.assertTrue('euphorie' in response.cookies)
cookie = response.cookies['euphorie']
self.assertTrue('expires' not in cookie)
self.assertEqual(cookie['path'], '/')
self.assertEqual(cookie['http_only'], True)
self.assertEqual(cookie['value'], 's2QukE8flTyx94ketu53fjEyMw==')
def _getContext(app):
resp = HTTPResponse(stdout=None)
env = {
"SERVER_NAME": "localhost",
"SERVER_PORT": "8080",
"REQUEST_METHOD": "GET",
}
req = HTTPRequest(None, env, resp)
return app.__of__(RequestContainer(REQUEST=req))
def aputrequest(file, content_type):
resp = HTTPResponse(stdout=sys.stdout)
environ = {}
environ['SERVER_NAME'] = 'foo'
environ['SERVER_PORT'] = '80'
environ['REQUEST_METHOD'] = 'PUT'
environ['CONTENT_TYPE'] = content_type
req = HTTPRequest(stdin=file, environ=environ, response=resp)
return req
def create_request():
""" fake request
"""
# Create a request to work with
response = HTTPResponse(stdout=sys.stdout)
env = {'SERVER_NAME': 'fake_server',
'SERVER_PORT': '80',
'REQUEST_METHOD': 'GET'}
return HTTPRequest(sys.stdin, env, response)
def FakeRequest(method='GET', add_auth=False, **kwargs):
environ = {}
environ.setdefault('SERVER_NAME', 'foo')
environ.setdefault('SERVER_PORT', '80')
environ.setdefault('REQUEST_METHOD', method)
request = HTTPRequest(sys.stdin, environ, HTTPResponse(stdout=StringIO()))
request.form = kwargs
if add_auth:
request.form['_authenticator'] = plone.protect.createToken()
return request
def _getContext(self, app):
resp = HTTPResponse(stdout=None)
env = {
'SERVER_NAME': 'localhost',
'SERVER_PORT': '8080',
'REQUEST_METHOD': 'GET'
}
req = HTTPRequest(None, env, resp)
app.__of__(RequestContainer(REQUEST=req))
return app
def testCSRF(self):
""" test csrf protection """
# for this test, we need a bit more serious request simulation
from ZPublisher.HTTPRequest import HTTPRequest
from ZPublisher.HTTPResponse import HTTPResponse
environ = {}
environ.setdefault('SERVER_NAME', 'foo')
environ.setdefault('SERVER_PORT', '80')
environ.setdefault('REQUEST_METHOD', 'POST')
request = HTTPRequest(sys.stdin,
environ,
HTTPResponse(stdout=sys.stdout))
request.form = \
{'topic':'test subject',
'replyto':'*****@*****.**',
'comments':'test comments'}
self.ff1.checkAuthenticator = True
self.assertRaises(zExceptions.Forbidden, self.ff1.fgvalidate, request)
# with authenticator... no error
tag = AuthenticatorView('context', 'request').authenticator()
token = tag.split('"')[5]
request.form['_authenticator'] = token
errors = self.ff1.fgvalidate(REQUEST=request)
self.assertEqual( errors, {} )
# sneaky GET request
environ['REQUEST_METHOD'] = 'GET'
request = HTTPRequest(sys.stdin,
environ,
HTTPResponse(stdout=sys.stdout))
self.assertRaises(zExceptions.Forbidden, self.ff1.fgvalidate, request)
# bad authenticator
request.form['_authenticator'] = 'inauthentic'
request = HTTPRequest(sys.stdin,
environ,
HTTPResponse(stdout=sys.stdout))
self.assertRaises(zExceptions.Forbidden, self.ff1.fgvalidate, request)
def setBody(self, body, title='', is_error=0, **kw):
""" Accept either a stream iterator or a string as the body """
if not IStreamIterator.providedBy(body):
return HTTPResponse.setBody(self, body, title, is_error, **kw)
assert not self._wrote
if isinstance(body, BlobStreamIterator):
body = body.blob # A BlobFile
if hasattr(body, 'seek') and hasattr(body, 'read') and hasattr(body, 'close'):
self.stdout = body
self._wrote = 1
return
try:
while True:
chunk = body.next()
self.write(chunk)
except StopIteration:
pass
def process_wrapper(pid, request_body, request_environ):
# Sets up everything we need to run a view method in a new Zope-ish
# context, then runs it and stores the result for later retrieval.
_process = None
def my_mapply(object, positional=(), keyword={},
debug=None, maybe=None,
missing_name=None,
handle_class=None,
context=None, bind=0):
if not isinstance(keyword, Mapping):
keyword = {}
keyword['process_id'] = pid
args = (getattr(object, '__run__', object),)
kwargs = dict(positional=positional,
keyword=keyword,
debug=debug,
maybe=maybe,
context=context,
bind=bind
)
if missing_name is not None:
kwargs['missing_name'] = missing_name
if handle_class is not None:
kwargs['handle_class'] = handle_class
return mapply(*args, **kwargs)
response = HTTPResponse(stdout=StringIO(), stderr=StringIO())
request = HTTPRequest(StringIO(request_body), request_environ, response)
request.set('process_id', pid)
import Zope2
app = Zope2.bobo_application.__bobo_traverse__(request)
reg = getProcessRegistry(app)
_process = reg.get(pid)
# Run
try:
try:
response = publish(request, 'Zope2', [None], mapply=my_mapply)
# We can't just pass the response back, as the data streams will not
# be set up right.
attr = (hasattr(response, 'cookies') and 'cookies') or \
(hasattr(response, '_cookies') and '_cookies')
cookies = deepcopy(getattr(response, attr))
if IHTTPResponse.providedBy(response):
_process['result'] = (response.getStatus(),
dict(response.getHeaders()),
cookies,
response.consumeBody())
else:
# Currently, ZPublisher.HTTPResponse doesn't implement
# IHTTPResponse, even though HTTPRequest implements
# IHTTPRequest.
_process['result'] = (response.getStatus(),
dict(response.headers),
cookies,
response.body)
except Exception, e:
# Set result to the exception raised
_process['result'] = e
raise
else:
def http(request_string, handle_errors=True):
"""Execute an HTTP request string via the publisher
This is used for HTTP doc tests.
"""
import urllib
import rfc822
from cStringIO import StringIO
from ZPublisher.HTTPResponse import HTTPResponse as Response
from ZServer.ZPublisher.Publish import publish_module
# Commit work done by previous python code.
transaction.commit()
# Discard leading white space to make call layout simpler
request_string = request_string.lstrip()
# Split off and parse the command line
l = request_string.find('\n')
command_line = request_string[:l].rstrip()
request_string = request_string[l + 1:]
method, path, protocol = command_line.split()
path = urllib.unquote(path)
instream = StringIO(request_string)
env = {"HTTP_HOST": 'localhost',
"HTTP_REFERER": 'localhost',
"REQUEST_METHOD": method,
"SERVER_PROTOCOL": protocol,
}
p = path.split('?', 1)
if len(p) == 1:
env['PATH_INFO'] = p[0]
elif len(p) == 2:
[env['PATH_INFO'], env['QUERY_STRING']] = p
else:
raise TypeError('')
header_output = HTTPHeaderOutput(
protocol, ('x-content-type-warning', 'x-powered-by',
'bobo-exception-type', 'bobo-exception-file',
'bobo-exception-value', 'bobo-exception-line'))
headers = [split_header(header)
for header in rfc822.Message(instream).headers]
# Store request body without headers
instream = StringIO(instream.read())
for name, value in headers:
name = ('_'.join(name.upper().split('-')))
if name not in ('CONTENT_TYPE', 'CONTENT_LENGTH'):
name = 'HTTP_' + name
env[name] = value.rstrip()
if 'HTTP_AUTHORIZATION' in env:
env['HTTP_AUTHORIZATION'] = auth_header(env['HTTP_AUTHORIZATION'])
outstream = StringIO()
response = Response(stdout=outstream, stderr=sys.stderr)
publish_module('Zope2',
response=response,
stdin=instream,
environ=env,
debug=not handle_errors)
header_output.setResponseStatus(response.getStatus(), response.errmsg)
header_output.setResponseHeaders(response.headers)
header_output.headersl.extend(response._cookie_list())
header_output.appendResponseHeaders(response.accumulated_headers)
sync()
return DocResponseWrapper(response, outstream, path, header_output)
def publish_module_standard(
module_name,
stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr,
environ=os.environ, debug=0, request=None, response=None):
must_die = 0
status = 200
after_list = [None]
try:
try:
if response is None:
response = Response(stdout=stdout, stderr=stderr)
else:
stdout = response.stdout
# debug is just used by tests (has nothing to do with debug_mode!)
response.handle_errors = not debug
if request is None:
request = Request(stdin, environ, response)
setRequest(request)
# make sure that the request we hand over has the
# default layer/skin set on it; subsequent code that
# wants to look up views will likely depend on it
if ISkinnable.providedBy(request):
setDefaultSkin(request)
response = publish(request, module_name, after_list, debug=debug)
except (SystemExit, ImportError):
# XXX: Rendered ImportErrors were never caught here because they
# were re-raised as string exceptions. Maybe we should handle
# ImportErrors like all other exceptions. Currently they are not
# re-raised at all, so they don't show up here.
must_die = sys.exc_info()
request.response.exception(1)
except:
# debug is just used by tests (has nothing to do with debug_mode!)
if debug:
raise
request.response.exception()
status = response.getStatus()
if response:
outputBody = getattr(response, 'outputBody', None)
if outputBody is not None:
outputBody()
else:
response = str(response)
if response:
stdout.write(response)
# The module defined a post-access function, call it
if after_list[0] is not None:
after_list[0]()
finally:
if request is not None:
request.close()
clearRequest()
if must_die:
# Try to turn exception value into an exit code.
try:
if hasattr(must_die[1], 'code'):
code = must_die[1].code
else:
code = int(must_die[1])
except:
code = must_die[1] and 1 or 0
if hasattr(request.response, '_requestShutdown'):
request.response._requestShutdown(code)
try:
reraise(must_die[0], must_die[1], must_die[2])
finally:
must_die = None
return status
