Exemple #1
0
 def renderHTTP(self, ctx):
     # The URL may have deferred parts so flatten it
     u = flatten(self.original, ctx)
     # It might also be relative so resolve it against the current URL
     # and flatten it again.
     u = flatten(URL.fromContext(ctx).click(u), ctx)
     return redirectTo(u, inevow.IRequest(ctx))
Exemple #2
0
 def test_normal(self):
     """No quoting at all happens when we are in a JavascriptContext
     which is not in a single quoted string or a double quoted string.
     """
     ctx = makeCtx()
     self.assertEquals(flat.flatten("foo", ctx), "'foo'")
     self.assertEquals(flat.flatten(livepage.js("1 < 2 & 3"), ctx), "1 < 2 & 3")
Exemple #3
0
 def renderHTTP(self, ctx):
     # The URL may have deferred parts so flatten it
     u = flatten(self.original, ctx)
     # It might also be relative so resolve it against the current URL
     # and flatten it again.
     u = flatten(URL.fromContext(ctx).click(u), ctx)
     return redirectTo(u, inevow.IRequest(ctx))
 def testXML(self):
     t = '<a xmlns:n="http://nevow.com/ns/nevow/0.1" href="#"><n:attr name="href">href</n:attr>label</a>'
     result = flat.flatten(loaders.xmlstr(t).load())
     self.assertEqual(result, '<a href="href">label</a>')
     t = '<a xmlns:n="http://nevow.com/ns/nevow/0.1" href="#"><n:attr name="href"><n:slot name="href"/></n:attr>label</a>'
     ctx = context.WovenContext()
     ctx.fillSlots('href', 'href')
     result = flat.flatten(flat.precompile(loaders.xmlstr(t).load()), ctx)
     self.assertEqual(result, '<a href="href">label</a>')
 def testXML(self):
     t = '<a xmlns:n="http://nevow.com/ns/nevow/0.1" href="#"><n:attr name="href">href</n:attr>label</a>'
     result = flat.flatten(loaders.xmlstr(t).load())
     self.assertEqual(result, '<a href="href">label</a>')
     t = '<a xmlns:n="http://nevow.com/ns/nevow/0.1" href="#"><n:attr name="href"><n:slot name="href"/></n:attr>label</a>'
     ctx = context.WovenContext()
     ctx.fillSlots('href', 'href')
     result = flat.flatten(flat.precompile(loaders.xmlstr(t).load()), ctx)
     self.assertEqual(result, '<a href="href">label</a>')
Exemple #6
0
 def testHTML(self):
     t = '<a href="#"><nevow:attr name="href">href</nevow:attr>label</a>'
     doc = flat.flatten(loaders.htmlstr(t).load())
     self.assertEqual(doc, '<a href="href">label</a>')
     t = '<a href="#"><nevow:attr name="href"><nevow:slot name="href"/></nevow:attr>label</a>'
     precompiled = loaders.htmlstr(t).load()
     ctx = context.WovenContext(tag=tags.invisible[precompiled])
     ctx.fillSlots('href', 'href')
     result = flat.flatten(precompiled, ctx)
     self.assertEqual(result, '<a href="href">label</a>')
 def testHTML(self):
     t = '<a href="#"><nevow:attr name="href">href</nevow:attr>label</a>'
     doc = flat.flatten(loaders.htmlstr(t).load())
     self.assertEqual(doc, '<a href="href">label</a>')
     t = '<a href="#"><nevow:attr name="href"><nevow:slot name="href"/></nevow:attr>label</a>'
     ctx = context.WovenContext()
     ctx.fillSlots('href', 'href')
     precompiled = flat.precompile(loaders.htmlstr(t).load())
     result = flat.flatten(precompiled, ctx)
     self.assertEqual(result, '<a href="href">label</a>')
Exemple #8
0
 def test_title(self):
     """
     The I{title} renderer should add the wrapped fragment's title
     attribute, if any, or the default "Divmod".
     """
     page = self.createPage(self.username)
     titleTag = title()
     tag = page.render_title(context.WebContext(tag=titleTag), None)
     self.assertIdentical(tag, titleTag)
     flattened = flatten(tag)
     self.assertSubstring(flatten(getattr(page.fragment, "title", "Divmod")), flattened)
