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 = StringIO()
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, '')
# modified since
t_mod = rfc1123_date(now - 100)
e['HTTP_IF_MODIFIED_SINCE'] = t_mod
out = StringIO()
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, str(self.file.data))
def testTrustedProxies(self):
TEST_ENVIRON = {
'REQUEST_METHOD': 'GET',
'SERVER_NAME': 'localhost',
'SERVER_PORT': '80',
'REMOTE_ADDR': '127.0.0.1',
'HTTP_X_FORWARDED_FOR': '10.1.20.30, 192.168.1.100',
}
from StringIO import StringIO
from ZPublisher.HTTPRequest import HTTPRequest, trusted_proxies
s = StringIO('')
env = TEST_ENVIRON.copy()
request = HTTPRequest(s, env, None)
self.assertEqual(request.getClientAddr(), '127.0.0.1')
trusted_proxies.append('127.0.0.1')
request = HTTPRequest(s, env, None)
self.assertEqual(request.getClientAddr(), '192.168.1.100')
trusted_proxies[0] = '192.168.1.100'
env = TEST_ENVIRON.copy()
env['REMOTE_ADDR'] = '192.168.1.100'
request = HTTPRequest(s, env, None)
self.assertEqual(request.getClientAddr(), '10.1.20.30')
env = TEST_ENVIRON.copy()
del env['REMOTE_ADDR']
request = HTTPRequest(s, env, None)
self.assertEqual(request.getClientAddr(), '')
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 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 create_request(base_request, body):
request = HTTPRequest(base_request.stdin, base_request._orig_env,
base_request.response)
for attr in base_request.__dict__.keys():
setattr(request, attr, getattr(base_request, attr))
request.set("BODY", body)
return request
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 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 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 _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_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_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_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 _make_composite(self):
from OFS.Folder import Folder
f = Folder()
f.getPhysicalPath = lambda: ()
f.getPhysicalRoot = lambda f=f: f
from ZPublisher.HTTPRequest import HTTPRequest
f.REQUEST = HTTPRequest('', dict(HTTP_HOST='localhost:8080'), {})
from Products.CompositePage.composite import Composite
f.composite = Composite()
f.composite._setId("composite")
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
t = ZopePageTemplate(id="template",
text=template_text,
content_type="text/html")
f.composite.template = t
from Products.CompositePage.slot import Slot
f.composite.filled_slots.slot_a = slot_a = Slot("slot_a")
t = f.composite.template
if t.pt_errors():
raise SyntaxError(t.pt_errors())
a1 = ZopePageTemplate(id="a1", text="<b>Slot A</b>")
f._setObject(a1.id, a1)
from Products.CompositePage.element import CompositeElement
e1 = CompositeElement('e1', f.a1)
slot_a._setObject(e1.id, e1)
return f.composite
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_update_preserves_mimetype(self):
self.folder.invokeFactory('DDocument', 'mydoc', title="My Doc")
doc = self.folder.mydoc
doc.setBody("""
An rst Document
===============
* Which
* has
* some
* bullet::
points.
* for testing""", mimetype="text/restructured")
doc.reindexObject()
mimetype = doc.getField('body').getContentType(doc)
self.assertEqual(mimetype, 'text/x-rst')
# update schema for all DDocuments and check if our type is preserved
request = HTTPRequest(sys.stdin,
{'SERVER_NAME': 'test', 'SERVER_PORT': '8080'},
{})
request.form['Archetypes.DDocument'] = True
request.form['update_all'] = True
self.portal.archetype_tool.manage_updateSchema(REQUEST=request)
doc = self.folder.mydoc
mimetype = doc.getField('body').getContentType(doc)
self.assertEqual(mimetype, 'text/x-rst')
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 call(self, method, args=(), errorValue=ERROR_MARKER):
path = self.servicePath[:] + [method]
response = Response()
env = {
'SERVER_NAME': 'dummy',
'SERVER_PORT': '8080',
'PATH_INFO': '/' + '/'.join(path)
}
request = HTTPRequest(None, env, response)
request.args = args
conn = self.db.open()
root = conn.root()
request['PARENTS'] = [root['Application']]
try:
try:
ZPublisher.Publish.publish(request, 'Zope2', [None])
except Exception, error:
# This thread should never crash, thus a blank except
log.error('Processor: ``%s()`` caused an error!' % method)
log.exception(error)
return errorValue is ERROR_MARKER and error or errorValue
finally:
request.close()
conn.close()
return request.response.body
def setUp(self):
self.request = HTTPRequest(sys.stdin, dict(SERVER_URL="dummy"), None)
KeyringTestCase.setUp(self)
def func(REQUEST=None):
return 1
self.func = protect(check)(func)
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_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 decodeQueryString(QueryString):
"""decode *QueryString* into a dictionary, as ZPublisher would do"""
r = HTTPRequest(None, {
'QUERY_STRING': QueryString,
'SERVER_URL': '',
}, None, 1)
r.processInputs()
return r.form
def send_response(self):
# create an output pipe by passing request to ZPublisher,
# and requesting a callback of self.log with the module
# name and PATH_INFO as an argument.
self.done = 1
response = PCGIResponse(stdout=PCGIPipe(self), stderr=StringIO())
request = HTTPRequest(self.data, self.env, response)
handle(self.server.module, request, response)
def get_requests_and_response(self):
out = StringIO()
s_req = '%s %s HTTP/%s' % ('GET', self.method, '1.0')
req = http_request(DummyChannel(self), s_req, 'GET', self.method,
'1.0', self.headers)
env = self.get_env(req)
resp = make_response(req, env)
zreq = HTTPRequest(out, env, resp)
return req, zreq, resp
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 _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 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 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 send_response(self):
"""
Create output pipes, request, and response objects. Give them
to ZPublisher for processing.
"""
response = FCGIResponse(stdout = FCGIPipe(self, FCGI_STDOUT),
stderr = StringIO())
response.setChannel(self)
request = HTTPRequest(self.stdin, self.env, response)
handle(self.server.module, request, 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
