def test_fromContext(self):
r = FakeRequest(uri='/a/b/c')
urlpath = url.URL.fromContext(context.RequestContext(tag=r))
self.assertEqual('http://localhost/', str(urlpath))
r.prepath = ['a']
urlpath = url.URL.fromContext(context.RequestContext(tag=r))
self.assertEqual('http://localhost/a', str(urlpath))
r = FakeRequest(uri='/a/b/c?foo=bar')
r.prepath = ['a','b']
urlpath = url.URL.fromContext(context.RequestContext(tag=r))
self.assertEqual('http://localhost/a/b?foo=bar', str(urlpath))
def setupContext(self, precompile=False, setupRequest=lambda r:r):
fr = setupRequest(FakeRequest(uri='/', currentSegments=['']))
ctx = context.RequestContext(tag=fr)
ctx.remember(fr, inevow.IRequest)
ctx.remember(None, inevow.IData)
ctx = context.WovenContext(parent=ctx, precompile=precompile)
return ctx
def test_oneLanguage(self):
request = FakeRequest(headers={
'accept-language': 'fo',
})
ctx = context.RequestContext(tag=request)
r = inevow.ILanguages(ctx)
self.assertEqual(r, ['fo'])
def test_multipleLanguages(self):
request = FakeRequest(headers={
'accept-language': 'fo,ba,th',
})
ctx = context.RequestContext(tag=request)
r = inevow.ILanguages(ctx)
self.assertEquals(r, ['fo', 'ba', 'th'])
def test_quality_simple(self):
request = FakeRequest(headers={
'accept-language': 'fo;q=0.4',
})
ctx = context.RequestContext(tag=request)
r = inevow.ILanguages(ctx)
self.assertEquals(r, ['fo'])
def test_quality_sort(self):
request = FakeRequest(headers={
'accept-language': 'fo;q=0.4,ba;q=0.2,xy;q=0.9',
})
ctx = context.RequestContext(tag=request)
r = inevow.ILanguages(ctx)
self.assertEquals(r, ['xy', 'fo', 'ba'])
def process(self):
"""When a form is POSTed,
we create a cgi.FieldStorage instance using the data posted,
and set it as the request.fields attribute. This way, we can
get at information about filenames and mime-types of
files that were posted."""
if self.method == 'POST':
self.fields = cgi.FieldStorage(self.environ['wsgi.input'],
self.received_headers,
environ={'REQUEST_METHOD': 'POST'})
# set various default headers
self.setHeader('server', nevowversion)
year, month, day, hh, mm, ss, wd, y, z = time.gmtime(time.time())
# HTTP date string format
s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
weekdayname[wd], day, monthname[month], year, hh, mm, ss)
self.setHeader('date', s)
self.setHeader('content-type', 'text/html; charset=UTF-8')
# Resource Identification
self.prepath = []
self.postpath = map(unquote, self.path[1:].split('/'))
self.sitepath = []
requestContext = context.RequestContext(parent=self.site.context,
tag=self)
requestContext.remember((), inevow.ICurrentSegments)
requestContext.remember(tuple(self.postpath),
inevow.IRemainingSegments)
pageContext = self.site.getPageContextForRequestContext(requestContext)
return self.gotPageContext(pageContext)
def test_quality_invalid_notFloat(self):
request = FakeRequest(headers={
'accept-language': 'fo;q=0.4,ba;q=junk',
})
ctx = context.RequestContext(tag=request)
r = inevow.ILanguages(ctx)
self.assertEquals(r, ['ba', 'fo'])
def getResourceFor(self, root, url):
r = testutil.FakeRequest()
self.request = r
r.postpath = url.split('/')
ctx = context.RequestContext(tag=self.request)
return util.maybeDeferred(
appserver.NevowSite(root).getPageContextForRequestContext, ctx)
def process(self):
# extra request parsing
if self.method == 'POST':
t = self.content.tell()
self.content.seek(0)
self.fields = cgi.FieldStorage(self.content,
_DictHeaders(self.requestHeaders),
environ={'REQUEST_METHOD': 'POST'})
self.content.seek(t)
# get site from channel
self.site = self.channel.site
# set various default headers
self.setHeader('server', server.version)
self.setHeader('date', server.http.datetimeToString())
self.setHeader('content-type', "text/html; charset=UTF-8")
# Resource Identification
self.prepath = []
self.postpath = map(unquote, self.path[1:].split('/'))
self.sitepath = []
self.deferred = defer.Deferred()
requestContext = context.RequestContext(parent=self.site.context,
tag=self)
requestContext.remember((), inevow.ICurrentSegments)
requestContext.remember(tuple(self.postpath),
inevow.IRemainingSegments)
return self.site.getPageContextForRequestContext(
requestContext).addErrback(processingFailed, self,
requestContext).addCallback(
self.gotPageContext)
def getResourceFor(self, request):
"""DEPRECATED. Use getPageContextForRequestContext instead.
"""
warnings.warn(
"getResourceFor is deprecated, use getPageContextForRequestContext instead.",
stacklevel=2)
return self.getPageContextForRequestContext(
context.RequestContext(tag=request))
def deferredRender(res):
defres = req()
d = res.renderHTTP(
context.PageContext(tag=res,
parent=context.RequestContext(tag=defres)))
def accumulated(result, req):
return req.accumulator
return d.addCallback(accumulated, defres)
def deferredRender(res, req):
d = util.maybeDeferred(res.renderHTTP,
context.PageContext(
tag=res, parent=context.RequestContext(
tag=req)))
def done(result):
if isinstance(result, str):
req.write(result)
return req
d.addCallback(done)
return d
def flt(stan, quote=True, client=None):
"""Flatten some stan to a string suitable for embedding in a javascript string.
If quote is True, apostrophe, quote, and newline will be quoted
"""
fr = testutil.FakeRequest()
fr.getSession().setComponent(ILiveEvil, client)
ctx = context.RequestContext(tag=fr)
ctx.remember(None, inevow.IData)
fl = flatten(stan, ctx=ctx)
if quote:
fl = jquote(fl)
return fl
def process(typed, data, configurable=None, ctx=None):
if ctx is None:
from nevow.testutil import FakeRequest
from nevow import context
fr = FakeRequest()
if type(data) is dict:
fr.args = data
ctx = context.RequestContext(tag=fr)
ctx.remember(fr, inevow.IRequest)
ctx.remember(None, inevow.IData)
try:
return iformless.IInputProcessor(typed).process(ctx, configurable, data, autoConfigure=False)
except TypeError:
return iformless.IInputProcessor(typed).process(ctx, configurable, data)
def deferredRender(res):
defres = req()
d = util.maybeDeferred(
res.renderHTTP,
context.PageContext(tag=res,
parent=context.RequestContext(tag=defres)))
def done(result):
if isinstance(result, str):
defres.write(result)
defres.d.callback(defres.accumulator)
return result
d.addCallback(done)
return unittest.deferredResult(defres.d, 1)
def renderResource(uri, notFoundHandler=None):
"""Render a resource at some uri and return the response code and html.
"""
root = Root()
if notFoundHandler is not None:
root.remember(notFoundHandler, inevow.ICanHandleNotFound)
site = appserver.NevowSite(root)
ctx = context.SiteContext(tag=site)
request = testutil.FakeRequest(uri=uri)
ctx = context.RequestContext(parent=ctx, tag=request)
def waitmore(newctx):
return defer.maybeDeferred(newctx.tag.renderHTTP, newctx).addCallback(lambda html: (request.code, html))
return site.getPageContextForRequestContext(ctx).addCallback(waitmore)
def _doRender(page, ctx): """returns a deferred firing the result of page.renderHTTP(ctx). This is a helper for our nevow simulation. """ request = inevow.IRequest(ctx) if not hasattr(page, "renderHTTP"): return _requestDone(page, request, ctx) d = defer.maybeDeferred(page.renderHTTP, context.PageContext( tag=page, parent=context.RequestContext(tag=request))) d.addCallback(_requestDone, request, ctx) d.addErrback(_renderCrashAndBurn, ctx) return d
def deferredRender(res, request=None):
if request is None:
request = testutil.AccumulatingFakeRequest()
d = util.maybeDeferred(
res.renderHTTP,
context.PageContext(tag=res,
parent=context.RequestContext(tag=request)))
def done(result):
if isinstance(result, str):
request.write(result)
request.d.callback(request.accumulator)
return result
d.addCallback(done)
return request.d
def getResourceFor(root, url):
"""
Perform traversal for C{url} beginning at C{root}.
@param root: The L{nevow.inevow.IResource} at which to begin.
@param url: The relative path string of the url of the resource to
retrieve.
@type url: L{bytes}
@return: A L{Deferred} that fires with a L{PageContext} for the discovered
resource.
"""
request = testutil.FakeRequest()
request.postpath = url.split('/')
ctx = context.RequestContext(tag=request)
return util.maybeDeferred(
appserver.NevowSite(root).getPageContextForRequestContext, ctx)
def flt(stan, quote=True, client=None, handlerFactory=None):
"""Flatten some stan to a string suitable for embedding in a javascript
string.
If quote is True, apostrophe, quote, and newline will be quoted
"""
warnings.warn("[0.5] livepage.flt is deprecated. Don't use it.",
DeprecationWarning, 2)
from nevow import testutil
fr = testutil.FakeRequest()
ctx = context.RequestContext(tag=fr)
ctx.remember(client, IClientHandle)
ctx.remember(handlerFactory, IHandlerFactory)
ctx.remember(None, inevow.IData)
fl = flat.flatten(stan, ctx=ctx)
if quote:
fl = fl.replace('\\', '\\\\').replace("'", "\\'").replace('\n', '\\n')
return fl
def benchmark_longContextChainArg(self):
from nevow import testutil
ctx = context.RequestContext(tag=testutil.FakeRequest(
args=dict(foo=["foo"], bar=["bar"])))
for x in range(5):
## Do some factory contexts
ctx = TestContext(parent=ctx)
for x in range(100):
## Do a bunch of crap
ctx = context.WovenContext(parent=ctx)
## Look for some request arguments
loops = 1e4
before = time.clock()
for x in xrange(loops):
ignored = ctx.arg('foo')
ignored = ctx.arg('bar')
after = time.clock()
self.recordStat({"arg/(cpu sec)": loops / (after - before)})
def processInput(widget, name, data=None):
ctx = context.RequestContext(tag=FakeRequest())
return widget.processInput(ctx, name, {name: data})
def renderResource(self, u):
request = FakeRequest()
ctx = context.RequestContext(tag=request)
return util.maybeDeferred(inevow.IResource(u).renderHTTP, ctx).addCallback(
lambda r: (r, request.redirected_to))
def getResource(root, path):
ctx = context.RequestContext(tag=testutil.FakeRequest(uri=path))
return appserver.NevowSite(root).getPageContextForRequestContext(ctx).addCallback(
lambda newctx: newctx.tag)
def test_noLanguages(self):
request = FakeRequest(headers={})
ctx = context.RequestContext(tag=request)
r = inevow.ILanguages(ctx)
self.assertEquals(r, [])
def make_context(self, req):
ctx = context.RequestContext(tag=req)
ctx.remember(req, inevow.IRequest)
ctx.remember(None, inevow.IData)
ctx = context.WovenContext(parent=ctx, precompile=False)
return ctx
def renderWidget(widget, name, data=None):
ctx = context.RequestContext(tag=FakeRequest())
ctx.remember(None, inevow.IData)
return flat.flatten(iformal.IWidget(widget).render(ctx, name, {name:'bar'}, None), ctx)
def renderIt(self):
req = testutil.FakeRequest()
self.r.renderHTTP(context.PageContext(tag=self.r, parent=context.RequestContext(tag=req)))
return req
def getResource(root, path):
return appserver.NevowSite(root).getPageContextForRequestContext(
context.RequestContext(tag=testutil.FakeRequest(uri=path)))