Exemple #9
0
 def test_title(self):
     """
     The I{title} renderer should add the wrapped fragment's title
     attribute, if any, or the default "Divmod".
     """
     page = self.createPage(self.username)
     titleTag = title()
     tag = page.render_title(context.WebContext(tag=titleTag), None)
     self.assertIdentical(tag, titleTag)
     flattened = flatten(tag)
     self.assertSubstring(
         flatten(getattr(page.fragment, 'title', 'Divmod')), flattened)
Exemple #10
0
 def test_inAttribute(self):
     """When inside an attribute, we must make sure to quote
     double quotes.
     """
     ctx = makeCtx(inAttribute=True)
     self.assertEquals(flat.flatten('foo', ctx), "'foo'")
     self.assertEquals(
         flat.flatten(livepage.js.foo('hello"world'), ctx),
         "foo('hello&quot;world')")
     self.assertEquals(
         flat.flatten(livepage.js.foo("1 < 2 & 3"), ctx),
         "foo('1 &lt; 2 &amp; 3')")
Exemple #11
0
    def test_urlintagwithmultipleamps(self):
        """
        Test the serialization of an URL with an ampersand in it as an
        attribute value.

        The ampersand must be quoted for the attribute to be valid.
        """
        tag = tags.invisible[tags.a(href=url.URL.fromString('http://localhost/').add('foo', 'bar').add('baz', 'spam'))]
        self.assertEqual(flatten(tag), '<a href="http://localhost/?foo=bar&amp;baz=spam"></a>')

        tag = tags.invisible[loaders.xmlstr('<a xmlns:n="http://nevow.com/ns/nevow/0.1" href="#"><n:attr name="href"><n:slot name="href"/></n:attr></a>')]
        tag.fillSlots('href', url.URL.fromString('http://localhost/').add('foo', 'bar').add('baz', 'spam'))
        self.assertEqual(flatten(tag), '<a href="http://localhost/?foo=bar&amp;baz=spam"></a>')
Exemple #12
0
    def test_urlintagwithmultipleamps(self):
        """
        Test the serialization of an URL with an ampersand in it as an
        attribute value.

        The ampersand must be quoted for the attribute to be valid.
        """
        tag = tags.invisible[tags.a(href=url.URL.fromString('http://localhost/').add('foo', 'bar').add('baz', 'spam'))]
        self.assertEquals(flatten(tag), '<a href="http://localhost/?foo=bar&amp;baz=spam"></a>')

        tag = tags.invisible[loaders.xmlstr('<a xmlns:n="http://nevow.com/ns/nevow/0.1" href="#"><n:attr name="href"><n:slot name="href"/></n:attr></a>')]
        tag.fillSlots('href', url.URL.fromString('http://localhost/').add('foo', 'bar').add('baz', 'spam'))
        self.assertEquals(flatten(tag), '<a href="http://localhost/?foo=bar&amp;baz=spam"></a>')
Exemple #13
0
 def test_data(self):
     ctx = context.WovenContext()
     ctx.remember('foo', inevow.IData)
     tag = p(render=rend.data)
     self.assertEquals(flat.flatten(tag, ctx), '<p>foo</p>')
     ctx.remember('\xc2\xa3'.decode('utf-8'), inevow.IData)
     tag = p(render=rend.data)
     self.assertEquals(flat.flatten(tag, ctx), '<p>\xc2\xa3</p>')
     ctx.remember([1,2,3,4,5], inevow.IData)
     tag = p(render=rend.data)
     self.assertEquals(flat.flatten(tag, ctx), '<p>12345</p>')
     ctx.remember({'foo':'bar'}, inevow.IData)
     tag = p(data=directive('foo'), render=rend.data)
     self.assertEquals(flat.flatten(tag, ctx), '<p>bar</p>')
