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()