def _root(self, scheme, hostname, portObj, standardPort): # TODO - real unicode support (but punycode is so bad) if portObj is None: return None portNumber = portObj.portNumber port = portObj.listeningPort if hostname is None: hostname = self.hostname else: hostname = hostname.split(':')[0].encode('ascii') if portNumber == 0: if port is None: return None else: portNumber = port.getHost().port # At some future point, we may want to make pathsegs persistently # configurable - perhaps scheme and hostname as well - in order to # easily support reverse proxying configurations, particularly where # Mantissa is being "mounted" somewhere other than /. See also rootURL # which has some overlap with this method (the difference being # universal vs absolute URLs - rootURL may want to call cleartextRoot # or encryptedRoot in the future). See #417 and #2309. pathsegs = [''] if portNumber != standardPort: hostname = '%s:%d' % (hostname, portNumber) return URL(scheme, hostname, pathsegs)
def test_rootURLWithoutHost(self): """ L{SiteConfiguration.rootURL} returns C{/} for a request made without a I{Host} header. """ request = FakeRequest() self.assertEqual(self.site.rootURL(request), URL('', ''))
def test_rootURL(self): """ L{SiteConfiguration.rootURL} returns C{/} for a request made onto the hostname with which the L{SiteConfiguration} is configured. """ request = FakeRequest(headers={'host': self.domain.encode('ascii')}) self.assertEqual(self.site.rootURL(request), URL('', ''))
def test_rootURLWWWSubdomain(self): """ L{SiteConfiguration.rootURL} returns C{/} for a request made onto the I{www} subdomain of the hostname of the L{SiteConfiguration}. """ request = FakeRequest( headers={'host': 'www.' + self.domain.encode('ascii')}) self.assertEqual(self.site.rootURL(request), URL('', ''))
def _differentHostnameNonstandardPort(self, portType, isSecure, scheme): portNumber = 12345 request = FakeRequest( isSecure=isSecure, headers={'host': 'alice.' + self.domain.encode('ascii')}) portType(store=self.store, factory=self.site, portNumber=portNumber) self.assertEqual( self.site.rootURL(request), URL(scheme, '%s:%s' % (self.domain.encode('ascii'), portNumber)))
def test_rootURLNonstandardRequestPort(self): """ L{SiteConfiguration.rootURL} returns C{/} for a request made onto a non-standard port which is one on which the L{SiteConfiguration} is configured to listen. """ request = FakeRequest( headers={'host': '%s:%s' % (self.domain.encode('ascii'), 54321)}) TCPPort(store=self.store, factory=self.site, portNumber=54321) self.assertEqual(self.site.rootURL(request), URL('', ''))
def _portZero(self, portType, scheme, method): randomPort = 7777 class FakePort(object): def getHost(self): return IPv4Address('TCP', u'example.com', randomPort) port = portType(store=self.store, portNumber=0, factory=self.site) port.listeningPort = FakePort() self.assertEquals( getattr(self.site, method)(), URL(scheme, '%s:%s' % (self.domain, randomPort)))
def test_rootURLAlternateSubdomain(self): """ L{SiteConfiguration.rootURL} returns C{/} for a request made onto a subdomain known as an internal domain. """ userbase.LoginMethod(store=self.store, localpart=u'username', domain=u'example.org', internal=True, protocol=u'*', verified=True, account=self.store) request = FakeRequest(headers={'host': 'example.org'}) self.assertEqual(self.site.rootURL(request), URL('', ''))
def test_renderHTTPNeedsSecure(self): """ L{SecuringWrapper.renderHTTP} returns a L{URL} pointing at the same location as the request URI but with an https scheme if the wrapped resource has a C{needsSecure} attribute with a true value and the request is over http. """ SSLPort(store=self.store, factory=self.urlGenerator, portNumber=443) request = FakeRequest(isSecure=False, uri='/bar/baz', currentSegments=['bar', 'baz']) self.resource.needsSecure = True result = self.wrapper.renderHTTP(request) self.assertEqual( result, URL('https', self.urlGenerator.hostname, ['bar', 'baz']))
def test_getJSModuleURL(self): """ L{MantissaLivePage.getJSModuleURL} should return a child of its C{_moduleRoot} attribute of the form:: _moduleRoot/<SHA1 digest of module contents>/Package.ModuleName """ module = 'Mantissa' url = URL(scheme='https', netloc='example.com', pathsegs=['foo']) page = MantissaLivePage(None) page._moduleRoot = url jsDir = FilePath(__file__).parent().parent().child("js") modulePath = jsDir.child(module).child("__init__.js") moduleContents = modulePath.open().read() expect = sha.new(moduleContents).hexdigest() self.assertEqual(page.getJSModuleURL(module), url.child(expect).child(module))
def test_jsCaching(self): """ Rendering a L{MantissaLivePage} causes each of its dependent modules to be loaded at most once. """ _realdeps = AthenaModule.dependencies def dependencies(self): self.count = getattr(self, 'count', 0) + 1 return _realdeps(self) self.patch(AthenaModule, 'dependencies', dependencies) module = jsDeps.getModuleForName('Mantissa.Test.Dummy.DummyWidget') module.count = 0 root = URL(netloc='example.com', pathsegs=['a', 'b']) class FakeWebSite(object): def rootURL(self, request): return root def _renderPage(): page = MantissaLivePage(FakeWebSite()) element = LiveElement( stan(tags.span(render=tags.directive('liveElement')))) element.setFragmentParent(page) element.jsClass = u'Mantissa.Test.Dummy.DummyWidget' page.docFactory = stan( [tags.span(render=tags.directive('liveglue')), element]) ctx = WovenContext() req = FakeRequest(headers={'host': self.hostname}) ctx.remember(req, IRequest) page.beforeRender(ctx) page.renderHTTP(ctx) page._messageDeliverer.close() # Make sure we have a fresh dependencies memo. self.patch(theHashModuleProvider, 'depsMemo', {}) _renderPage() self.assertEqual(module.count, 1) _renderPage() self.assertEqual(module.count, 1)
def test_beforeRenderSetsModuleRoot(self): """ L{MantissaLivePage.beforeRender} should set I{_moduleRoot} to the C{__jsmodule__} child of the URL returned by the I{rootURL} method of the L{WebSite} it wraps. """ receivedRequests = [] root = URL(netloc='example.com', pathsegs=['a', 'b']) class FakeWebSite(object): def rootURL(self, request): receivedRequests.append(request) return root request = FakeRequest() page = MantissaLivePage(FakeWebSite()) page.beforeRender(request) self.assertEqual(receivedRequests, [request]) self.assertEqual(page._moduleRoot, root.child('__jsmodule__'))
def rootURL(self, request): """ Return the URL for the root of this website which is appropriate to use in links generated in response to the given request. @type request: L{twisted.web.http.Request} @param request: The request which is being responded to. @rtype: L{URL} @return: The location at which the root of the resource hierarchy for this website is available. """ host = request.getHeader('host') or self.hostname if ':' in host: host = host.split(':', 1)[0] if (host == self.hostname or host.startswith('www.') and host[len('www.'):] == self.hostname): return URL(scheme='', netloc='', pathsegs=['']) else: if request.isSecure(): return self.encryptedRoot(self.hostname) else: return self.cleartextRoot(self.hostname)
def _nonstandardPortTest(self, portType, scheme, portNumber, method): portType(store=self.store, portNumber=portNumber, factory=self.site) self.assertEquals( getattr(self.site, method)(), URL(scheme, '%s:%s' % (self.domain, portNumber)))
def _baseTest(self, portType, scheme, portNumber, method): portType(store=self.store, portNumber=portNumber, factory=self.site) self.assertEquals( getattr(self.site, method)(), URL(scheme, self.domain))
def _differentHostnameTest(self, portType, portNumber, isSecure, scheme): request = FakeRequest( isSecure=isSecure, headers={'host': 'alice.' + self.domain.encode('ascii')}) portType(store=self.store, factory=self.site, portNumber=portNumber) self.assertEqual(self.site.rootURL(request), URL(scheme, self.domain))
def _hostOverrideTest(self, portType, scheme, portNumber, method): portType(store=self.store, portNumber=portNumber, factory=self.site) self.assertEquals( getattr(self.site, method)(u'example.net'), URL(scheme, 'example.net'))