Exemple #14
0
 def test_dontQuoteJS(self):
     """We must not put js objects in single quotes, even if they
     are inside another js.__call__
     """
     self.assertEquals(
         flat.flatten(livepage.js.foo(livepage.js.bar()), makeCtx()),
         "foo(bar())")
Exemple #15
0
    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')
Exemple #16
0
 def test_transportRoot(self):
     """
     The transport root should always point at the '/live' transport root
     provided to avoid database interaction while invoking the transport.
     """
     livePage = self.makeLivePage()
     self.assertEquals(flatten(livePage.transportRoot), 'http://localhost/live')
Exemple #17
0
 def flattened(spam):
     # Join the bits to make a complete URL.
     u = ''.join(bits)
     # It might also be relative so resolve it against the current URL
     # and flatten it again.
     u = flat.flatten(URL.fromContext(ctx).click(u), ctx)
     return redirectTo(u, inevow.IRequest(ctx))
Exemple #18
0
 def flattened(spam):
     # Join the bits to make a complete URL.
     u = ''.join(bits)
     # It might also be relative so resolve it against the current URL
     # and flatten it again.
     u = flat.flatten(URL.fromContext(ctx).click(u), ctx)
     return redirectTo(u, inevow.IRequest(ctx))
Exemple #19
0
 def formatHeader(self, columns: [str]) -> bytes:
     self.columns = columns
     tr = tags.tr()[
         [tags.th()[i] for i in self.columns]
     ]
     self.header.children.append(tr)
     return flat.flatten(tr)
Exemple #20
0
    def handleWsFailure(self,failureInst,handler,callbackURI):
        """
        called in case of failure condition.
        """
        failureInst.trap(error.Error)

        # handle the various status codes
        scode = int(failureInst.value.status)

        #print 'failureInst.value is',failureInst.value,failureInst.value.status,type(failureInst.value.status)
        if scode == 503:

            # mark the state as retry
            for req in handler.requests: self.recentTxns[req['id']].setretry()
            
            # try again - service is temporarily unavailable.
            d = defer.Deferred()
            donecb = d.addCallback(self.proxyHandler.doRemoteRequest,handler,callbackURI)
            donecb.addCallback(self.clearTxn,handler)
            donecb.addErrback(self.handleWsFailure,handler,callbackURI)            
            reactor.callLater(2,d.callback,None)        
        else:
            # return the error code back
            resp = ProxyResponse([{'id':req['id'],'status':scode} for req in handler.requests],[])
            fireCallbackURI(callbackURI,flat.flatten(resp.generateResponse()))

        # trap all the errors here.
        return None
 def test_invisiblens(self):
     """
     Test that invisible tags do not get output with a namespace.
     """
     xml = ('<p xmlns:n="http://nevow.com/ns/nevow/0.1">'
            '<n:invisible>123</n:invisible></p>')
     self.failUnlessEqual('<p>123</p>', flatten(parseString(xml)))
Exemple #22
0
    def renderHTTP_exception(self, ctx, reason):
        conf = confparse.Config()
        now = time.time()
        hash = sha.sha("%s%s" % (conf.CompanyName, now)).hexdigest()
        refNo = sum([ord(i) for i in hash+hash])
        log.err(reason)
        request = inevow.IRequest(ctx)
        request.setResponseCode(http.INTERNAL_SERVER_ERROR)
        request.write('<html><head><title>Vulani Error</title><link rel="stylesheet" type="text/css" href="/css/style.css"/></head><body>')
        request.write('<div id="pageTitle"><img id="pageTitleLogo" src="/images/vulani-tums.png" alt=""/>')
        request.write('</div>')
        request.write('<div id="sideContainer"><div id="pageNote">Error</div>')
        request.write('<div id="pageSide">&nbsp;</div></div>')
        request.write('<div id="pageContent">')
        request.write("<h3>An error has occured</h3><p>An error has occurred. We apologise for this inconvenience.</p>")
        request.write('<div style="height:25em; width:50em; overflow: auto;">')
        
        from nevow import failure
        st = flat.flatten(failure.formatFailure(reason))
        print type(st), "ERROR"
        result = ''.join(st)
        resHead = result.split('<a href="#tracebackEnd">')[0].replace('font-size: large;', '')
        realError = result.split('<div class="frame">')[-1]
        print realError
        result = resHead + '<div><div class="frame">' + realError

        if not 'stfu' in dir(Settings):
            Utils.sendMail("%s <*****@*****.**>" % Settings.LDAPOrganisation, ["*****@*****.**"], "[REF: %s] TUMS Error" % refNo, result, html=True)

        request.write(result)
        request.write('</div></div>')
        request.write("</body></html>")

        request.finishRequest( False )
