def doRendering(self, fragmentClass):
"""
Verify that the given fragment class will render without raising an
exception.
"""
siteStore = Store()
loginSystem = LoginSystem(store=siteStore)
installOn(loginSystem, siteStore)
p = Product(store=siteStore, types=["xmantissa.webadmin.LocalUserBrowser",
"xmantissa.signup.SignupConfiguration"])
account = loginSystem.addAccount(u'testuser', u'localhost', None)
p.installProductOn(account.avatars.open())
f = fragmentClass(None, u'testuser', account)
p = LivePage(
docFactory=stan(
html[
head(render=directive('liveglue')),
body(render=lambda ctx, data: f)]))
f.setFragmentParent(p)
ctx = WovenContext()
req = FakeRequest()
ctx.remember(req, IRequest)
d = p.renderHTTP(ctx)
def rendered(ign):
p.action_close(None)
d.addCallback(rendered)
return d
def child_live(self, ctx):
"""
The 'live' namespace is reserved for Athena LivePages. By default in
Athena applications these resources are child resources of whatever URL
the live page ends up at, but this root URL is provided so that the
reliable message queuing logic can sidestep all resource traversal, and
therefore, all database queries. This is an important optimization,
since Athena's implementation assumes that HTTP hits to the message
queue resource are cheap.
@return: an L{athena.LivePage} instance.
"""
return LivePage(None, None)
def renderLiveFragment(fragment):
"""
Render the given fragment in a LivePage.
This can only work for fragments which can be rendered synchronously.
Fragments which involve Deferreds will be silently rendered incompletely.
@type fragment: L{nevow.athena.LiveFragment} or L{nevow.athena.LiveElement}
@param fragment: The page component to render.
@rtype: C{str}
@return: The result of rendering the fragment.
"""
page = LivePage(docFactory=stan(fragment))
fragment.setFragmentParent(page)
(request, context) = _makeContext()
page.renderHTTP(context)
page.action_close(context)
return request.v
def _render(self, element):
"""
Put the given L{IRenderer} provider into an L{athena.LivePage} and
render it. Return a Deferred which fires with the request object used
which is an instance of L{nevow.testutil.FakeRequest}.
"""
p = LivePage(docFactory=stan(html[head(
render=directive('liveglue')), body[invisible(
render=lambda ctx, data: element)]]))
element.setFragmentParent(p)
ctx = WovenContext()
req = FakeRequest()
ctx.remember(req, IRequest)
d = p.renderHTTP(ctx)
def rendered(ign):
p.action_close(None)
return req
d.addCallback(rendered)
return d
def test_rendering(self):
"""
Test that L{webadmin.UserInteractionFragment} renders without raising
any exceptions.
"""
f = UserInteractionFragment(self.browser)
p = LivePage(
docFactory=stan(
html[
head(render=directive('liveglue')),
body(render=lambda ctx, data: f)]))
f.setFragmentParent(p)
ctx = WovenContext()
req = FakeRequest()
ctx.remember(req, IRequest)
d = p.renderHTTP(ctx)
def rendered(ign):
p.action_close(None)
d.addCallback(rendered)
return d
