def test_detachWithChildren(self):
"""
Similar to L{test_detach}, but cover the case where the removed element
has a child of its own and verify that that child is also detached.
"""
page = athena.LivePage()
element = self.elementFactory()
element.setFragmentParent(page)
child = self.elementFactory()
child.setFragmentParent(element)
calls = []
def callRemote(methodName):
d = Deferred()
calls.append((methodName, d))
return d
element.callRemote = callRemote
child.callRemote = callRemote
d = element.detach()
self.assertEqual(len(calls), 1)
self.assertEqual(calls[0][0], '_athenaDetachClient')
calls[0][1].callback(None)
self.assertNotIn(element, page.liveFragmentChildren)
self.assertIdentical(element.fragmentParent, None)
self.assertIdentical(element.page, None)
self.assertNotIn(child, element.liveFragmentChildren)
self.assertIdentical(child.fragmentParent, None)
self.assertIdentical(child.page, None)
def test_athenaIdRewriting(self):
"""
Test that IDs are correctly rewritten in id, for, and headers
attributes.
"""
tag = [tags.label(_for='foo'),
tags.input(id='foo'),
tags.th(headers=''),
tags.th(headers='foo'),
tags.td(headers='foo bar'),
tags.td(headers='foo bar baz')]
element = athena.LiveElement(docFactory=loaders.stan(tag))
page = athena.LivePage(docFactory=loaders.stan(element))
element.setFragmentParent(page)
def _verifyRendering(result):
self.assertIn('<input id="athenaid:%s-foo"' % (element._athenaID,), result)
self.assertIn('<label for="athenaid:%s-foo"' % (element._athenaID,), result)
self.assertIn('<th headers=""', result)
self.assertIn('<th headers="athenaid:%s-foo"' % (
element._athenaID,), result)
self.assertIn('<td headers="athenaid:%s-foo athenaid:%s-bar"' % (
element._athenaID, element._athenaID), result)
self.assertIn('<td headers="athenaid:%s-foo athenaid:%s-bar athenaid:%s-baz"' % (
element._athenaID, element._athenaID, element._athenaID), result)
return renderLivePage(page).addCallback(_verifyRendering)
def test_userAgentDetection(self):
"""
C{LivePage._supportedBrowser} should return True for User-Agent strings
which are not known to be supported and False for those which are known
to be unsupported.
"""
page = athena.LivePage()
supported = [
"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)",
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)",
"Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.3)"
" Gecko/20061201 Firefox/2.0.0.3 (Ubuntu-feisty)",
"Mozilla/5.0 (Windows; U; Windows NT 5.2; sv-SE;"
" rv:1.8.0.8) Gecko/20061025 Firefox 1.5.0.8",
"Opera/9.20 (Windows NT 6.0; U; en)"
]
unsupported = [
"Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en)"
" AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3",
"Opera/8.5 (Windows NT 6.0; U; en)",
"Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US;"
" rv:1.7.10) Gecko/20050716 Firefox/1.0.6",
"Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)"
]
for ua in supported:
req = FakeRequest()
req.received_headers['user-agent'] = ua
self.assertTrue(page._supportedBrowser(req))
for ua in unsupported:
req = FakeRequest()
req.received_headers['user-agent'] = ua
self.assertFalse(page._supportedBrowser(req))
def test_detach(self):
"""
Verify that L{detach} informs the client of the event and returns a
Deferred which fires when the client acknowledges this.
"""
page = athena.LivePage()
element = self.elementFactory()
element.setFragmentParent(page)
calls = []
def callRemote(methodName):
d = Deferred()
calls.append((methodName, d))
return d
element.callRemote = callRemote
d = element.detach()
self.assertEqual(len(calls), 1)
self.assertEqual(calls[0][0], '_athenaDetachClient')
calls[0][1].callback(None)
self.assertNotIn(element, page.liveFragmentChildren)
self.assertIdentical(element.fragmentParent, None)
self.assertIdentical(element.page, None)
def test_blogsRenderer(self):
"""
Test that L{hyperbola_view.BlogListFragment.blogs} renders a list of blogs.
"""
site = self.siteStore.findUnique(SiteConfiguration)
site.hostname = u'blogs.renderer'
blog1 = self._shareAndGetProxy(self._makeBlurb(FLAVOR.BLOG))
blog2 = self._shareAndGetProxy(self._makeBlurb(FLAVOR.BLOG))
blf = hyperbola_view.BlogListFragment(
athena.LivePage(), self.publicPresence)
blf.docFactory = loaders.stan(
tags.div(pattern='blog')[
tags.span[tags.slot('title')],
tags.span[tags.slot('link')],
tags.span[tags.slot('post-url')]])
tag = tags.invisible
markup = flat.flatten(tags.div[blf.blogs(None, tag)])
doc = minidom.parseString(markup)
blogNodes = doc.firstChild.getElementsByTagName('div')
self.assertEqual(len(blogNodes), 2)
for (blogNode, blog) in zip(blogNodes, (blog1, blog2)):
(title, blogURL, postURL) = blogNode.getElementsByTagName('span')
blogURL = blogURL.firstChild.nodeValue
expectedBlogURL = str(websharing.linkTo(blog))
self.assertEqual(blogURL, expectedBlogURL)
postURL = postURL.firstChild.nodeValue
self.assertEqual(
postURL, 'https://blogs.renderer' + expectedBlogURL + '/post')
def test_detachCallback(self):
"""
Verify that C{detached} is called C{detach} is called locally.
"""
page = athena.LivePage()
element = self.elementFactory()
element.setFragmentParent(page)
detachCall = []
def detached():
detachCall.append((element.fragmentParent, element.page))
element.detached = detached
calls = []
def callRemote(methodName):
d = Deferred()
calls.append(d)
return d
element.callRemote = callRemote
d = element.detach()
self.assertEqual(detachCall, [])
calls[0].callback(None)
self.assertEqual(detachCall, [(None, None)])
def test_localDetachOrphaned(self):
"""
L{_athenaDetachServer} should raise L{athena.OrphanedFragment} if the
element is not attached.
"""
element = self.elementFactory()
self.assertRaises(athena.OrphanedFragment, element._athenaDetachServer)
page = athena.LivePage()
element.setFragmentParent(page)
element._athenaDetachServer()
self.assertRaises(athena.OrphanedFragment, element._athenaDetachServer)
def test_localDetach(self):
"""
Verify that L{_athenaDetachServer} removes the element from its parent
and disassociates it from the page locally.
"""
page = athena.LivePage()
element = self.elementFactory()
element.setFragmentParent(page)
element._athenaDetachServer()
self.assertNotIn(element, page.liveFragmentChildren)
self.assertIdentical(element.fragmentParent, None)
self.assertIdentical(element.page, None)
def test_unsupportedBrowserPage(self):
"""
Test that unsupported browsers get told they're unsupported.
"""
ctx = WovenContext()
page = athena.LivePage()
req = FakeRequest()
req.received_headers[
'user-agent'] = "Mozilla/4.0 (compatible; MSIE 2.0; Windows NT 5.1)"
ctx.remember(req, IRequest)
d = renderPage(page, reqFactory=lambda: req)
d.addCallback(self.assertEqual,
flat.flatten(page.unsupportedBrowserLoader))
return d
def testFragmentNesting(self):
lp = athena.LivePage()
tf1 = TestFragment()
tf2 = TestFragment()
tf1.setFragmentParent(lp)
tf2.setFragmentParent(tf1)
self.assertEquals(lp.liveFragmentChildren, [tf1])
self.assertEquals(tf1.liveFragmentChildren, [tf2])
self.assertEquals(tf2.liveFragmentChildren, [])
self.assertEquals(tf2.fragmentParent, tf1)
self.assertEquals(tf1.fragmentParent, lp)
self.assertEquals(tf2.page, lp)
self.assertEquals(tf1.page, lp)
def test_blurbViewColumn(self):
"""
Verify the L{xmantissa.ixmantissa.IColumn} implementation of
L{hyperbola_view.BlurbViewColumn}.
"""
col = hyperbola_view.BlurbViewColumn()
self.assertEqual(col.attributeID, 'blurbView')
self.assertEqual(col.getType(), scrolltable.TYPE_WIDGET)
model = athena.LivePage()
frag = col.extractValue(model, self.blogPostSharedToEveryone)
fragClass = hyperbola_view.blurbViewDispatcher(
self.blogPostSharedToEveryone).__class__
self.failUnless(isinstance(frag, fragClass))
self.assertIdentical(frag.fragmentParent, model)
self.failUnless(frag.docFactory)
self.assertIdentical(col.sortAttribute(), None)
self.assertRaises(NotImplementedError, col.toComparableValue, None)
def test_localDetachCallback(self):
"""
Verify that C{detached} is called when C{_athenaDetachServer} is
called.
"""
page = athena.LivePage()
element = self.elementFactory()
element.setFragmentParent(page)
detachCall = []
def detached():
detachCall.append((element.fragmentParent, element.page))
element.detached = detached
element._athenaDetachServer()
self.assertEqual(detachCall, [(None, None)])
def test_elementPreprocessors(self):
"""
Make sure that LiveElements have their preprocessors applied to their
document.
"""
preprocessed = []
tag = tags.span
element = athena.LiveElement(docFactory=loaders.stan(tag))
page = athena.LivePage(docFactory=loaders.stan(element))
element.preprocessors = [preprocessed.append]
element.setFragmentParent(page)
renderDeferred = self._render(page)
def rendered(result):
page.action_close(None)
self.assertEquals(preprocessed, [[tag]])
renderDeferred.addCallback(rendered)
return renderDeferred
def test_localDetachWithChildren(self):
"""
Similar to L{test_localDetach}, but cover the case where the removed
element has a child of its own and verify that that child is also
detached.
"""
page = athena.LivePage()
element = self.elementFactory()
element.setFragmentParent(page)
child = self.elementFactory()
child.setFragmentParent(element)
element._athenaDetachServer()
self.assertNotIn(element, page.liveFragmentChildren)
self.assertIdentical(element.fragmentParent, None)
self.assertIdentical(element.page, None)
self.assertNotIn(child, element.liveFragmentChildren)
self.assertIdentical(child.fragmentParent, None)
self.assertIdentical(child.page, None)
def testInsideOutFragmentNesting(self):
"""
Test that even if LiveFragments have their parents assigned from the
inside out, parent/child relationships still end up correct.
"""
innerFragment = TestFragment()
outerFragment = TestFragment()
page = athena.LivePage()
innerFragment.setFragmentParent(outerFragment)
outerFragment.setFragmentParent(page)
self.assertEquals(page.liveFragmentChildren, [outerFragment])
self.assertEquals(outerFragment.fragmentParent, page)
self.assertEquals(outerFragment.page, page)
self.assertEquals(outerFragment.liveFragmentChildren, [innerFragment])
self.assertEquals(innerFragment.fragmentParent, outerFragment)
self.assertEquals(innerFragment.page, page)
def renderWidget(widget, debug=False):
"""
Flatten and render a widget.
@rtype: C{Deferred} -> C{ElementTree}
@return: A deferred that fires with the parsed flattened output.
"""
def parse(result):
return etree.ElementTree(
etree.fromstring('<widget>' + result + '</widget>'))
def printIt(result):
print result
return result
page = athena.LivePage(docFactory=loaders.stan(widget))
widget.setFragmentParent(page)
d = renderLivePage(page)
if debug:
d.addCallback(printIt)
d.addCallback(parse)
return d
def setUp(self):
"""
Create and remember a L{LivePage} instance.
"""
self.page = athena.LivePage()