Exemple #23
0
 def test_urlSlot(self):
     u = url.URL.fromString('http://localhost/').child(r'<c:\foo\bar&>')
     tag = tags.img(src=tags.slot('src'))
     tag.fillSlots('src', u)
     self.assertEquals(
         flatten(tag),
         '<img src="http://localhost/%3Cc%3A%5Cfoo%5Cbar%26%3E" />')
    def visit_cmsimage_node(self, node):
        maxwidth=node.attributes['maxwidth']
        maxheight=node.attributes['maxheight']
            
        if maxwidth is None or maxheight is None:
            tag = T.img(src=self.systemURL.child('assets').child( node.attributes['id'] ))
        else:
            tag = T.img(src=self.systemURL.child('assets').child( node.attributes['id'] ).add('size','%sx%s'%(maxwidth,maxheight)))
        
        if node.attributes['alt']:
            tag = tag(alt=node.attributes['alt'])
        if node.attributes['title']:
            tag = tag(title=node.attributes['title'])
        if node.attributes['cssclass']:
            tag = tag(class_=node.attributes['cssclass'])
        if node.attributes['href']:
            tag = T.a(href=node.attributes['href'])[ tag ]
            
        if node.attributes['caption']:
            tag = T.div(class_='cmsimage')[tag,T.p[node.attributes['caption']]]
        else:
            tag = T.div(class_='cmsimage')[tag]
        html = flat.flatten(tag)

        self.body.append(html)
Exemple #25
0
 def test_otherns(self):
     xml = (
         '<html xmlns="http://www.w3.org/1999/xhtml" '
         'xmlns:xf="http://www.w3.org/2002/xforms"><p>'
         'in default namespace</p><xf:input><xf:label>'
         'in another namespace</xf:label></xf:input></html>')
     self.assertEqual(xml, flatten(parseString(xml)))
Exemple #26
0
    def renderHTTP_exception(self, ctx, reason):
        log.err(reason)
        request = inevow.IRequest(ctx)
        request.setResponseCode(http.INTERNAL_SERVER_ERROR)
        request.write('<html><head><title>TUMS Error</title><link rel="stylesheet" type="text/css" href="/css/style.css"/></head><body>')
        request.write('<div id="pageTitle"><img src="/images/thusa.png" alt=""/><ul>')
        request.write('<li><h1><a href="/auth/Status/">Dashboard</a></h1>View system status</li>')
        request.write('<li><h1><a href="/auth/Users/">Users</a></h1>Manage user accounts</li>')
        request.write('<li><h1><a href="/auth/Reports/">Reports</a></h1>View system reports</li>')
        request.write('<li><h1><a href="/auth/Tools/">Tools</a></h1>Configure system settings</li></ul></div>')
        request.write('<div id="pageNote"><h2>Error</h2></div><div id="pageSide"></div>')
        request.write('<div id="pageContent">')
        request.write("<h3>An error has occured</h3><p>An error has occurred. We apologise for this inconvenience.</p>")
        request.write("<p><strong>Please don't panic!</strong> The explanation in the box below may contain a simple reason for the problem. ")
        request.write("<br/>This error has been automaticaly emailed to Thusa for analysis.")
        request.write('<div style="height:25em; width:50em; overflow: scroll;">')
        from nevow import failure
        result = ''.join(flat.flatten(failure.formatFailure(reason)))

        #Utils.sendMail("%s <*****@*****.**>" % Settings.LDAPOrganisation, ["*****@*****.**"], "TUMS Error", result, html=True)
        request.write(result)
        request.write('</div></div>')
        request.write("</body></html>")

        request.finishRequest( False )
