def test_synchronousFlatten(self):
"""
Flattening a L{Element} with no Deferreds using the old synchronous
flattener API returns a value synchronously.
"""
element = Element()
element.docFactory = stan(["hello, world"])
self.assertEqual(synchronousFlatten(element), "hello, world")
def test_synchronousFlatten(self):
"""
Flattening a L{Element} with no Deferreds using the old synchronous
flattener API returns a value synchronously.
"""
element = Element()
element.docFactory = stan(["hello, world"])
self.assertEqual(synchronousFlatten(element), "hello, world")
def test_synchronousFlattenError(self):
"""
If the old flattener encounters an exception while flattening an
L{IRenderable}, the exception is raised to the caller of the flattener
API.
"""
element = Element()
element.docFactory = stan(invisible(render=directive('foo')))
self.assertRaises(FlattenerError, synchronousFlatten, element)
def test_synchronousFlattenError(self):
"""
If the old flattener encounters an exception while flattening an
L{IRenderable}, the exception is raised to the caller of the flattener
API.
"""
element = Element()
element.docFactory = stan(invisible(render=directive('foo')))
self.assertRaises(FlattenerError, synchronousFlatten, element)
def test_flattenable(self):
"""
Flattening L{Element} instances with the new flatten function results in
the flattened version of whatever their C{render} method returns.
"""
element = Element()
element.docFactory = stan(["Hello, world"])
result = []
finished = newFlatten(FakeRequest(), element, False, False, result.append)
finished.addCallback(lambda ignored: "".join(result))
finished.addCallback(self.assertEqual, "Hello, world")
return finished
def test_oldFlattenableInAttribute(self):
"""
Flattening a L{Element} as the value of an attribute of a L{Tag} XML
attribute escapes the element's flattened document.
"""
result = []
element = Element()
element.docFactory = stan(['"&<>'])
request = FakeRequest()
context = WovenContext()
context.remember(request)
finished = oldFlatten(p(foo=element), context, result.append, lambda ign: ign)
finished.addCallback(lambda ign: "".join(result))
finished.addCallback(self.assertEqual, '<p foo=""&<>"></p>')
return finished
def test_oldFlattenable(self):
"""
Flattening L{Element} instances with the old flatten function results in
the flattened version of whatever their C{render} method returns.
"""
result = []
element = Element()
element.docFactory = stan(['"&<>'])
request = FakeRequest()
context = WovenContext()
context.remember(request)
finished = oldFlatten(element, context, result.append, lambda ign: ign)
finished.addCallback(lambda ign: "".join(result))
finished.addCallback(self.assertEqual, '"&<>')
return finished
def test_oldFlattenable(self):
"""
Flattening L{Element} instances with the old flatten function results in
the flattened version of whatever their C{render} method returns.
"""
result = []
element = Element()
element.docFactory = stan(['"&<>'])
request = FakeRequest()
context = WovenContext()
context.remember(request)
finished = oldFlatten(element, context, result.append, lambda ign: ign)
finished.addCallback(lambda ign: "".join(result))
finished.addCallback(self.assertEqual, '"&<>')
return finished
def test_missingDocumentFactory(self):
"""
Test that rendering a Element without a docFactory attribute raises
the appropriate exception.
"""
f = Element()
return self.assertFailure(self._render(f), MissingDocumentFactory)
def test_render(self):
"""
L{Element.render} loads a document from the C{docFactory} attribute and
returns it.
"""
args = []
preproc = object()
class DocFactory(object):
def load(self, ctx, preprocessors, precompile=None):
args.append(preprocessors)
return "result"
element = Element()
element.preprocessors = (preproc,)
element.docFactory = DocFactory()
self.assertEqual(element.render(None), "result")
self.assertEqual(args, [(preproc,)])
def test_missingRenderMethod(self):
"""
Test that rendering a Element and using a render directive in its
document factory fails if there is no available render method to
satisfy that directive.
"""
f = Element(docFactory=stan(directive('renderMethod')))
return self.assertFailure(self._render(f), MissingRenderMethod)
def test_simpleXHTMLRendering(self):
"""
Test that a Element with a simple, static xhtml document factory
renders correctly.
"""
f = Element(docFactory=xmlstr("<p>Hello, world.</p>"))
return self._render(f).addCallback(self.assertEquals,
"<p>Hello, world.</p>")
def test_simpleStanRendering(self):
"""
Test that a Element with a simple, static stan document factory
renders correctly.
"""
f = Element(docFactory=stan(p["Hello, world."]))
return self._render(f).addCallback(self.assertEquals,
"<p>Hello, world.</p>")
def test_missingDocumentFactory(self):
"""
L{Element.render} raises L{MissingDocumentFactory} if the C{docFactory}
attribute is C{None}.
"""
element = Element()
err = self.assertRaises(MissingDocumentFactory, element.render, None)
self.assertIdentical(err.element, element)
def test_missingRendererMethod(self):
"""
When called with the name which is not associated with a render method,
L{Element.renderer} raises L{MissingRenderMethod}.
"""
element = Element()
err = self.assertRaises(MissingRenderMethod, element.renderer, "foo")
self.assertIdentical(err.element, element)
self.assertEqual(err.renderName, "foo")
def _instaString(self, x):
"""
Convert a new-style-renderable thing into a string, raising an
exception if any deferred rendering took place.
"""
e = Element(docFactory=stan(x))
l = []
d = deferflatten(None, e, False, False, l.append)
return ''.join(l)
def test_missingDocumentFactory(self):
"""
Test that rendering a Element without a docFactory attribute raises
the appropriate exception.
"""
def cb(ignored):
# The old flattener unconditionally logs errors.
self.flushLoggedErrors(MissingDocumentFactory)
d = self.assertFailure(self._render(Element()), FlattenerError)
d.addCallback(cb)
return d
def test_oldFlattenableError(self):
"""
If the old flattener encounters an asynchronous Failure while
flattening an L{IRenderable}, the returned L{Deferred} fires with the
failure.
"""
result = Deferred()
element = Element()
element.docFactory = stan(result)
request = FakeRequest()
context = WovenContext()
context.remember(request)
accumulator = []
finished = oldFlatten(element, context, accumulator.append, lambda ign: ign)
result.addErrback(lambda err: err.trap(RuntimeError))
finished = self.assertFailure(finished, RuntimeError)
result.errback(RuntimeError("test error"))
return finished
def test_missingRenderMethod(self):
"""
Test that flattening an L{Element} with a C{docFactory} which has a tag
with a render directive fails with L{FlattenerError} if there is no
available render method to satisfy that directive.
"""
element = Element(docFactory=stan(p(render=directive('renderMethod'))))
def cb(ignored):
# The old flattener unconditionally logs errors.
self.flushLoggedErrors(MissingRenderMethod)
d = self.assertFailure(self._render(element), FlattenerError)
d.addCallback(cb)
return d
def rend(self, ctx, data):
contexts.append(ctx)
return Element.rend(self, ctx, data)
def renderMethod(self, request, tag):
return tag[Element(docFactory=stan("Hello, world."))]
def __init__(self, dummy):
Element.__init__(self)
self.dummy = dummy
def __init__(self, original):
self.original = original
Element.__init__(self)
def __init__(self, dummy):
Element.__init__(self)
self.dummy = dummy
def rend(self, ctx, data):
return invisible(render=directive("foo"))[Element.rend(
self, ctx, data)]
def rend(self, ctx, data):
return invisible(render=directive("foo"))[Element.rend(self, ctx, data)]
def rend(self, ctx, data):
contexts.append(ctx)
return Element.rend(self, ctx, data)
def test_renderable(self):
"""
L{Element} implements L{IRenderable}.
"""
self.assertTrue(verifyObject(IRenderable, Element()))
def __init__(self, original):
self.original = original
Element.__init__(self)