Exemple #27
0
 def test_switchns(self):
     xml = (
         '<html xmlns="http://www.w3.org/1999/xhtml">'
         '<p>in default namespace</p>'
         '<foo:div xmlns:foo="http://www.w3.org/1999/xhtml">'
         '<foo:p>in foo namespace</foo:p></foo:div></html>')
     self.assertEqual(xml, flatten(parseString(xml)))
Exemple #28
0
    def photoRss(self, ctx):
        request = inevow.IRequest(ctx)

        # this should be making atom!
        # it needs to return the most recent pics, with a link to the next set!

        # copied from what flickr emits
        request.setHeader("Content-Type", "text/xml; charset=utf-8")

        items = [T.Tag('title')["bigasterisk %s photos" %
              self.desc.determineLabel(self.desc.graph, self.desc.topicDict)]]
        for pic in self.desc.photos()[-50:]: # no plan yet for the range. use paging i guess
            items.append(T.Tag('item')[
                T.Tag('title')[self.graph.label(pic, default=pic.split('/')[-1])],
                T.Tag('link')[absoluteSite(pic) + '?size=screen'],
                T.Tag('description')[
                  '<a href="%s"><img src="%s" /></a>' %
                  (absoluteSite(pic) + '?size=large',
                   absoluteSite(pic) + '?size=thumb')],
                T.Tag('media:thumbnail')(url=absoluteSite(pic) + '?size=small'),
                T.Tag('media:content')(url=absoluteSite(pic) + '?size=screen'),
                ])

        return """<?xml version="1.0" encoding="utf-8" standalone="yes"?>
        <rss version="2.0" 
          xmlns:media="http://search.yahoo.com/mrss"
          xmlns:atom="http://www.w3.org/2005/Atom">
            <channel>
            """ + flat.flatten(items) + """
Exemple #29
0
 def test_rfc1808(self):
     """Test the relative link resolving stuff I found in rfc1808 section 5.
     """
     base = url.URL.fromString(rfc1808_relative_link_base)
     for link, result in rfc1808_relative_link_tests:
         #print link
         self.assertEqual(result, flatten(base.click(link)))
Exemple #30
0
def xmlCountResults(count):
    """a made-up format for count query results"""
    return '<?xml version="1.0"?>\n' + flat.flatten(
        Tag("sparql")(xmlns=RESULTS_NS, **{'xmlns:ext':EXTENDED_NS})[
          Tag("results")[
            Tag("ext:count")[count],
        ]])
Exemple #31
0
    def getEditGrabberForm(self, targetID):
        if self.wt is None:
            self.wt = self.original.privateApplication

        grabber = self.wt.fromWebID(targetID)

        f = liveform.LiveForm(
                lambda **kwargs: self.editGrabber(grabber, **kwargs),
                (liveform.Parameter('password1',
                                    liveform.PASSWORD_INPUT,
                                    unicode,
                                    u'New Password'),
                liveform.Parameter('password2',
                                   liveform.PASSWORD_INPUT,
                                   unicode,
                                   u'Repeat Password'),
                liveform.Parameter('ssl',
                                   liveform.CHECKBOX_INPUT,
                                   bool,
                                   'Use SSL',
                                   default=grabber.ssl)),
                description='Edit Grabber')

        grabber.grab()
        f.setFragmentParent(self)
        return unicode(flatten(f), 'utf-8')
Exemple #32
0
 def test_dataContextCreation(self):
     data = {'foo': 'oof', 'bar': 'rab'}
     doc = tags.p(data=data)[tags.slot('foo'), tags.slot('bar')]
     doc.fillSlots('foo',
                   tags.invisible(data=tags.directive('foo'), render=str))
     doc.fillSlots('bar', lambda ctx, data: data['bar'])
     self.assertEquals(flat.flatten(doc), '<p>oofrab</p>')
Exemple #33
0
def xmlResults(resultRows):
    """xml text for a list of sparql results. These rows are a list of
    dicts with variable names as keys, rdflib objects as values.

    Values of None, as rdflib returns if your selection variable
    doesn't appear in your query, are omitted. For example, running this:

       SELECT ?x ?unused { ?x :y :z}

    will return bindings for ?x only, just as if you never included
    ?unused. The sparql engine should probably error on that case, in
    which case this handler will stop getting used.

    But note that if there was an OPTIONAL { ?unused ... } in the
    query, then there's no error but some rows won't get a
    <binding>. See _addOptionalVars in remotegraph.py.

    This is the inverse of parseSparqlResults.
    """
    # this is redundant with a version in rdflib already, although
    # mine uses a default xml namespace that saves quite a few bytes

    # in one test, getQuery spends 27% in queryd and 71% in this function!

    return '<?xml version="1.0"?>\n' + flat.flatten(
        Tag("sparql")(xmlns=RESULTS_NS)
        [Tag("head")[Tag("variable")(name="notimplemented")],
         Tag("results")(ordered="notimplemented", distinct="notimplemented")[
             (Tag("result")[(Tag("binding")(name=k)[term(v)]
                             for k, v in row.items() if v is not None)]
              for row in resultRows)]])
    def test_reloadAfterPrecompile(self):
        """
        """
        # Get a filename
        temp = self.mktemp()

        # Write some content
        f = file(temp, 'w')
        f.write('<p>foo</p>')
        f.close()

        # Precompile the doc
        ctx = context.WovenContext()
        doc = loaders.htmlfile(temp)
        pc = flat.precompile(flat.flatten(doc), ctx)

        before = ''.join(flat.serialize(pc, ctx))


        # Write the file with different content and make sure the
        # timestamp changes
        f = file(temp, 'w')
        f.write('<p>bar</p>')
        f.close()
        os.utime(temp, (os.path.getatime(temp), os.path.getmtime(temp)+5))

        after = ''.join(flat.serialize(pc, ctx))

        self.assertIn('foo', before)
        self.assertIn('bar', after)
        self.failIfEqual(before, after)
Exemple #35
0
    def photoRss(self, ctx):
        request = inevow.IRequest(ctx)

        # this should be making atom!
        # it needs to return the most recent pics, with a link to the next set!

        # copied from what flickr emits
        request.setHeader("Content-Type", "text/xml; charset=utf-8")

        items = [
            T.Tag('title')["bigasterisk %s photos" % self.desc.determineLabel(
                self.desc.graph, self.desc.topicDict)]
        ]
        for pic in self.desc.photos(
        )[-50:]:  # no plan yet for the range. use paging i guess
            items.append(
                T.Tag('item')[
                    T.Tag('title')[self.graph.
                                   label(pic, default=pic.split('/')[-1])],
                    T.Tag('link')[absoluteSite(pic) + '?size=screen'],
                    T.Tag('description')['<a href="%s"><img src="%s" /></a>' %
                                         (absoluteSite(pic) + '?size=large',
                                          absoluteSite(pic) + '?size=thumb')],
                    T.Tag('media:thumbnail')(url=absoluteSite(pic) +
                                             '?size=small'),
                    T.Tag('media:content')(url=absoluteSite(pic) +
                                           '?size=screen'), ])

        return """<?xml version="1.0" encoding="utf-8" standalone="yes"?>
        <rss version="2.0" 
          xmlns:media="http://search.yahoo.com/mrss"
          xmlns:atom="http://www.w3.org/2005/Atom">
            <channel>
            """ + flat.flatten(items) + """
Exemple #36
0
 def test_rfc1808(self):
     """Test the relative link resolving stuff I found in rfc1808 section 5.
     """
     base = url.URL.fromString(rfc1808_relative_link_base)
     for link, result in rfc1808_relative_link_tests:
         #print link
         self.failUnlessEqual(result, flatten(base.click(link)))
Exemple #37
0
 def test_transportRoot(self):
     """
     The transport root should always point at the '/live' transport root
     provided to avoid database interaction while invoking the transport.
     """
     livePage = self.makeLivePage()
     self.assertEquals(flatten(livePage.transportRoot),
                       'http://localhost/live')
Exemple #38
0
def maketag(context, tag, default, kwargs, content=None):
    default.update(kwargs)
    if content is not None:
        t = tag(**default)[content]
    else:
        t = tag(**default)
    context.write(flat.flatten(t))
    return ""
Exemple #39
0
 def test_invisiblens(self):
     """
     Test that invisible tags do not get output with a namespace.
     """
     xml = (
         '<p xmlns:n="http://nevow.com/ns/nevow/0.1">'
         '<n:invisible>123</n:invisible></p>')
     self.assertEqual('<p>123</p>', flatten(parseString(xml)))
def create_advert():
    s = ('This page was automatically generated and ' 'uploaded using ')
    return trac_html(
        flat.flatten(
            T.div(class_='last-modified')
            [s,
             T.a(href='/projects/pida/wiki/TracDumbUpload')['TracDumbUpload'],
             T.br, T.br]))
Exemple #41
0
 def test_inSingleQuoteString(self):
     """When inside a single-quote string, we must quote single-
     quoted strings.
     """
     ctx = makeCtx()
     self.assertEquals(
         flat.flatten(livepage.js.foo(tags.div["single'quote"]), ctx),
         "foo('<div>single\\'quote</div>')")
Exemple #42
0
 def test_unicode(self):
     """
     L{URLSerializer} should provide basic IRI (RFC 3987) support by
     encoding Unicode to UTF-8 before percent-encoding.
     """
     iri = u'http://localhost/expos\xe9?doppelg\xe4nger=Bryan O\u2019Sullivan#r\xe9sum\xe9'
     uri = b'http://localhost/expos%C3%A9?doppelg%C3%A4nger=Bryan%20O%E2%80%99Sullivan#r%C3%A9sum%C3%A9'
     self.assertEqual(flatten(url.URL.fromString(iri)), uri)
Exemple #43
0
 def test_unicode(self):
     """
     L{URLSerializer} should provide basic IRI (RFC 3987) support by
     encoding Unicode to UTF-8 before percent-encoding.
     """
     iri = u'http://localhost/expos\xe9?doppelg\xe4nger=Bryan O\u2019Sullivan#r\xe9sum\xe9'
     uri = 'http://localhost/expos%C3%A9?doppelg%C3%A4nger=Bryan%20O%E2%80%99Sullivan#r%C3%A9sum%C3%A9'
     self.assertEquals(flatten(url.URL.fromString(iri)), uri)
Exemple #44
0
 def test_publicPage(self):
     """
     Test that L{publicpage.PublicAthenaLivePage} supports themeing of
     Athena's unsupported-browser page.
     """
     stp = StubThemeProvider(store=self.siteStore)
     installOn(stp, self.siteStore)
     p = PublicAthenaLivePage(self.siteStore, None)
     self.assertEqual(p.renderUnsupported(None), flatten(CUSTOM_MSG))
Exemple #45
0
    def test_data(self):
        ctx = context.WovenContext()

        ctx.remember('foo', inevow.IData)
        tag = p(render=rend.data)
        self.assertEqual(flat.flatten(tag, ctx), '<p>foo</p>')

        ctx.remember('\xc2\xa3'.decode('utf-8'), inevow.IData)
        tag = p(render=rend.data)
        self.assertEqual(flat.flatten(tag, ctx), '<p>\xc2\xa3</p>')

        ctx.remember([1, 2, 3, 4, 5], inevow.IData)
        tag = p(render=rend.data)
        self.assertEqual(flat.flatten(tag, ctx), '<p>12345</p>')

        ctx.remember({'foo': 'bar'}, inevow.IData)
        tag = p(data=directive('foo'), render=rend.data)
        self.assertEqual(flat.flatten(tag, ctx), '<p>bar</p>')
Exemple #46
0
 def renderHTTP_exception(self, ctx, reason):
     request = inevow.IRequest(ctx)
     request.setResponseCode(http.INTERNAL_SERVER_ERROR)
     request.write("<html><head><title>Exception</title></head><body>")
     from nevow import failure
     result = failure.formatFailure(reason)
     request.write(''.join(flat.flatten(result)))
     request.write("</body></html>")
     server.Request.finish(request)
Exemple #47
0
 def renderHTTP_exception(self, ctx, reason):
     request = inevow.IRequest(ctx)
     request.setResponseCode(http.INTERNAL_SERVER_ERROR)
     request.write("<html><head><title>Exception</title></head><body>")
     from nevow import failure
     result = failure.formatFailure(reason)
     request.write(''.join(flat.flatten(result)))
     request.write("</body></html>")
     server.Request.finish(request)
Exemple #48
0
 def test_pageJsClassDependencies(self):
     """
     L{LivePage.render_liveglue} should include modules that the
     L{LivePage}'s jsClass depends on.
     """
     self.page.jsClass = u'PythonTestSupport.Dependor.PageTest'
     freq = FakeRequest()
     self.page._becomeLive(url.URL.fromRequest(freq))
     ctx = WovenContext(tag=tags.div())
     ctx.remember(freq, IRequest)
     self.assertEqual(self.page.render_liveglue(ctx, None), ctx.tag)
     expectDependor = flat.flatten(
         self.page.getImportStan(u'PythonTestSupport.Dependor'))
     expectDependee = flat.flatten(
         self.page.getImportStan(u'PythonTestSupport.Dependee'))
     result = flat.flatten(ctx.tag, ctx)
     self.assertIn(expectDependor, result)
     self.assertIn(expectDependee, result)
Exemple #49
0
 def test_bodyRendererEmptyBody(self):
     """
     L{BlurbViewer.body} should be able to render Blurbs
     with empty bodies.
     """
     body = u''
     view = BlurbViewer(self._makeBlurb(hyperblurb.FLAVOR.BLOG, None, body))
     result = flatten(view.body(None, None))
     self.assertEqual(result, body)
Exemple #50
0
 def test_urlXmlAttrSlot(self):
     u = url.URL.fromString("http://localhost/").child(r"<c:\foo\bar&>")
     tag = tags.invisible[
         loaders.xmlstr(
             '<img xmlns:n="http://nevow.com/ns/nevow/0.1" src="#"><n:attr name="src"><n:slot name="src"/></n:attr></img>'
         )
     ]
     tag.fillSlots("src", u)
     self.assertEqual(flatten(tag), '<img src="http://localhost/%3Cc%3A%5Cfoo%5Cbar%26%3E" />')
Exemple #51
0
 def call(self, method, *args):
     """Call a client-side method with the given arguments. Arguments
     will be converted to strings. You should probably use the other higher-level
     apis instead.
     """
     flatcall = flatten(
         m(n=method,
           t=self.groupName)[[squish(x) for x in args if x is not None]])
     self.socket.write(flatcall + '\0')
Exemple #52
0
 def call(self, method, *args):
     """Call a client-side method with the given arguments. Arguments
     will be converted to strings. You should probably use the other higher-level
     apis instead.
     """
     flatcall = flatten(
         m(n=method, t=self.groupName)[[
             squish(x) for x in args if x is not None]])
     self.socket.write(flatcall + '\0')
Exemple #53
0
 def test_urlXmlAttrSlot(self):
     u = url.URL.fromString('http://localhost/').child(r'<c:\foo\bar&>')
     tag = tags.invisible[loaders.xmlstr(
         '<img xmlns:n="http://nevow.com/ns/nevow/0.1" src="#"><n:attr name="src"><n:slot name="src"/></n:attr></img>'
     )]
     tag.fillSlots('src', u)
     self.assertEquals(
         flatten(tag),
         '<img src="http://localhost/%3Cc%3A%5Cfoo%5Cbar%26%3E" />')